import * as i0 from '@angular/core';
import { ElementRef, OnInit, InjectionToken, DestroyRef, PipeTransform } from '@angular/core';
import * as rxjs from 'rxjs';
import { Observable, Subject, Subscription } from 'rxjs';
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 _ngrx_effects from '@ngrx/effects';
import { Actions } from '@ngrx/effects';
import { IKeyCode, ImageOutputValues, Area } from '@3dsource/utils';
import { SafeHtml, SafeStyle, SafeScript, SafeUrl, SafeResourceUrl } from '@angular/platform-browser';
import { MetaBoxCommandPacket, MetaBoxCommandList, FSceneState, FProductPayload, FCameraChangedPayload, FTransformJson } from '@3dsource/types-unreal';

declare class AfkTimeoutModalComponent {
    #private;
    readonly isAfkTimerVisible: i0.Signal<boolean>;
    readonly afkCountdown: i0.Signal<number>;
    resetAfk(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AfkTimeoutModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AfkTimeoutModalComponent, "app-afk-timeout-modal", never, {}, {}, never, never, true, never>;
}

declare class FreezeFrameComponent {
    #private;
    readonly freezeFrameProgressMessageFromVideo: i0.Signal<number | null>;
    readonly combinedFreeze: i0.Signal<string | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FreezeFrameComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FreezeFrameComponent, "app-freeze-frame", never, {}, {}, never, never, true, never>;
}

declare class LowBandwidthModalComponent {
    #private;
    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 ImageLoadingSrcComponent {
    #private;
    readonly isLoaderScreenVisible: i0.Signal<boolean>;
    readonly imageLoadingSrc: i0.Signal<string>;
    imageError(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageLoadingSrcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ImageLoadingSrcComponent, "app-image-loading-src", never, {}, {}, never, never, true, never>;
}

declare class StatGraphComponent {
    readonly label: i0.InputSignal<string>;
    readonly stat: i0.InputSignal<{
        value: number;
    } | undefined>;
    readonly color: i0.InputSignal<string>;
    readonly tickStep: i0.InputSignal<number>;
    private el;
    readonly graph: i0.Signal<ElementRef<HTMLCanvasElement> | undefined>;
    private data;
    readonly max: i0.WritableSignal<number>;
    readonly min: i0.WritableSignal<number>;
    readonly current: i0.WritableSignal<number>;
    private canvas;
    private ctx;
    constructor();
    resize(): void;
    private draw;
    private getColor;
    private pushData;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatGraphComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StatGraphComponent, "app-stat-graph", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "stat": { "alias": "stat"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "tickStep": { "alias": "tickStep"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class UnrealSceneComponent {
    #private;
    readonly isStudio: i0.InputSignal<boolean>;
    readonly useContainerAsSizeProvider: i0.InputSignal<boolean>;
    readonly studioResolutionSize: i0.InputSignal<{
        width: number;
        height: number;
    }>;
    studioResolutionValues: rxjs.Observable<{
        width: number;
        height: number;
    }>;
    readonly videoElement: i0.Signal<ElementRef<HTMLDivElement> | undefined>;
    changeMouseOverScene: i0.OutputEmitterRef<boolean>;
    private width;
    private height;
    private readonly actions$;
    private isExistMatchUrls;
    readonly isDevMode: boolean;
    readonly lightMode: i0.Signal<boolean>;
    private isFreezeFrameLoading;
    private readonly maxResolution;
    private commandsSender;
    private videoService;
    private element;
    private destroyRef;
    private get resizeValues();
    private get pixelRatio();
    onMouseOver(): void;
    onMouseOut(): void;
    constructor();
    private listenResizeValues;
    private adaptVideo;
    private getResizeValuesUniversal;
    private getResizeStudioValues;
    private sendResize;
    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-pdf", "app-show-case", "app-low-bandwidth-detector"], true, never>;
}

declare class IntroSrcComponent {
    #private;
    private readonly videoElement;
    protected imageIntroSrc: i0.Signal<string | null>;
    protected videoIntroSrc: i0.Signal<string | null>;
    private viewportReady;
    constructor();
    private createVideo;
    imageError(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IntroSrcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IntroSrcComponent, "app-intro-src", never, {}, {}, never, never, true, never>;
}

interface GraphListItem {
    key: string;
    color: string;
    stat: Observable<{
        value: number;
    }>;
}
declare class VideoStatsComponent implements OnInit {
    readonly collapsed: i0.WritableSignal<boolean>;
    private store;
    private videoService;
    private isDevMode;
    private obs$;
    readonly viewportReady: i0.Signal<boolean>;
    readonly ssInfo: i0.Signal<string>;
    readonly fpsTick: i0.Signal<{
        value: number;
    } | undefined>;
    readonly fpsAvgTick: i0.Signal<{
        value: number;
    } | undefined>;
    readonly bitrateTick: i0.Signal<{
        value: number;
    } | undefined>;
    readonly videoQP: i0.Signal<{
        value: number;
    } | undefined>;
    readonly bitrateAverageTick: i0.Signal<{
        value: number;
    } | undefined>;
    readonly videoStatus: i0.Signal<{
        key: string;
        value: string | number | Record<string, string> | _3dsource_angular_unreal_module.DataFlowCheckResult | {
            local: {
                type: string;
                url: string;
            };
            remote: {
                type: string;
                url: string;
            };
        } | null | undefined;
    }[] | undefined>;
    fields: string[];
    graphList: GraphListItem[];
    graphList$: Observable<GraphListItem[]>;
    private idKey;
    private elementsToShow;
    private trigger$;
    constructor();
    ngOnInit(): void;
    updateGraph(): void;
    toggle(): void;
    toggleGraph($event: MouseEvent, el: string, value?: unknown): 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;
    readonly isCirrusConnected: i0.Signal<boolean>;
    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 const WSCloseCode_NORMAL_CLOSURE = 3000;
declare const WSCloseCode_NORMAL_AFK_TIMEOUT = 3001;
declare const WSCloseCode_NORMAL_MANUAL_DISCONNECT = 3002;
declare const WSCloseCode_FORCE_CIRRUS_CLOSE = 3003;
declare const WSCloseCode_UNKNOWN = 1000;
declare const WSCloseCode_CIRRUS_PLAYER_DISCONNECTED = 1001;
declare const WSCloseCode_CIRRUS_ABNORMAL_CLOSURE = 1006;
declare const WSCloseCode_CIRRUS_MAX_PLAYERS_ERROR = 1013;
declare const WSCloseCode_CIRRUS_STREAMER_KIKED_PLAYER = 1011;
declare const WSCloseCodes: readonly [3000, 3001, 3002, 3003, 1000, 1001, 1006, 1013, 1011];
type WSCloseCodesValues = (typeof WSCloseCodes)[number];

declare const DisconnectReason: {
    readonly Afk: "Afk";
    readonly None: "None";
    readonly Destroy: "Destroy";
    readonly DataChannelClosed: "DataChannelClosed";
    readonly DataChannelTimeout: "DataChannelTimeout";
    readonly WebRTCError: "WebRTCError";
    readonly WebSocketError: "WebSocketError";
    readonly WebSocketClose: "WebSocketClose";
    readonly DropConnection: "DropConnection";
    readonly OrchestrationPlayerDisconnected: "OrchestrationPlayerDisconnected";
    readonly OrchestrationStreamerDisconnected: "OrchestrationStreamerDisconnected";
    readonly IceConnectionFailed: "IceConnectionFailed";
    readonly ReconnectFailed: "ReconnectFailed";
    readonly NewConnectionAttempt: "NewConnectionAttempt";
    readonly AbortEstablishingConnection: "AbortEstablishingConnection";
};
type DisconnectReasonType = (typeof DisconnectReason)[keyof typeof DisconnectReason];
interface ConnectionError {
    reason: DisconnectReasonType;
    message: string;
}

interface CloseReason {
    code: WSCloseCodesValues;
    reason: DisconnectReasonType;
}

interface FreezeFrameMessage {
    dataUrl: string | null;
    progress: number | null;
}

interface ReconnectConfig {
    /** Enable auto-reconnection when WebRTC or DataChannel connection is lost. Default: true */
    enabled?: boolean;
    /** Maximum number of reconnection attempts before giving up. Default: 3 */
    maxAttempts?: number;
    /** Delay in milliseconds between reconnection attempts. Default: 1000 */
    delayMs?: number;
    /** Reconnect on ICE connection failure (disconnected/failed state). Default: true */
    onIceFailure?: boolean;
    /** Reconnect on DataChannel close. Default: true */
    onDataChannelClose?: boolean;
}
interface UnrealInitialConfig {
    customErrorsEndpoint?: string;
    commandTelemetryReceiver?: string;
    regionsPingUrl?: string;
    screenLockerContainerId?: string;
    dataChannelConnectionTimeout?: number;
    fpsMonitor?: boolean;
    playwright?: boolean;
    streamTelemetryV2?: boolean;
    streamTelemetryV2Url?: string;
    /** Configuration for auto-reconnection behavior */
    reconnect?: ReconnectConfig;
}

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 ControlScheme: {
    readonly LockedMouse: 0;
    readonly HoveringMouse: 1;
    readonly Default: 2;
};
type ControlSchemeValues = (typeof ControlScheme)[keyof typeof ControlScheme];

declare const MessageType: {
    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 MessageTypeValues = (typeof MessageType)[keyof typeof MessageType];

declare const ToClientMessage: {
    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 FileExtension: 8;
    readonly FileMimeType: 9;
    readonly FileContents: 10;
    readonly TestEcho: 11;
    readonly InputControlOwnership: 12;
    readonly GamepadResponse: 13;
    readonly Protocol: 255;
};

declare const UNREAL_CONFIG: InjectionToken<UnrealInitialConfig>;

declare const InputOptions: InputProps;

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 POLLING_TIME = 4000;
declare const WS_OPEN_STATE = 1;
declare const DEFAULT_AFK_TIMEOUT_PERIOD = 15;
declare const DEFAULT_AFK_TIMEOUT = 120;
declare const DATA_CHANNEL_CONNECTION_TIMEOUT = 8000;
declare const SIGNALLING_PERCENT_VALUE = 56;
declare const SCREEN_LOCKER_CONTAINER_ID = "3dsource_start_screen";
declare const DEFAULT_RECONNECT_ENABLED = true;
declare const DEFAULT_RECONNECT_MAX_ATTEMPTS = 3;
declare const DEFAULT_RECONNECT_DELAY_MS = 1000;
declare const DEFAULT_RECONNECT_ON_ICE_FAILURE = true;
declare const DEFAULT_RECONNECT_ON_DATACHANNEL_CLOSE = true;
declare const UnrealStatusMessage: {
    readonly CONNECTING_TO_SESSION: "Connecting to session.";
    readonly STARTING_YOUR_SESSION: "Starting your session";
};

interface NormalizeAndQuantizeUnsignedValue {
    inRange: boolean;
    x: number;
    y: number;
}
interface UnquantizeAndDenormalizeUnsignedValue {
    x: number;
    y: number;
}
interface NormalizeAndQuantizeSignedValue {
    x: number;
    y: number;
}
interface InputProps {
    controlScheme: ControlSchemeValues;
    suppressBrowserKeys: boolean;
}

declare class SubService {
    protected readonly destroyRef: DestroyRef;
    protected readonly destroy$: Subject<void>;
    actions$: Actions<any>;
    store: Store<any>;
    disconnect$: rxjs.Observable<false>;
    _destroy: () => void;
}

declare class AFKService extends SubService {
    private active;
    private warnTimer;
    private countdown;
    private countdownTimer;
    private readonly warnTimeout;
    private readonly isViewportReady;
    private readonly unrealConfig;
    /** Ticks every time warnTimeout changes or resetAfk action fires */
    private readonly afkResetTrigger;
    /** Ticks when cirrus disconnects */
    private readonly disconnected;
    constructor();
    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;
    private clearTimers;
    private stop;
    reset(): void;
    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 fileReceiver;
    private readonly unrealConfig;
    private readonly responseEventListeners;
    /**
     * Never called for now
     */
    constructor();
    protected init(): void;
    protected listenWebRTC(): void;
    protected initialize(): void;
    private addResponseEventListener;
    private showOnScreenKeyboard;
    private removeLoadScreen;
    private startListenCallbacks;
    private showMessageFromUnreal;
    private resetResponseList;
    private dataChannelMessageHandler;
    static ɵfac: i0.ɵɵFactoryDeclaration<AggregatorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AggregatorService>;
}

declare class CommandTelemetryService {
    private actions$;
    private readonly appId;
    private commandsSent;
    private exileTimeout;
    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 sessionId;
    private userId;
    private payloads;
    private readonly httpClient;
    private readonly unrealConfig;
    constructor();
    protected init(): void;
    private get timeNow();
    private get sessionTime();
    private get canSkipSending();
    decorate(funcToDecorate: IToBeDecorated): (data: MetaBoxCommandPacket) => void;
    trackStartCommand(trackingId: string): void;
    trackStopCommand(trackingId: string, multi?: boolean, response?: {
        multi?: boolean;
    } & Record<string, unknown>, timeStampsRaw?: TimeStampsRaw): void;
    reset(): void;
    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.
     */
    protected listenCallbacks(): void;
    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 {MetaBoxCommandPacket} 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: MetaBoxCommandPacket) => void;
interface TimeStampsRaw {
    timeStampPak: TimeStampPakCollection;
    timeStampCommand: TimeStampCommandCollection;
}
interface TimeStampPakCollection {
    onLoadPak: TimeStampMemory;
    onRenderPak: TimeStampMemory;
    onSequencePak: TimeStampMemory;
    onSpawnPak: TimeStampMemory;
}
interface TimeStampMemory {
    timestamp: number;
    ram: number;
    vRam: number;
}
interface TimeStampCommandCollection {
    onRequestCommand: TimeStampMemory;
    onStartCommand: TimeStampMemory;
    onCompleteCommand: TimeStampMemory;
}

declare class ConsoleExtensionsService extends SubService {
    #private;
    private readonly unrealConfig;
    constructor();
    protected 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;
    private readonly unrealConfig;
    constructor();
    protected 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;
    private videoService;
    private readonly unrealConfig;
    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 normalizeAndQuantizeSigned;
    videoBoundingRect: DOMRect;
    fingerIds: Map<any, any>;
    maxByteValue: number;
    fingers: (0 | 2 | 1 | 4 | 8 | 3 | 5 | 6 | 7 | 9)[];
    private offsetParams;
    constructor();
    protected init(): void;
    useKeyboardKeys(keys: IKeyCode[]): void;
    get video(): HTMLVideoElement | null;
    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 store;
    private unrealInitialConfig;
    config: {
        ping_count: number;
        ping_timeout: number;
        max_parallel_requests: number;
        bust_cache: boolean;
    };
    getFastest(regionListUrl?: string): rxjs.Observable<string | undefined>;
    getPingResult(providers: ProvidersData): rxjs.Observable<PingResult | null>;
    getProviders(regionList?: string): rxjs.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 SignallingService extends SubService {
    private readonly action$;
    private readonly httpClient;
    private readonly regionsPingService;
    private readonly commandTelemetryService;
    private readonly unrealConfig;
    readonly region: i0.WritableSignal<string>;
    readonly selectClientAndViewIds: i0.Signal<{
        clientId: string | null;
        viewId: string | null;
    }>;
    readonly environmentId: i0.Signal<string | null>;
    readonly streamRequestContext: i0.Signal<_3dsource_angular_unreal_module.StreamRequestContext | null>;
    onOffer$: Subject<RTCSessionDescriptionInit>;
    onConfig$: Subject<ConfigMessage>;
    onWebRtcIce$: Subject<RTCIceCandidate>;
    onWebRtcAnswer$: Subject<RTCSessionDescriptionInit | null>;
    abort$: Observable<_ngrx_store.Action<string>>;
    private ws;
    orchestrationRetrySub?: Subscription;
    private wsMsgHandlers;
    protected correlationId: string;
    constructor();
    protected init(): void;
    connectToSignaling(urlList: string[]): Observable<WebSocket>;
    protected startEstablishingConnection(): void;
    private adaptUrlsToRegion;
    /**
     * Resolves an active AWS *signaling* instance and returns a WebSocket endpoint.
     *
     * The observable produced by this method is **cold** and executes inside a `defer`,
     * so each subscription (including those triggered by `retry`) pulls the **next**
     * URL candidate from a generator created by `getActiveUrl(urlsPool)`.
     *
     * ### Execution flow
     *
     * 1. **Telemetry** — Starts a `getSignaling` span for end-to-end timing.
     * 2. **Candidate URL selection** — A stateful generator (`urlGen`) is created
     *    from `urlsPool`. Each resubscription (e.g. via `retry`) advances to the next URL.
     * 3. **Short-circuit for WS URLs** — If the picked candidate already matches
     *    `ws://` or `wss://`, emit `{ wsUrl, pollingUrl: null, instanceName: null }`
     *    immediately and complete (no HTTP request).
     * 4. **Await client/view identifiers** — `this.store.select(selectClientAndViewIds)`
     *    is tapped for logging (missing IDs) and then filtered to require both `clientId`
     *    and `viewId` to be truthy.
     * 5. **Single in-flight HTTP orchestration call** — Uses `exhaustMap` to issue
     *    `GET {signalingUrl}{clientId}/{viewId}`. New `{clientId, viewId}` emissions
     *    while the request is in flight are **ignored** until completion, preventing overlap.
     * 6. **Per-attempt timeout** — `timeout(WS_TIMEOUT)` caps how long we wait for a response.
     *    On timeout, the attempt errors and the outer `retry` schedules the next URL.
     * 7. **Response validation & progress reporting** — A `filter`:
     *    - Calls `TelemetryStop('getSignaling', { ...data, multi: true })` on receipt.
     *    - If `data.signallingServer === ''` or `data.error`:
     *      shows a status message, optionally dispatches `setStatusPercentSignallingServer`
     *      with `data.info.percent`, and **throws** to fail the attempt (triggers `retry`).
     * 8. **Mapping to `AwsInstance`** — Converts the validated orchestration payload into:
     *    - `wsUrl`: via `httpUrlToWs(\`\${location.protocol}//\${data.signallingServer}\`)`
     *    - `pollingUrl`: the base `signalingUrl` that succeeded
     *    - `instanceName`: the (validated) `data.signallingServer`
     * 9. **Retry policy** — On *any* upstream error (timeout, HTTP error, invalid payload),
     *    `retry({ delay })`:
     *    - Shows a “connecting” status,
     *    - Logs the attempt number,
     *    - Waits `WS_TIMEOUT` ms (via `timer`) and **resubscribes**, advancing `urlGen`.
     *
     * ### Concurrency semantics
     *
     * - `exhaustMap` guarantees a **single** HTTP request per attempt; subsequent
     *   `{clientId, viewId}` emissions are ignored until the current request completes.
     *
     * ### Telemetry semantics
     *
     * - `trackStartCommand('EXT-getSignaling')` begins before work.
     * - `trackStopCommand('getSignaling', {...})` runs on receipt of an orchestration response.
     *   If an attempt fails (e.g., timeout), stopping the span is the responsibility of
     *   your telemetry layer or a `finalize` elsewhere if desired.
     *
     * ### Error & retry semantics
     *
     * - Missing/never-emitted IDs → timeout → retry with next URL.
     * - HTTP/network error → retry with next URL.
     * - Invalid orchestration payload (`error` set or empty `signallingServer`) → throw in
     *   validation filter → retry with next URL.
     * - Short-circuit WS path **does not** retry (emits once, completes).
     *
     * @param urlsPool - Ordered list of base URLs to probe. Retries advance through this list
     * until a working signaling server is found. A candidate may also be a direct `ws://`/`wss://`
     * URL to short-circuit HTTP orchestration.
     *
     * @returns Observable that emits exactly one {@link AwsInstance} on success and then completes.
     * On failure, the stream errors; the built-in `retry` operator re-subscribes after `WS_TIMEOUT`
     * and advances to the next URL candidate.
     *
     * @throws Emits an error within the observable chain (not a thrown synchronous exception) when:
     * - The HTTP request fails or times out.
     * - The orchestration response indicates an error or an empty `signallingServer`.
     * - Any other operator in the chain surfaces an error.
     *
     * @remarks
     * - The URL generator (`urlGen`) is created **outside** `defer`, so resubscriptions
     *   advance the pool. Creating it inside `defer` would restart from the first URL each retry.
     * - `location.protocol` is used to derive `ws` vs `wss`. If this may run in non-browser
     *   contexts (e.g., SSR), guard or abstract this logic.
     * - Consider capping retries with `count` in `retry({ count, delay })` when appropriate.
     *
     * @example
     * ```ts
     * getAwsInstance(['https://signaling.example.com/', 'wss://direct.example.com'])
     *   .subscribe({
     *     next: ({ wsUrl }) => connect(wsUrl),
     *     error: (e) => console.error('Unable to establish signaling:', e),
     *   });
     * ```
     *
     * @see httpUrlToWs
     * @see selectClientAndViewIds
     * @see setStatusPercentSignallingServer
     */
    private getAwsInstance;
    private connectToCirrus;
    addWsHandlers(ws: WebSocket): void;
    showStatusMessage(statusMessage: string | null): void;
    /**
     * Close the connection with the signaling server
     * @param data
     */
    close(data: CloseReason): void;
    send(data: AnySignalingMessage): void;
    protected handleMessage(msg: MessageBase): void;
    private setHandlersFromStream;
    protected sendRequestStream(): void;
    /**
     * Check if the WebSocket connection is open and ready.
     */
    isConnected(): boolean;
    private getRegion;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignallingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SignallingService>;
}

declare class StreamStatusTelemetryService {
    private readonly store;
    private readonly actions$;
    private readonly videoService;
    private readonly unrealConfig;
    constructor();
    protected init(): void;
    /**
     * Emits `undefined` until `readyState$` first emits a truthy value,
     * then emits the ms elapsed since `startedAt` and completes.
     * Used with `withLatestFrom` so events carry a stable duration for the whole session.
     */
    private readyTimeSince;
    private mapEventData;
    private trackEventToMixPanel;
    static ɵfac: i0.ɵɵFactoryDeclaration<StreamStatusTelemetryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StreamStatusTelemetryService>;
}

/** Wire-format milestone — minimal by design. The viewer never inspects
 *  milestone names as identifiers. */
interface EmittedMilestone {
    readonly label: string;
    readonly time: number;
}
/**
 * Selected WebRTC ICE candidate pair, pulled off {@link AggregatedStat}.
 * The closer for the viewport phase flattens this to two `PhaseParam`
 * rows (`localCandidate`, `remoteCandidate`) before emission.
 */
interface SelectedIceCandidatePair {
    local: {
        type: string;
        url: string;
    };
    remote: {
        type: string;
        url: string;
    };
}
/**
 * Wire-format display key/value pair — rendered verbatim in the viewer's
 * phase tooltip. Nested or structured values should be pre-formatted by
 * the catalog closer's `map(...)` (string/number/boolean only).
 */
interface PhaseParam {
    readonly key: string;
    readonly value: string;
}
/** Resolved overlay region sent on the wire. */
interface PhaseOverlay {
    readonly fromMs: number;
    readonly toMs: number;
    readonly title: string;
}
declare class StreamStatusTelemetryService2 {
    private readonly store;
    private readonly actions$;
    private readonly videoService;
    private readonly signallingService;
    private readonly unrealConfig;
    /**
     * Per-browser anonymous user id. Read from `localStorage` on first access;
     * if missing, a new UUID is generated and persisted. Included as
     * `data.userId` on every emitted event — the server uses it to bucket
     * per-session files under `data/<userId>/<sessionId>.jsonl`.
     */
    private readonly userId;
    private session;
    /**
     * Whether a session has already started during the current page lifetime.
     * Used to distinguish a fresh page load (bootstrap measurement is
     * meaningful) from a Resume/restart (the document is already loaded,
     * so "bootstrap" is a no-op). Only the first session gets the bootstrap
     * phase anchored at navigation start (perf.now() === 0).
     */
    private hasStartedBefore;
    /**
     * Rolling snapshot of the currently selected WebRTC ICE candidate pair
     * (local/remote type + url). Scanned over `videoStats$` so the stream
     * *keeps* the first non-null pair even if later stats emit null — WebRTC
     * doesn't un-select a pair mid-session, but the source is nullable. The
     * `startWith(null)` seed makes `withLatestFrom` on this stream safe even
     * before the first video stat arrives (common at data-channel-open).
     */
    private readonly selectedPair$;
    /**
     * Correlation-matched Observable: emits once when the first `loopBack`
     * command's corresponding `command completed` action fires. Built from
     * the two related actions — the command-started captures the correlation
     * id, the command-completed with that id emits.
     */
    private readonly loopbackReceived$;
    private readonly pollingStartedEntry;
    private readonly awsInstanceResolvedEntry;
    private readonly loopbackReceivedEntry;
    private readonly signalingServerConnectedEntry;
    private readonly configReceivedEntry;
    /**
     * Unified phase catalog — the single source of truth for everything
     * this service tracks after `session_started`. Each entry is a phase;
     * its `milestones` array is ordered chronologically and the *last*
     * entry is the phase closer. When that closer's observable fires, the
     * service emits one generic `stream.phase_ended` wire event with every
     * display field the viewer needs.
     *
     * `phaseNo` is the array index; `startPhase` chains from the previous
     * phase's `endPhase` — neither needs to be specified here.
     */
    private readonly phaseCatalog;
    constructor();
    private getOrCreateUserId;
    private init;
    private startSession;
    private endSession;
    /**
     * Emit a lifecycle event with a `duration` field — ms between the
     * previous lifecycle event and now (phase-local, NOT anchor-relative).
     * For `session_started` this equals the full page-load elapsed on the
     * first session, or 0 on Resume. Advances `lastMilestonePerf` so the
     * next event's duration is correctly rooted.
     */
    private emitLifecycle;
    /**
     * Emit the unified `stream.phase_ended` wire event for a closer. Packs
     * every display field the viewer consumes — phaseNo (derived from the
     * catalog index), label, color, milestones, params, overlays. Boundary
     * labels aren't on the wire — the viewer derives them from neighbour
     * phases' `label` fields.
     */
    private emitPhaseEnded;
    private handleWindow;
    private evaluateAnomalies;
    private updateMaxFpsTarget;
    /**
     * Snapshot every milestone recorded in this session that belongs to
     * {@link phase}. Used to attach a phase's milestone array to the
     * lifecycle event that closes that phase.
     */
    /**
     * Collect wire-shape milestones that fired within a bucket. Walks the
     * catalog's own milestone list (minus the closer) and pulls each
     * entry's time from the in-session map via object identity.
     */
    private milestonesOfBucket;
    /**
     * Capture browser navigation timings — useful to explain the
     * "application bootstrap → session_started" waterfall phase.
     * Values are ms from navigation start; null if the entry is unavailable
     * (old browsers, cross-origin iframes with limited perf access, etc.).
     */
    private collectBootstrapInfo;
    /**
     * Aggregate all resources the browser has loaded so far
     * (`performance.getEntriesByType('resource')`), grouped by `initiatorType`.
     * Gives a real "bytes downloaded before session start" figure — unlike the
     * navigation entry which only covers the HTML document.
     *
     * `transferSize === 0 && decodedBodySize > 0` means the resource came from
     * the HTTP cache — counted separately so cached hits don't inflate
     * the "bytes on the wire" metric.
     */
    private collectResourceTotals;
    private aggregate;
    private track;
    static ɵfac: i0.ɵɵFactoryDeclaration<StreamStatusTelemetryService2, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StreamStatusTelemetryService2>;
}

declare class UnrealCommunicatorService {
    private store;
    private actions$;
    private commandTelemetryService;
    private webRtcPlayerService;
    private readonly unrealConfig;
    private destroy$;
    private cirrusConnected;
    private readonly afkIgnoredCommands;
    private skipAfkReset;
    constructor();
    protected init(): void;
    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;
    isPlaywrightMode(): void;
    private emitDescriptor;
    private requestInitialSettings;
    private requestQualityControl;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnrealCommunicatorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UnrealCommunicatorService>;
}

declare class VideoService extends SubService {
    video: HTMLVideoElement | null;
    audio: HTMLAudioElement | null;
    private container;
    private latencyTestTimings;
    private videoTrack$;
    private VideoEncoderQP;
    private aggregatedStats;
    kalmanFilter1D: KalmanFilter1D;
    /**
     * Aggregate video stats and emit it as videoStats$
     */
    videoStats$: rxjs.Observable<AggregatedStat>;
    setContainer(container?: HTMLDivElement | null): void;
    setLatencyTimings(latencyTimings: string): void;
    setEncoder(data: ArrayBuffer): void;
    create(): void;
    attachVideoStream(stream: MediaStream, pcClient: RTCPeerConnection): void;
    attachAudioStream(stream: MediaStream): void;
    play(): void;
    safePlay(video: HTMLVideoElement | null): Promise<void>;
    private getStats;
    private generateAggregatedStatsFunction;
    private onAggregatedStats;
    private destroy;
    private createWebRtcVideo;
    private createWebRtcAudio;
    private playAudio;
    static ɵfac: i0.ɵɵFactoryDeclaration<VideoService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VideoService>;
}

declare class WebRtcPlayerService extends SubService {
    onDataChannelMessage$: Subject<ArrayBuffer>;
    private pcClient;
    private dcClient;
    private signallingSrv;
    private videoService;
    private commandTelemetryService;
    private cfg;
    private useMic;
    private forceTURN;
    private forceMonoAudio;
    /** Whether the remote SDP has been applied to the current peer connection */
    private remoteDescriptionSet;
    /** ICE candidates received before the remote description was set */
    private iceCandidateBuffer;
    private isReconnecting;
    constructor();
    protected init(): void;
    /**
     * Handles an SDP offer received from the server.
     * Creates a new peer connection, applies the remote offer,
     * then responds with an SDP answer.
     *
     * The DataChannel is NOT created here — the server creates it,
     * and we receive it via the `datachannel` event on the peer connection.
     */
    private handleServerOffer;
    /**
     * Handles an SDP answer received from the server in response to our offer.
     * Applies the remote description and flushes any buffered ICE candidates.
     */
    private handleServerAnswer;
    /** Drains buffered ICE candidates after the remote description has been set */
    private flushIceCandidateBuffer;
    /**
     * Creates a client-initiated WebRTC offer and sends it to the server.
     * When the client offers, it also creates the DataChannel.
     * Used for peer reconnection through the existing signaling connection.
     */
    private createWebRtcOffer;
    /**
     * Initializes a new RTCPeerConnection with event handlers.
     * Transceivers are NOT added here — the caller is responsible for adding
     * them at the correct point depending on the negotiation flow.
     */
    private setupPeerConnection;
    private createDataChannel;
    private handleCandidateFromServer;
    /**
     * Reorders the `m=video` line in the SDP so that payload types matching
     * the given H.264 `profile-level-id` appear first, making the browser
     * prefer that profile during codec negotiation.
     *
     * A `profile-level-id` is a 3-byte hex string (`XXYYZZ`) defined in
     * RFC 6184 that encodes three H.264 parameters:
     * - **Profile IDC** (`XX`) — the H.264 profile.
     * - **Profile IOP** (`YY`) — constraint flags that further narrow the profile.
     * - **Level IDC** (`ZZ`) — the level, which caps resolution/framerate/bitrate.
     *
     * ### H.264 profiles relevant to Unreal Engine Pixel Streaming
     *
     * | profile-level-id | Profile                    | Level | Notes                                        |
     * |------------------|----------------------------|-------|----------------------------------------------|
     * | `42001f`         | Baseline                   | 3.1   | No B-frames, low latency; legacy devices     |
     * | `42e01f`         | Constrained Baseline       | 3.1   | Widest HW decode support; **recommended**    |
     * | `4d001f`         | Main                       | 3.1   | B-frames + CABAC; better compression          |
     * | `4d4028`         | Main                       | 4.0   | Up to 1080p60; common desktop target          |
     * | `640028`         | High                       | 4.0   | Best quality/compression; most GPUs support   |
     * | `64002a`         | High                       | 4.2   | Up to 1080p120 or 4K30                        |
     * | `640033`         | High                       | 5.1   | Up to 4K60; requires modern HW                |
     * | `640034`         | High                       | 5.2   | Up to 4K120; high-end HW only                 |
     * | `6e001f`         | High 10                    | 3.1   | 10-bit color; limited browser support          |
     * | `f4001f`         | High 4:4:4 Predictive      | 3.1   | Lossless capable; rare in browsers             |
     *
     * UE Pixel Streaming defaults to Constrained Baseline (`42e01f`) or High (`6400xx`)
     * depending on engine version and `WebRTC.H264Profile` CVar.
     *
     * We prioritize `42e01f` because it guarantees hardware decoding on
     * virtually all client devices (desktop, mobile, embedded), avoiding
     * fallback to software decoding or negotiation of a higher profile
     * that the client GPU may not accelerate.
     */
    private prioritizeH264Profile;
    private mungeSDP;
    /**
     * Closes existing PeerConnection and DataChannel, resets negotiation state.
     */
    closePC(): void;
    canSend(): boolean | null;
    send(data: ArrayBuffer): void;
    /**
     * Attempts to reconnect the peer when send fails due to DataChannel not being open.
     * This handles cases where the DC connection is broken, but no error events are fired.
     */
    private tryReconnectOnSendFailure;
    /**
     * Reconnects only the WebRTC peer connection without re-establishing signaling.
     * Closes the current PeerConnection and creates a new client-initiated offer
     * through the existing WebSocket connection.
     * @returns true if reconnection was initiated, false if signaling is not connected
     */
    reconnectPeer(): boolean;
    private setConfig;
    private handlePeerConnectionEvents;
    private setupTransceiversAsync;
    private setupDataChannelCallbacks;
    private onDataChannelConnected;
    /**
     * Creates an SDP offer, applies SDP munging, sets it as a local description,
     * and sends it to the server via signaling.
     * Transceivers already configure media directions, so deprecated
     * offerToReceive* options are not used.
     */
    private createOffer;
    /**
     * Creates an SDP answer, applies SDP munging, sets it as a local description,
     * and sends it to the server via signaling.
     */
    private createAnswer;
    static ɵfac: i0.ɵɵFactoryDeclaration<WebRtcPlayerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WebRtcPlayerService>;
}

declare const ReceivedMimeTypes: {
    readonly ApplicationJson: "application/json";
};
type ReceivedMimeType = (typeof ReceivedMimeTypes)[keyof typeof ReceivedMimeTypes];

declare class FileHandlerService {
    private fileService;
    private fileHandlers;
    private handleJsonFile;
    observeFileResponse<K extends keyof MetaBoxCommandList, T extends MetaBoxCommandList[K] = MetaBoxCommandList[K]>(mimetype: ReceivedMimeType, data: T, sender: (data: T) => void, timeOut?: number): Observable<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileHandlerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FileHandlerService>;
}

declare class FileReceiverService extends SubService {
    fileComplete$: Subject<ReceivedFile>;
    private valid;
    private chunks;
    private mimetype;
    private receiving;
    private extension;
    private data;
    private readonly unrealConfig;
    constructor();
    protected init(): void;
    reset(): void;
    private resetOnStart;
    /**
     * Processes a file extension when received over data channel
     * @param view - the file extension data
     */
    setExtensionFromBytes(view: Uint8Array): void;
    /**
     * Processes a file mime type when received over data channel
     * @param view - the file mime type data
     */
    setMimeTypeFromBytes(view: Uint8Array): void;
    setContentsFromBytes(view: Uint8Array): void;
}
interface ReceivedFile {
    blob: Blob;
    mimetype: ReceivedMimeType;
    extension: string;
    valid: boolean;
}

declare class AnalyticsService extends SubService {
    #private;
    sendEventToMixPanel(name: string, params?: Record<string, unknown>): void;
    constructor();
    private monitorMouse;
    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsService>;
}

/**
 * Adaptive FPS controller that monitors the incoming WebRTC video stream
 * quality and dynamically adjusts Unreal Engine's `t.MaxFPS` console variable.
 *
 * ## How it works
 *
 * The service subscribes to `VideoService.videoStats$` (emitted every 250 ms)
 * and collects samples of FPS, bitrate, and QP (Quantisation Parameter).
 * Every {@link SAMPLE_WINDOW} ticks (~2 s) it averages the collected samples
 * and feeds them into a set of **fuzzy-logic membership functions** that
 * classify each metric into overlapping quality bands.
 *
 * ### Input signals
 *
 * **1. FPS ratio** = `actualFPS / currentTargetFPS` (0..1+)
 *
 * | Band   | Range               | Meaning                                       |
 * |--------|---------------------|-----------------------------------------------|
 * | low    | ratio < 0.7 → 1.0, linear ramp 0.7..0.9 → 0   | Stream cannot keep up with the target         |
 * | ok     | triangle 0.8..1.0, peak at 0.95                 | Stream roughly matches the target             |
 * | high   | ratio 0.9..1.0 → ramp, >1.0 → 1.0              | Stream meets or exceeds the target            |
 *
 * **2. Bitrate load** = `currentBitrate / MAX_BITRATE` (0..1+)
 *
 * `MAX_BITRATE` = 20 Mbit/s — the reference ceiling for the encoder.
 *
 * | Band   | Range                                           | Meaning                                       |
 * |--------|-------------------------------------------------|-----------------------------------------------|
 * | high   | load 0.5..0.8 → ramp, >0.8 → 1.0               | Encoder is using most of the available bandwidth |
 * | not high | load < 0.5 → 0.0                              | Bandwidth headroom is available                |
 *
 * **3. Quality** — mapped from QP via `mapQpToQuality()` (see {@link Quality}):
 *
 * | Quality  | QP range  | Meaning                                         |
 * |----------|-----------|-------------------------------------------------|
 * | `lime`   | QP <= 26  | Good — encoder has enough headroom              |
 * | `orange` | QP 27..35 | Fair — encoder is under moderate pressure        |
 * | `red`    | QP > 35   | Poor — heavy compression, visible artefacts      |
 *
 * ### Decision rules (evaluated in priority order, first match wins)
 *
 * | # | Condition                                                  | Decision     |
 * |---|------------------------------------------------------------|--------------|
 * | 1 | FPS ratio is **low** (membership > 0.5)                    | **decrease** |
 * | 2 | FPS ratio is **ok** AND quality is `red`                   | **decrease** |
 * | 3 | FPS ratio is **ok** AND bitrate **high** AND quality is `orange` | **hold** |
 * | 4 | FPS ratio is **high** AND quality is `lime` AND bitrate **not high** | **increase** |
 * | — | Everything else                                            | **hold**     |
 *
 * ## Cooldown-based throttling
 *
 * The service continuously evaluates fuzzy rules every sample window.
 * After each FPS step change it enforces a cooldown before the next
 * change can be applied. The cooldown duration depends on the
 * (previous decision → next decision) pair:
 *
 * | Previous  | Next      | Cooldown                                            |
 * |-----------|-----------|-----------------------------------------------------|
 * | decrease  | decrease  | {@link COOLDOWN_DECREASE_AFTER_DECREASE_MS} (2 s)   |
 * | decrease  | increase  | {@link COOLDOWN_INCREASE_AFTER_DECREASE_MS} (10 s)  |
 * | increase  | decrease  | {@link COOLDOWN_AFTER_INCREASE_MS} (2 s)            |
 * | increase  | increase  | {@link COOLDOWN_AFTER_INCREASE_MS} (2 s)            |
 *
 * This means the system reacts quickly after an increase (2 s in any
 * direction) but is cautious about stepping back up after a decrease
 * (10 s), while still allowing consecutive decreases at 2 s intervals.
 *
 * ## FPS dispatch
 *
 * FPS changes are dispatched via the NgRx `setMaxFps` action, which triggers
 * the existing `CommandsEffects.setMaxFps$` effect that sends the
 * `t.MaxFPS <value>` console command to Unreal Engine.
 */
declare class FpsMonitorService {
    private videoService;
    private store;
    private readonly unrealConfig;
    /** Discrete FPS targets the controller can switch between (ascending order). Last 0 is unlimited framerate indicator*/
    private readonly FPS_STEPS;
    /**
     * Reference FPS used to compute the FPS ratio when `currentFpsTarget` is 0
     * (unlimited). Keeps adaptive logic operational at the unlimited step:
     * if the stream drops well below this value, fuzzy rules can still fire.
     */
    private readonly UNLIMITED_REFERENCE_FPS;
    /** Reference ceiling for bitrate (bits/sec) used to normalize a bitrate load to 0..1. */
    private readonly MAX_BITRATE;
    /**
     * Cooldown (ms) for any decision (increase or decrease) following an increase.
     * After an increase, the system should react faster.
     */
    private readonly COOLDOWN_AFTER_INCREASE_MS;
    /**
     * Cooldown (ms) for a decrease following a previous decrease.
     */
    private readonly COOLDOWN_DECREASE_AFTER_DECREASE_MS;
    /**
     * Cooldown (ms) for an increase following a previous decrease.
     * The stream needs more time to stabilise before stepping back up.
     */
    private readonly COOLDOWN_INCREASE_AFTER_DECREASE_MS;
    /**
     * Number of videoStats$ ticks to accumulate before evaluating.
     * At 250 ms per tick, this gives a ~2 s sliding evaluation window,
     * long enough to smooth out single-frame jitter.
     */
    private readonly SAMPLE_WINDOW;
    /** Emits when the session ends, cancelling the current stats' subscription. */
    private session$;
    /** Current FPS target; starts at max (60 FPS) and adapts downward/upward. */
    private currentFpsTarget;
    private samples;
    private lastDecisionTime;
    private lastUpgrade;
    private disconnect$;
    constructor();
    protected init(): void;
    private startSession;
    private resetSession;
    private resetMutableState;
    /**
     * Called on every videoStats$ emission (~250 ms).
     * Accumulates samples and evaluates once per SAMPLE_WINDOW.
     */
    private processTick;
    private handleMonitoring;
    /**
     * Combines fuzzy membership values into a single discrete decision.
     * Rules are evaluated in priority order — first match wins.
     *
     * Inputs:
     * - `fpsRatio`    = avgFPS / currentTargetFPS  (e.g. 45/60 = 0.75)
     * - `bitrateLoad` = avgBitrate / 20 Mbit/s     (e.g. 12M/20M = 0.6)
     * - `quality`     = mapQpToQuality(avgQP)       → 'lime' | 'orange' | 'red'
     */
    private evaluateDecision;
    /**
     * FPS ratio membership "low".
     * Input: ratio = actualFPS / targetFPS (e.g. 42/60 = 0.70).
     *
     *   ratio < 0.7  → 1.0  (clearly failing, e.g. 40/60)
     *   ratio 0.7..0.9 → linear ramp down (e.g. 0.8 → 0.5)
     *   ratio > 0.9  → 0.0  (keeping up)
     */
    private membershipFpsLow;
    /**
     * FPS ratio membership "ok" — triangle shape.
     * Input: ratio = actualFPS / targetFPS.
     *
     *   ratio < 0.8  → 0.0
     *   ratio 0.8..0.95 → ramp up, peak at 0.95 (e.g. 57/60)
     *   ratio 0.95..1.0 → ramp down
     *   ratio > 1.0  → 0.0
     */
    private membershipFpsOk;
    /**
     * FPS ratio membership "high".
     * Input: ratio = actualFPS / targetFPS.
     *
     *   ratio < 0.9  → 0.0
     *   ratio 0.9..1.0 → linear ramp up (e.g. 0.95 → 0.5)
     *   ratio >= 1.0 → 1.0  (meeting or exceeding target, e.g. 60/60)
     */
    private membershipFpsHigh;
    /**
     * Bitrate load membership "high".
     * Input: load = currentBitrate / MAX_BITRATE (20 Mbit/s).
     *
     *   load < 0.5  → 0.0  (below 10 Mbit/s — plenty of headroom)
     *   load 0.5..0.8 → linear ramp (e.g. 13M/20M = 0.65 → 0.5)
     *   load > 0.8  → 1.0  (above 16 Mbit/s — near capacity)
     */
    private membershipBitrateHigh;
    private upgradeFps;
    /**
     * Get the next FPS target based on current target and decision.
     * Clamps to valid FPS_STEPS range.
     */
    private getNextFpsTarget;
    /**
     * Find the closest FPS step index for a given target value.
     */
    private findClosestFpsIndex;
    /** Average all collected samples for the current evaluation window. */
    private averageSamples;
    static ɵfac: i0.ɵɵFactoryDeclaration<FpsMonitorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FpsMonitorService>;
}

/**
 * Custom Unreal callback events that are not part of MetaBoxCommandList.
 * These events are pushed from Unreal to the frontend via the data channel.
 */
interface UnrealCallbackEventMap {
    onSceneState: {
        command: 'onSceneState';
        payload: FSceneState;
    };
    onFocusObject: {
        command: 'onFocusObject';
        payload: FProductPayload;
    };
    cameraChanged: {
        command: 'cameraChanged';
        payload: FCameraChangedPayload;
    };
    onObjectTransformChanged: {
        command: 'onObjectTransformChanged';
        payload: {
            objectName: string;
            transform: FTransformJson;
        };
    };
    onChangeSequence: {
        command: 'onChangeSequence';
        payload: unknown;
    };
    onFinishedSequence: {
        command: 'onFinishedSequence';
        payload: unknown;
    };
}
/**
 * Combined map of all known callback event types:
 * MetaBoxCommandList (command responses) + UnrealCallbackEventMap (custom events).
 */
type UnrealCallbackDescriptor = MetaBoxCommandList & UnrealCallbackEventMap;
declare class UnrealCallbackService {
    private readonly actions$;
    /**
     * Listens for unreal command callbacks matching a specific command or event type.
     *
     * Supports both MetaBoxCommand keys (e.g. `MetaBoxCommand.FLoadProductCommand`)
     * and custom Unreal callback events (e.g. `'cameraChanged'`, `'onSceneState'`).
     *
     * @param command - The command or event key to filter callbacks by
     * @returns Observable that emits matching callback payloads
     *
     * @example
     * ```ts
     * // Listen for a MetaBox command callback
     * this.unrealCallbackService
     *   .fromUnrealCallback(MetaBoxCommand.FLoadProductCommand)
     *   .subscribe(data => console.log(data));
     *
     * // Listen for a custom Unreal event
     * this.unrealCallbackService
     *   .fromUnrealCallback('cameraChanged')
     *   .subscribe(data => console.log(data));
     * ```
     */
    fromUnrealCallback<K extends keyof UnrealCallbackDescriptor>(command: K): rxjs.Observable<UnrealCallbackDescriptor[K]>;
    /**
     * Sends a command and observes the matching response by correlationId.
     * Replaces the old `observeCommandResponse` standalone function.
     *
     * @param data - The command data to send
     * @param sender - Function to send the command to Unreal
     * @param timeOut - Timeout in ms (default 60000)
     * @param dispatchOnTimeout - Whether to emit on timeout (default true)
     *
     * @example
     * ```ts
     * this.unrealCallbackService
     *   .observeCommandResponse<FLoopBackCommand['command']>(
     *     { command: MetaBoxCommand.FLoopBackCommand },
     *     (data) => this.communicator.sendCommandToUnreal(data),
     *   )
     *   .subscribe();
     * ```
     */
    observeCommandResponse<K extends keyof MetaBoxCommandList, T extends MetaBoxCommandList[K] = MetaBoxCommandList[K]>(data: T, sender: (data: T) => void, timeOut?: number, dispatchOnTimeout?: boolean): rxjs.Observable<MetaBoxCommandList[K]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnrealCallbackService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UnrealCallbackService>;
}

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): 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;

/**
 * Keeps the max of numbers seen so far; resets to 0 whenever `reset$` emits.
 * Emits `0` immediately on reset.
 */
declare const keepMaxUntilReset: (reset$: Observable<unknown>) => ((source: Observable<number>) => Observable<number>);

declare function decodeData(anyData: ArrayBuffer): string;

declare const dispatchResize: () => void;

declare function getRtcErrorMessage(code: number | null): string | undefined;

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;
}

declare function qpToQuality(VideoEncoderQP: number): Quality;

declare function fromResizeObserver(elem: HTMLElement): Observable<ResizeObserverEntry[]>;

/**
 * Calculates the optimal stream resolution for studio mode.
 *
 * Fits the studio aspect ratio into the container (scaled by pixelRatio), then
 * caps the total pixel count to a budget (Full HD or 4K) to avoid overloading
 * the GPU/encoder while maximizing visual quality.
 *
 * The pixel budget approach (instead of per-dimension caps) ensures that
 * non-standard aspect ratios (portrait, ultra-wide, square) utilize available
 * pixels efficiently — e.g. a tall 1080×1920 stream uses the same pixel budget
 * as a wide 1920×1080 stream.
 *
 * Resolution is always capped at the studio dimensions — never upscaled beyond
 * what the Unreal scene was designed for.
 *
 * @param params.pixelRatio - Device pixel ratio (`window.devicePixelRatio`).
 * @param params.containerWidth - CSS width of the video container in pixels.
 * @param params.containerHeight - CSS height of the video container in pixels.
 * @param params.studioWidth - Target width of the MetaBox Studio scene.
 * @param params.studioHeight - Target height of the MetaBox Studio scene.
 * @param params.maxResolution - When `true`, uses 4K pixel budget (3840×2160);
 *   otherwise Full HD (1920×1080). Controlled by `?maxresolution` query param.
 * @returns An {@link Area} with the calculated `w`, `h`, position (`x`, `y`),
 *   and `scale` factor relative to the container's device-pixel size.
 */
declare function getResizeStudioValues(params: {
    pixelRatio: number;
    containerWidth: number;
    containerHeight: number;
    studioWidth: number;
    studioHeight: number;
    maxResolution: boolean;
}): Area;
/**
 * Calculates the optimal stream resolution for configurator (non-studio) mode.
 *
 * Uses the full container area (scaled by pixelRatio) as the stream resolution,
 * then caps total pixel count to a budget (Full HD or 4K) to prevent excessive
 * GPU/encoder load while preserving the container's aspect ratio.
 *
 * Unlike {@link getResizeStudioValues}, there is no fixed studio resolution to
 * fit into — the container itself defines the aspect ratio, and the stream fills
 * it entirely (no letterboxing).
 *
 * @param params.pixelRatio - Device pixel ratio (`window.devicePixelRatio`).
 * @param params.containerWidth - CSS width of the video container in pixels.
 * @param params.containerHeight - CSS height of the video container in pixels.
 * @param params.maxResolution - When `true`, uses 4K pixel budget (3840×2160);
 *   otherwise Full HD (1920×1080). Controlled by `?maxresolution` query param.
 * @returns An {@link Area} with the calculated `w`, `h`, position (`x`, `y`),
 *   and `scale` factor (1 when no downscale needed, <1 when capped).
 */
declare function getResizeValuesUniversal(params: {
    pixelRatio: number;
    containerWidth: number;
    containerHeight: number;
    maxResolution: boolean;
}): Area;

declare function getResizeValuesUniversalOld(params: {
    pixelRatio: number;
    containerWidth: number;
    containerHeight: number;
    maxResolution: boolean;
}): Area;
declare function getResizeStudioValuesOld(params: {
    pixelRatio: number;
    containerWidth: number;
    containerHeight: number;
    studioWidth: number;
    studioHeight: number;
    maxResolution: boolean;
}): Area;

/**
 * Rounds a number to the nearest even integer (rounding up for odd values).
 *
 * Video encoders (H.264/H.265) require even dimensions because chroma subsampling
 * operates on 2×2 pixel blocks. Odd dimensions cause encoding artifacts or failures.
 *
 * @param value - The number to round to the nearest even integer.
 * @returns The nearest even integer greater than or equal to the input.
 *
 * @example
 * makeEven(1079) // 1080
 * makeEven(1080) // 1080
 * makeEven(1081) // 1082
 */
declare function makeEven(value: number): number;

interface LBMStats {
    dataFlowResult: DataFlowCheckResult;
    reason: string;
    triggerTime: number;
}

type Quality = 'lime' | 'red' | 'orange';

interface SignalingData {
    instanceType: string;
    branchInfo: string;
    cirrusVersion: string;
    streamerVersion: string;
    streamPath: string;
    streamApp: string;
    connectionId: string;
}

declare const OrchestrationMessageTypes: {
    readonly ping: "ping";
    readonly error: "error";
    readonly offer: "offer";
    readonly answer: "answer";
    readonly ssInfo: "ssInfo";
    readonly config: "config";
    readonly playerCount: "playerCount";
    readonly iceCandidate: "iceCandidate";
    readonly streamerList: "streamerList";
    readonly requestStream: "requestStream";
    readonly listStreamers: "listStreamers";
    readonly instanceReady: "instanceReady";
    readonly p2pEstablished: "p2pEstablished";
    readonly instanceReserved: "instanceReserved";
    readonly playerDisconnected: "playerDisconnected";
    readonly streamPreparedForUserInteraction: "streamPreparedForUserInteraction";
    readonly streamerDisconnected: "streamerDisconnected";
    readonly interruptClientStream: "interruptClientStream";
};
interface InstanceReady extends InstanceMessageBase {
    type: 'instanceReady';
}
interface InstanceReserved extends InstanceMessageBase {
    type: 'instanceReserved';
}
interface OrchestrationErrorMessage {
    type: 'error';
    payload: {
        code: number;
        message: string;
    };
}
interface InstanceMessageBase extends MessageBase {
    correlationId: string;
    payload: {
        instanceId: string;
        streamRequestId: string;
        eta: number;
    };
}
interface MessageBase {
    type: OrchestrationMessageType;
}
interface SSInfo extends MessageBase {
    type: 'ssInfo';
    message: string;
    data: SignalingData;
}
interface PlayerCountMessage extends MessageBase {
    type: 'playerCount';
    playerCount: number;
}
interface StreamerListMessage extends MessageBase {
    type: 'streamerList';
    ids: string[];
}
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>;
interface InterruptClientStream extends MessageBase {
    type: 'interruptClientStream';
    correlationId: string;
    payload: {
        environmentId: string;
    };
}
interface ForceClientDisconnect extends MessageBase {
    type: 'streamerDisconnected' | 'playerDisconnected';
    connectionId: string;
}
interface ListStreamersMessage extends MessageBase {
    type: 'listStreamers';
    correlationId: string;
}
interface P2PEstablishedMessage extends MessageBase {
    type: 'p2pEstablished';
    source: string;
    sessionId: string;
}
interface streamPreparedForUserInteractionMessage extends MessageBase {
    type: 'streamPreparedForUserInteraction';
    correlationId: string;
}
interface RequestStream extends MessageBase {
    type: 'requestStream';
    correlationId: string;
    payload: {
        environmentId: string;
        region?: string;
        /**
         * The context field is used for plugins of the external
         * applications for collecting additional statistics, etc.
         */
        context: StreamRequestContext;
    };
}
interface MetaboxBasicConfiguratorContext {
    id: 'metaboxBasicConfigurator';
    data: {
        configuratorId: string;
    };
}
interface MetaboxModularConfiguratorContext {
    id: 'metaboxModularConfigurator';
    data: {
        configuratorId: string;
    };
}
interface MetaboxProductContext {
    id: 'metaboxProduct';
    data: {
        productId: string;
    };
}
interface MetaboxEnvironmentContext {
    id: 'metaboxEnvironment';
    data: {
        environmentId: string;
    };
}
interface MetaboxStudioContext {
    id: 'metaboxStudio';
    data: {
        userId: string;
        workspaceId: string;
    };
}
interface CustomApplicationContext {
    id: 'customApplication';
    data: {
        clientId: string;
        applicationId: string;
    };
}
type StreamRequestContext = MetaboxStudioContext | MetaboxProductContext | CustomApplicationContext | MetaboxEnvironmentContext | MetaboxBasicConfiguratorContext | MetaboxModularConfiguratorContext;
interface SignalingMessageMap {
    [OrchestrationMessageTypes.ping]: PingMessage;
    [OrchestrationMessageTypes.offer]: RTCSessionDescriptionInit;
    [OrchestrationMessageTypes.error]: OrchestrationErrorMessage;
    [OrchestrationMessageTypes.ssInfo]: SSInfo;
    [OrchestrationMessageTypes.config]: ConfigMessage;
    [OrchestrationMessageTypes.answer]: RTCSessionDescriptionInit;
    [OrchestrationMessageTypes.playerCount]: PlayerCountMessage;
    [OrchestrationMessageTypes.iceCandidate]: CandidateMessage;
    [OrchestrationMessageTypes.streamerList]: StreamerListMessage;
    [OrchestrationMessageTypes.instanceReady]: InstanceReady;
    [OrchestrationMessageTypes.requestStream]: RequestStream;
    [OrchestrationMessageTypes.listStreamers]: ListStreamersMessage;
    [OrchestrationMessageTypes.p2pEstablished]: P2PEstablishedMessage;
    [OrchestrationMessageTypes.instanceReserved]: InstanceReserved;
    [OrchestrationMessageTypes.playerDisconnected]: ForceClientDisconnect;
    [OrchestrationMessageTypes.streamPreparedForUserInteraction]: streamPreparedForUserInteractionMessage;
    [OrchestrationMessageTypes.streamerDisconnected]: ForceClientDisconnect;
    [OrchestrationMessageTypes.interruptClientStream]: InterruptClientStream;
}
type OrchestrationMessageType = keyof SignalingMessageMap;
type AnySignalingMessage = SignalingMessageMap[OrchestrationMessageType] | string;
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;
}

interface StreamResolutionProps {
    width: number | null;
    height: number | null;
}

type TelemetryType = 'commandSent' | 'commandStop';

interface AggregatedStat {
    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;
    selectedPair: {
        local: {
            type: string;
            url: string;
        };
        remote: {
            type: string;
            url: string;
        };
    } | null;
    currentRoundTripTime: number;
    codecs: Record<string, string>;
    receiveToCompositeMs: number;
    bitrate: number;
    kalmanBitrate: number;
    bitrateDrop: number;
    dataFlowCheckResult: DataFlowCheckResult;
    dataFlowBitrate: DataFlowCheckResult;
}
interface AwsInstance {
    /**
     * WebSocket URL for connecting to the Cirrus (polling mode) or Orchestration (direct mode).
     */
    wsUrl: string | null;
    pollingUrl: string | null;
    instanceName: string | null;
    /**
     * Unique identifier for the streaming request.
     * Coming with a new orchestration message "instanceReserved".
     */
    streamRequestId?: string;
    /**
     * Estimated time of arrival (in seconds) for the instance to be ready.
     * Coming with a new orchestration message "instanceReserved".
     */
    eta?: number;
    /**
     * Progress of completion for the instance launch (0-1).
     * Based on ETA time comes from the backend with new orchestration.
     * If eta is not provided, this value will be undefined.
     */
    progressComplete?: number;
    message?: string;
}

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;
}

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;
}

declare class FilterSettingsComponent implements OnInit {
    #private;
    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(settings: FilterSettings): 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 videoService;
    readonly isDevMode: boolean;
    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>;
    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: string, type: string): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafePipe, "safe", true>;
}

declare function provideUnrealModule(): i0.EnvironmentProviders;

/**
 * Raw JSON from Unreal can either be wrapped in `commandCallback`
 * (e.g. `{ commandCallback: { command: '...', correlationId: '...' } }`)
 * or be a direct command/event object (e.g. `{ command: 'cameraChanged', payload: {...} }`).
 */
interface UnrealCallbackJsonWrapped {
    commandCallback: MetaBoxCommandPacket;
    timeStamp?: unknown;
}
type UnrealCallbackJson = UnrealCallbackJsonWrapped | MetaBoxCommandPacket;
declare const unrealCommandCallback: _ngrx_store.ActionCreator<string, (props: {
    json: UnrealCallbackJson;
}) => {
    json: UnrealCallbackJson;
} & _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 class CommandsEffects {
    private actions$;
    private unrealInitialConfig;
    listenUnrealCallbackByInitSignalling$: rxjs.Observable<{
        id: string;
    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommandsEffects, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CommandsEffects>;
}

declare const commandsFeature: {
    name: "commandsFeature";
    reducer: _ngrx_store.ActionReducer<_3dsource_angular_unreal_module.UnrealCommandsState, _ngrx_store.Action<string>>;
    selectCommandsFeatureState: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.UnrealCommandsState, (featureState: _3dsource_angular_unreal_module.UnrealCommandsState) => _3dsource_angular_unreal_module.UnrealCommandsState>;
    selectCommandsInProgress: _ngrx_store.MemoizedSelector<Record<string, any>, {
        timeStamp: number;
        command: string;
        id: string;
    }[], (featureState: _3dsource_angular_unreal_module.UnrealCommandsState) => {
        timeStamp: number;
        command: string;
        id: string;
    }[]>;
    selectTotalCommandsStarted: _ngrx_store.MemoizedSelector<Record<string, any>, number, (featureState: _3dsource_angular_unreal_module.UnrealCommandsState) => number>;
    selectTotalCommandsCompleted: _ngrx_store.MemoizedSelector<Record<string, any>, number, (featureState: _3dsource_angular_unreal_module.UnrealCommandsState) => number>;
};

interface UnrealCommandsState {
    commandsInProgress: {
        timeStamp: number;
        command: string;
        id: string;
    }[];
    totalCommandsStarted: number;
    totalCommandsCompleted: number;
}
declare const commandsReducer: _ngrx_store.ActionReducer<UnrealCommandsState, _ngrx_store.Action<string>>;

declare const selectCommandsInProgress: _ngrx_store.MemoizedSelector<Record<string, any>, number, (s1: {
    timeStamp: number;
    command: string;
    id: string;
}[]) => number>;
declare const selectCommandProgress: _ngrx_store.MemoizedSelector<Record<string, any>, number, (s1: number, s2: number) => number>;

declare const trackMixpanelEvent: _ngrx_store.ActionCreator<string, (props: {
    event: string;
    data?: unknown;
}) => {
    event: string;
    data?: unknown;
} & _ngrx_store.Action<string>>;
declare const trackTelemetryData: _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: {
    reason: DisconnectReasonType;
}) => {
    reason: DisconnectReasonType;
} & _ngrx_store.Action<string>>;
declare const destroyUnrealScene: _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: {
    statusMessage: string | null;
}) => {
    statusMessage: 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 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>>;
/**
 * @deprecated Use `dataChannelReady` instead. Currently, this action is not working.
 */
declare const setDataChannelConnected: _ngrx_store.ActionCreator<string, (props: {
    statusMessage: string;
}) => {
    statusMessage: string;
} & _ngrx_store.Action<string>>;
declare const dataChannelConnected: _ngrx_store.ActionCreator<string, (props: {
    statusMessage: string;
}) => {
    statusMessage: string;
} & _ngrx_store.Action<string>>;
declare const dataChannelReady: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const setConfig: _ngrx_store.ActionCreator<string, (props: {
    config: Partial<StreamConfig>;
}) => {
    config: Partial<StreamConfig>;
} & _ngrx_store.Action<string>>;
declare const disconnectStream: _ngrx_store.ActionCreator<string, (props: {
    reason: DisconnectReasonType;
    message: string;
}) => {
    reason: DisconnectReasonType;
    message: string;
} & _ngrx_store.Action<string>>;
declare const dropConnection: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const setViewportReady: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const setViewportNotReady: _ngrx_store.ActionCreator<string, () => _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 setOrchestrationParameters: _ngrx_store.ActionCreator<string, (props: {
    instanceName: string;
    streamRequestId: string;
    eta: number;
}) => {
    instanceName: string;
    streamRequestId: string;
    eta: number;
} & _ngrx_store.Action<string>>;
/**
 * Dispatched when the orchestration server signals that the reserved
 * instance is ready to serve the stream (`instanceReady` WS message).
 * Emitted for observability only — no reducer state change.
 */
declare const instanceReady: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
/**
 * Dispatched when `RegionsPingService.getFastest()` begins — right
 * before the region-list HTTP request goes out. Bookends the entire
 * region-discovery flow together with {@link regionResolved}.
 * Observability-only — no state change.
 */
declare const regionPingFetchStart: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
/**
 * Dispatched once `RegionsPingService.getProviders()` returns the region
 * list — i.e. the fetch step is done and the actual per-region ping
 * sweep is about to start. Splits the region-discovery waterfall into
 * two legs: config fetch vs ping sweep. Observability-only.
 */
declare const regionPingFetchEnd: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
/**
 * Dispatched once the closest region has been resolved by the
 * regions-ping service. Carries every sampled ping RTT to the winning
 * region (one entry per probe — `checkLatency` issues `ping_count`
 * sequential pings per region) so consumers can inspect variance /
 * jitter, not just the mean. Observability-only — no state change.
 */
declare const regionResolved: _ngrx_store.ActionCreator<string, (props: {
    region: string;
    pingsMs: number[];
}) => {
    region: string;
    pingsMs: number[];
} & _ngrx_store.Action<string>>;
/**
 * Dispatched around the HTTP polling roundtrip inside `getAwsInstance`
 * (old orchestration flow). Only fires when polling is actually used
 * (i.e. signaling URL is not a direct `ws://` / `wss://` endpoint).
 * Observability-only — no state change.
 */
declare const pollingStarted: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const pollingEnded: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
/**
 * Dispatched when the client has just sent an SDP answer back to Cirrus
 * after receiving the server-initiated offer. Observability-only.
 */
declare const answerSent: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const setOrchestrationMessage: _ngrx_store.ActionCreator<string, (props: {
    message: string;
}) => {
    message: string;
} & _ngrx_store.Action<string>>;
declare const setOrchestrationProgress: _ngrx_store.ActionCreator<string, (props: {
    progressComplete: number;
}) => {
    progressComplete: number;
} & _ngrx_store.Action<string>>;
declare const setOrchestrationContext: _ngrx_store.ActionCreator<string, (props: {
    urls: string[];
    environmentId: string;
    streamRequestContext: StreamRequestContext;
}) => {
    urls: string[];
    environmentId: string;
    streamRequestContext: StreamRequestContext;
} & _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 setLoopBackCommandIsCompleted: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const setAfkTimerVisible: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const setAfkTimerHide: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const setAfkTimerCountdown: _ngrx_store.ActionCreator<string, (props: {
    countdown: number;
}) => {
    countdown: number;
} & _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.FunctionWithParametersType<[data?: {
    resetDisconnectionReason: boolean;
} | undefined], {
    resetDisconnectionReason: boolean;
} & _ngrx_store.Action<string>> & _ngrx_store.Action<string>;
declare const startStream: _ngrx_store.ActionCreator<string, (props: {
    config: Partial<StreamConfig>;
}) => {
    config: Partial<StreamConfig>;
} & _ngrx_store.Action<string>>;
declare const resetConfig: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const resetAfk: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const resetWarnTimeout: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const abortEstablishingConnection: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const setUnrealPlaywrightConfig: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const saveAnalyticsEvent: _ngrx_store.ActionCreator<string, (props: {
    event: {
        name: string;
        params: Record<string, unknown>;
    };
}) => {
    event: {
        name: string;
        params: Record<string, unknown>;
    };
} & _ngrx_store.Action<string>>;
/** Action to trigger WebRTC peer reconnection (keeps signaling connection) */
declare const reconnectPeer: _ngrx_store.ActionCreator<string, (props: {
    attempt: number;
    maxAttempts: number;
    delay?: number;
}) => {
    attempt: number;
    maxAttempts: number;
    delay?: number;
} & _ngrx_store.Action<string>>;
/** Action to reset the data channel state before reconnection */
declare const resetDataChannelForReconnect: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
/** Action dispatched when peer reconnection succeeds */
declare const reconnectPeerSuccess: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
/** Action dispatched when all peer reconnection attempts are exhausted */
declare const reconnectPeerFailed: _ngrx_store.ActionCreator<string, (props: {
    reason: string;
}) => {
    reason: string;
} & _ngrx_store.Action<string>>;
/** Action dispatched when ICE connection state changes to failed/disconnected */
declare const iceConnectionFailed: _ngrx_store.ActionCreator<string, (props: {
    state: RTCIceConnectionState;
}) => {
    state: RTCIceConnectionState;
} & _ngrx_store.Action<string>>;
declare const forceResizeViewport: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const videoAdaptedToContainer: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const videoStreamInitialized: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const setKalmanSettings: _ngrx_store.ActionCreator<string, (props: {
    settings: FilterSettings;
}) => {
    settings: FilterSettings;
} & _ngrx_store.Action<string>>;
declare const dropDC: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;
declare const dropPC: _ngrx_store.ActionCreator<string, () => _ngrx_store.Action<string>>;

declare class UnrealEffects {
    private actions$;
    private dialog;
    private http;
    private store;
    private isDevMode;
    private scrollStrategy;
    private unrealInitialConfig;
    private webRtcPlayerService;
    private commandsSender;
    private readonly commandTelemetryService;
    private signallingService;
    private videoService;
    private unrealCallbackService;
    private dataChannelConnectionTimeout;
    private connectionCompleted$;
    private reconnectConfig;
    disconnectReasonHandling$: rxjs.Observable<{
        reason: _3dsource_angular_unreal_module.DisconnectReasonType;
    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    destroyConnections$: rxjs.Observable<{
        reason: _3dsource_angular_unreal_module.DisconnectReasonType;
    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    destroyRemoteConnections$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    webrtcErrorModalComponent$: rxjs.Observable<false> & _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;
    sendLbmStatistics$: rxjs.Observable<Object> & _ngrx_effects.CreateEffectMetadata;
    resetAfk$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    abortEstablishingConnection$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    setMaxFps$: rxjs.Observable<{
        maxFps: number;
    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    setKalmanSettings$: rxjs.Observable<{
        settings: FilterSettings;
    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    setSignalingTo100$: rxjs.Observable<{
        percent: number | null;
    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    setOrchestrationParameters$: rxjs.Observable<{
        progressComplete: number;
    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    setDataChannelTimeoutCheck$: rxjs.Observable<{
        reason: _3dsource_angular_unreal_module.DisconnectReasonType;
        message: string;
    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    resetCirrusOnDestroy$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    destroyConnectionAndRestart$: rxjs.Observable<{
        resetDisconnectionReason: boolean;
    } & _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<Object> & _ngrx_effects.CreateEffectMetadata;
    unrealReceiverReady$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    initAppBySetDataChannelConnected$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    setViewportReadyBySetLoopBackCommandIsCompleted$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    startStream$: rxjs.Observable<{
        resetDisconnectionReason: boolean;
    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    connectToSignaling$: rxjs.Observable<WebSocket> & _ngrx_effects.CreateEffectMetadata;
    /**
     * Effect: `forceViewportNotReady$`
     *
     * Ensures the viewport is explicitly marked as *not ready* to prevent
     * a temporary black screen flash when disconnecting.
     *
     * ### Why
     * - The video stream is disconnected immediately.
     * - The DataChannel closes slightly later.
     * - Closing the DataChannel resets the Unreal scene,
     *   which also sets `viewPortReady` to `false`.
     *
     * Without this effect, the order of these events may cause
     * a visible flicker (video flashing to black).
     */
    forceViewportNotReady$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    /**
     * Effect: `handleDataChannelClosed$`
     *
     * Triggers peer reconnection when DataChannel closes unexpectedly.
     * Only triggers if reconnection is enabled, onDataChannelClose is true,
     * and the signaling WebSocket is still connected.
     */
    handleDataChannelClosed$: rxjs.Observable<{
        attempt: number;
        maxAttempts: number;
        delay?: number;
    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    /**
     * Effect: `resetStateForPeerReconnect$`
     *
     * Resets the data channel state when peer reconnection starts.
     */
    resetStateForPeerReconnect$: rxjs.Observable<_ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    /**
     * Effect: `executePeerReconnect$`
     *
     * Executes the actual peer reconnection attempt.
     * This only re-establishes the WebRTC connection, not the signaling.
     */
    executePeerReconnect$: rxjs.Observable<_ngrx_store.Action<string> | ({
        attempt: number;
        maxAttempts: number;
        delay?: number;
    } & _ngrx_store.Action<string>) | ({
        reason: string;
    } & _ngrx_store.Action<string>)> & _ngrx_effects.CreateEffectMetadata;
    /**
     * Effect: `handlePeerReconnectFailed$`
     *
     * Handles the case when all peer reconnection attempts have failed.
     * Falls back to full disconnection which may trigger full reconnection.
     */
    handlePeerReconnectFailed$: rxjs.Observable<{
        reason: _3dsource_angular_unreal_module.DisconnectReasonType;
        message: string;
    } & _ngrx_store.Action<string>> & _ngrx_effects.CreateEffectMetadata;
    /**
     * Effect: `logPeerReconnectSuccess$`
     *
     * Logs successful peer reconnection for telemetry.
     */
    logPeerReconnectSuccess$: rxjs.Observable<_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>;
    selectFreezeFrame: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.FreezeFrameMessage, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.FreezeFrameMessage>;
    selectLowBandwidth: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
    selectIsVideoPlaying: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
    selectStatusMessage: _ngrx_store.MemoizedSelector<Record<string, any>, string | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => string | null>;
    selectEnvironmentId: _ngrx_store.MemoizedSelector<Record<string, any>, string | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => string | null>;
    selectStreamRequestContext: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.StreamRequestContext | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.StreamRequestContext | null>;
    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>;
    selectIsFirstSuccessLoad: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
    selectIsAfkTimerVisible: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
    selectAfkCountdown: _ngrx_store.MemoizedSelector<Record<string, any>, number, (featureState: _3dsource_angular_unreal_module.UnrealState) => number>;
    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>;
    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.ConnectionError | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.ConnectionError | null>;
    selectIsReconnecting: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (featureState: _3dsource_angular_unreal_module.UnrealState) => boolean>;
    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>;
    selectDisconnectReason: _ngrx_store.MemoizedSelector<Record<string, any>, _3dsource_angular_unreal_module.DisconnectReasonType, (featureState: _3dsource_angular_unreal_module.UnrealState) => _3dsource_angular_unreal_module.DisconnectReasonType>;
    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>;
    selectAnalyticsEvent: _ngrx_store.MemoizedSelector<Record<string, any>, {
        name: string;
        params: Record<string, unknown>;
    } | null, (featureState: _3dsource_angular_unreal_module.UnrealState) => {
        name: string;
        params: Record<string, unknown>;
    } | null>;
};

interface UnrealState {
    lowBandwidthStats: LBMStats | undefined;
    streamConfig: StreamConfig;
    awsInstance: AwsInstance;
    lowBandwidth: boolean;
    isFirstSuccessLoad: boolean;
    isAfkTimerVisible: boolean;
    afkCountdown: number;
    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: ConnectionError | null;
    isReconnecting: boolean;
    dataChannelConnected: boolean;
    streamResolution: StreamResolutionProps;
    isVideoPlaying: boolean;
    establishingConnection: boolean;
    disconnectReason: DisconnectReasonType;
    matchUrls: string[];
    environmentId: string | null;
    streamClientCompanyId: string | null;
    streamViewId: string | null;
    videoIntroSrc: string | null;
    imageIntroSrc: string | null;
    imageLoadingSrc: string;
    streamRequestContext: StreamRequestContext | null;
    analyticsEvent: {
        name: string;
        params: Record<string, unknown>;
    } | null;
}
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 selectIsExistMatchUrls: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (s1: string[]) => boolean>;
declare const selectIsAutostart: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (s1: _3dsource_angular_unreal_module.StreamConfig) => boolean>;
declare const selectShowReconnectPopup: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (s1: boolean, s2: boolean) => boolean>;
declare const selectShowLoader: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (s1: boolean, s2: 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>;
/**
 * 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, s4: boolean) => number>;
declare const selectClientAndViewIds: _ngrx_store.MemoizedSelector<Record<string, any>, {
    clientId: string | null;
    viewId: string | null;
}, (s1: string | null, s2: string | null) => {
    clientId: string | null;
    viewId: string | null;
}>;
declare const selectIsLoaderScreenVisible: _ngrx_store.MemoizedSelector<Record<string, any>, boolean, (s1: boolean, s2: boolean, s3: boolean) => boolean>;
declare const selectCirrusConnectionId: _ngrx_store.MemoizedSelector<Record<string, any>, string | undefined, (s1: _3dsource_angular_unreal_module.SignalingData | null) => string | undefined>;

export { AFKService, AfkTimeoutModalComponent, AggregatorService, AnalyticsService, AnswerHandler, CONSOLE_COMMAND_DISABLE_MESSAGES, CONSOLE_COMMAND_ENABLE_MESSAGES, CONSOLE_COMMAND_PIXEL_QUALITY, CommandTelemetryService, CommandsEffects, ConfigHandler, ConsoleExtensionsService, ControlScheme, DATA_CHANNEL_CONNECTION_TIMEOUT, DEBOUNCE_TO_MANY_RESIZE_CALLS, DEFAULT_AFK_TIMEOUT, DEFAULT_AFK_TIMEOUT_PERIOD, DEFAULT_RECONNECT_DELAY_MS, DEFAULT_RECONNECT_ENABLED, DEFAULT_RECONNECT_MAX_ATTEMPTS, DEFAULT_RECONNECT_ON_DATACHANNEL_CLOSE, DEFAULT_RECONNECT_ON_ICE_FAILURE, DataFlowMonitor, DevModeService, DisconnectReason, FULL_HD_HEIGHT, FULL_HD_WIDTH, FileHandlerService, FileReceiverService, FilterSettingsComponent, FpsMonitorService, FreezeFrameComponent, FreezeFrameService, IceCandidateHandler, ImageLoadingSrcComponent, InputOptions, InputService, InstanceReadyHandler, InstanceReservedHandler, IntroSrcComponent, KalmanFilter1D, LatencyTimings, LowBandwidthDetectorComponent, LowBandwidthModalComponent, MINIMAL_FPS, MessageType, MouseButton, MouseButtonsMask, OnCloseHandler, OnErrorHandler, OnMessageHandler, OnOpenHandler, OrchestrationMessageTypes, POLLING_TIME, PingHandler, PlayerCountHandler, RegionsPingService, SAME_SIZE_THRESHOLD, SCREEN_LOCKER_CONTAINER_ID, SIGNALLING_PERCENT_VALUE, SSInfoHandler, STREAMING_VIDEO_ID, SafePipe, SignallingService, SpecialKeyCodes, StatGraphComponent, StreamStatusTelemetryService, StreamStatusTelemetryService2, SubService, ToClientMessage, UNREAL_CONFIG, UnrealCallbackService, UnrealCommunicatorService, UnrealEffects, UnrealSceneComponent, UnrealStatusMessage, VideoService, VideoStatsComponent, WSCloseCode_CIRRUS_ABNORMAL_CLOSURE, WSCloseCode_CIRRUS_MAX_PLAYERS_ERROR, WSCloseCode_CIRRUS_PLAYER_DISCONNECTED, WSCloseCode_CIRRUS_STREAMER_KIKED_PLAYER, WSCloseCode_FORCE_CIRRUS_CLOSE, WSCloseCode_NORMAL_AFK_TIMEOUT, WSCloseCode_NORMAL_CLOSURE, WSCloseCode_NORMAL_MANUAL_DISCONNECT, WSCloseCode_UNKNOWN, WSCloseCodes, WS_OPEN_STATE, WS_TIMEOUT, WebRtcPlayerService, WebrtcErrorModalComponent, abortEstablishingConnection, answerSent, changeLowBandwidth, changeStatusMainVideoOnScene, changeStreamResolutionAction, changeStreamResolutionSuccessAction, commandCompleted, commandStarted, commandsFeature, commandsReducer, dataChannelConnected, dataChannelReady, decodeData, destroyRemoteConnections, destroyUnrealScene, disconnectStream, dispatchResize, dropConnection, dropDC, dropPC, floatToSmoothPercents, forceResizeViewport, fromResizeObserver, getActiveUrl, getImageFromVideoStream, getResizeStudioValues, getResizeStudioValuesOld, getResizeValuesUniversal, getResizeValuesUniversalOld, getRtcErrorMessage, iceConnectionFailed, initSignalling, instanceReady, keepMaxUntilReset, makeEven, pollingEnded, pollingStarted, provideUnrealModule, qpToQuality, reconnectPeer, reconnectPeerFailed, reconnectPeerSuccess, regionPingFetchEnd, regionPingFetchStart, regionResolved, resetAfk, resetConfig, resetDataChannelForReconnect, resetIntroSrc, resetWarnTimeout, saveAnalyticsEvent, selectCirrusConnectionId, selectClientAndViewIds, selectCommandProgress, selectCommandsInProgress, selectFreezeFrameCombinedDataUrl, selectFreezeFrameDataUrl, selectFreezeFrameDataUrlFromVideo, selectFreezeFrameProgressMessageFromVideo, selectIsAutostart, selectIsExistMatchUrls, selectIsFreezeFrameLoading, selectIsLoaderScreenVisible, selectIsVideoPlayingAndDataChannelConnected, selectShowLoader, selectShowReconnectPopup, selectSignalingParameters, selectStreamConfig, selectTotalProgress, selectWarnTimeout, setAfkTimerCountdown, setAfkTimerHide, setAfkTimerVisible, setAwsInstance, setCirrusConnected, setCirrusDisconnected, setConfig, setDataChannelConnected, setEstablishingConnection, setFreezeFrame, setFreezeFrameFromVideo, setIntroImageSrc, setIntroVideoSrc, setKalmanSettings, setLoadingImageSrc, setLoopBackCommandIsCompleted, setMaxFps, setOrchestrationContext, setOrchestrationMessage, setOrchestrationParameters, setOrchestrationProgress, setSignalingName, setStatusMessage, setStatusPercentSignallingServer, setStreamClientCompanyId, setStreamViewId, setUnrealPlaywrightConfig, setViewportNotReady, setViewportReady, showUnrealErrorMessage, smoothTransition, startStream, trackMixpanelEvent, trackTelemetryData, unrealCommandCallback, unrealFeature, unrealReducer, updateCirrusInfo, videoAdaptedToContainer, videoStreamInitialized };
export type { AggregatedStat, AnySignalingMessage, AwsInstance, CandidateMessage, CloseReason, ConfigMessage, ConnectionError, ControlSchemeValues, DataFlowCheckResult, DisconnectReasonType, EmittedMilestone, ForceClientDisconnect, FreezeFrameMessage, InboundVideoStats, InputProps, InstanceReady, InstanceReserved, InterruptClientStream, LBMStats, ListStreamersMessage, MessageBase, MessageTypeValues, NormalizeAndQuantizeSignedValue, NormalizeAndQuantizeUnsignedValue, OrchestrationErrorMessage, OrchestrationMessageType, P2PEstablishedMessage, PhaseOverlay, PhaseParam, PingMessage, PlayerCountMessage, PollingOrchestrationMessage, Quality, ReceivedFile, ReconnectConfig, RequestStream, SSInfo, SelectedIceCandidatePair, SignalingData, SignalingMessageHandler, SignalingMessageMap, StreamConfig, StreamRequestContext, StreamResolutionProps, StreamerListMessage, TelemetryType, UnknownFields, UnquantizeAndDenormalizeUnsignedValue, UnrealCallbackDescriptor, UnrealCallbackEventMap, UnrealCallbackJson, UnrealCallbackJsonWrapped, UnrealCommandsState, UnrealInitialConfig, UnrealState, WSCloseCodesValues, streamPreparedForUserInteractionMessage };