@3dsource/angular-unreal-module 0.0.1

package/lib/constants/timeout.constant.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_TIMEOUT_PERIOD = 15;
+export declare const DEFAULT_WARN_TIMEOUT = 120;
+export declare const DEFAULT_SHOWCASE_TIMEOUT = 120;
+export declare const DEFAULT_PDF_TIMEOUT = 300;
+export declare const DEFAULT_RENDER_SPINNER_TIMEOUT: number;
+export declare const DATA_CHANNEL_CONNECTION_TIMEOUT = 5000;

package/lib/constants/unreal.constant.d.ts

@@ -0,0 +1,11 @@
+export declare const DEBOUNCE_TO_MANY_RESIZE_CALLS = 100;
+export declare const SAME_SIZE_THRESHOLD = 1.01;
+export declare const MINIMAL_FPS = 6;
+export declare const STREAMING_VIDEO_ID = "streamingVideo";
+export declare const CONSOLE_COMMAND_ENABLE_MESSAGES = "EnableAllScreenMessages";
+export declare const CONSOLE_COMMAND_DISABLE_MESSAGES = "DisableAllScreenMessages";
+export declare const CONSOLE_COMMAND_PIXEL_QUALITY = "PixelStreaming.FreezeFrameQuality 95";
+export declare const FULL_HD_WIDTH = 1920;
+export declare const FULL_HD_HEIGHT = 1080;
+export declare const WS_TIMEOUT = 2000;
+export declare const WS_OPEN_STATE = 1;

package/lib/constants/unreal.providers.d.ts

@@ -0,0 +1,15 @@
+import { AFKService } from '../services/afk.service';
+import { AggregatorService } from '../services/aggregator.service';
+import { CommandTelemetryService } from '../services/command-telemetry.service';
+import { ConsoleExtensionsService } from '../services/console-extensions.service';
+import { FreezeFrameService } from '../services/freeze-frame.service';
+import { InputService } from '../services/input.service';
+import { SignallingService } from '../services/signalling.service';
+import { StreamStatusTelemetryService } from '../services/stream-status-telemetry.service';
+import { UnrealCommunicatorService } from '../services/unreal-communicator.service';
+import { VideoService } from '../services/video.service';
+import { VideoStreamStatusService } from '../services/video-stream-status.service';
+import { WebRtcPlayerService } from '../services/web-rtc-player.service';
+import { ImageCaptureService } from '../services/image-capture.service';
+import { RegionsPingService } from '../services/regions-ping.service';
+export declare const UNREAL_PROVIDERS: (import("@angular/core").EnvironmentProviders | (typeof CommandTelemetryService | typeof WebRtcPlayerService | typeof VideoStreamStatusService | typeof VideoService | typeof AFKService | typeof FreezeFrameService | typeof ConsoleExtensionsService | typeof UnrealCommunicatorService | typeof ImageCaptureService | typeof RegionsPingService | typeof SignallingService | typeof InputService | typeof AggregatorService | typeof StreamStatusTelemetryService)[])[];

package/lib/helpers/CommandObserver.d.ts

@@ -0,0 +1,8 @@
+import type { MetaBoxCommandList, MetaBoxCommandPacket } from '@struct';
+import type { Observable } from 'rxjs';
+export declare function observeCommandResponse<K extends keyof MetaBoxCommandList, T extends MetaBoxCommandList[K] = MetaBoxCommandList[K]>(data: T, sender: (data: T) => void, timeOut?: number, dispatchOnTimeout?: boolean): Observable<ObservedCallbackResponse<T> | never>;
+export interface ObservedCallbackResponse<T extends MetaBoxCommandPacket> {
+    json: {
+        commandCallback: T;
+    };
+}

package/lib/helpers/DataDecoder.d.ts

@@ -0,0 +1 @@
+export declare function decodeData(anyData: any): string;

package/lib/helpers/DataFlowMonitor.d.ts

@@ -0,0 +1,39 @@
+import type { Quality } from '../interfaces/quality.interface';
+import type { FilterSettings } from '../components/low-bandwidth-indicator/DataFlowConstants';
+export interface DataFlowCheckResult {
+    isDropDetected: boolean;
+    dropPercentage: number;
+    activeMedian: number;
+    quality: Quality;
+    message: string;
+    dataHistory: number[];
+    config: {
+        yellowFlagThresholdPercentage: number;
+        redFlagThresholdPercentage: number;
+        historyBufferLength: number;
+        splitPoint: number;
+    };
+}
+export 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;
+}

package/lib/helpers/EventWrapper.d.ts

@@ -0,0 +1,18 @@
+import type { SignalDescriptor } from '../interfaces/unreal-internal-signal-events.interface';
+import type { Observable } from 'rxjs';
+import type { MetaBoxCommandList } from '@struct';
+type Descriptor = MetaBoxCommandList & SignalDescriptor;
+/**
+ * UnrealInternalSignalEvents commands list wrapper listener
+ * @param event
+ */
+export declare function fromSignal<K extends keyof Descriptor>(event: K): Observable<Descriptor[K]>;
+type ArgumentType<K extends keyof Descriptor> = Descriptor[K] extends void ? never : Descriptor[K];
+/**
+ * UnrealInternalSignalEvents commands list wrapper sender
+ * @param event
+ * @param args
+ */
+export declare function sendSignal<K extends keyof Descriptor>(event: K, ...args: ArgumentType<K> extends never ? [] : [ArgumentType<K>]): void;
+export declare function fromUnrealCallBackSignal<K extends keyof Descriptor>(command: K): Observable<Descriptor[K]>;
+export {};

package/lib/helpers/FromStreamerHandlers/AnswerHandler.d.ts

@@ -0,0 +1,3 @@
+import type { SignallingService } from '../../services/signalling.service';
+import type { AnswerMessage } from '../../interfaces/SignalingMessage';
+export declare function AnswerHandler(this: SignallingService, msg: AnswerMessage): void;

package/lib/helpers/FromStreamerHandlers/ConfigHandler.d.ts

@@ -0,0 +1,3 @@
+import type { SignallingService } from '../../services/signalling.service';
+import type { ConfigMessage } from '../../interfaces/SignalingMessage';
+export declare function ConfigHandler(this: SignallingService, msg: ConfigMessage): void;

package/lib/helpers/FromStreamerHandlers/IceCandidateHandler.d.ts

@@ -0,0 +1,4 @@
+import type { SignallingService } from '../../services/signalling.service';
+export declare function IceCandidateHandler(this: SignallingService, msg: {
+    candidate: RTCIceCandidate;
+}): void;

package/lib/helpers/FromStreamerHandlers/InstanceReadyHandler.d.ts

@@ -0,0 +1,3 @@
+import type { InstanceReady } from '../../interfaces/SignalingMessage';
+import type { SignallingService } from '../../services/signalling.service';
+export declare function InstanceReadyHandler(this: SignallingService, msg: InstanceReady): void;

package/lib/helpers/FromStreamerHandlers/InstanceReservedHandler.d.ts

@@ -0,0 +1,3 @@
+import type { InstanceReserved } from '../../interfaces/SignalingMessage';
+import type { SignallingService } from '../../services/signalling.service';
+export declare function InstanceReservedHandler(this: SignallingService, msg: InstanceReserved): void;

package/lib/helpers/FromStreamerHandlers/PingHandler.d.ts

@@ -0,0 +1,2 @@
+import type { SignallingService } from '../../services/signalling.service';
+export declare function PingHandler(this: SignallingService): void;

package/lib/helpers/FromStreamerHandlers/PlayerCountHandler.d.ts

@@ -0,0 +1,3 @@
+import type { SignallingService } from '../..//services/signalling.service';
+import type { PlayerCountMessage } from '../..//interfaces/SignalingMessage';
+export declare function PlayerCountHandler(this: SignallingService, msg: PlayerCountMessage): void;

package/lib/helpers/FromStreamerHandlers/SSInfoHandler.d.ts

@@ -0,0 +1,3 @@
+import type { SignallingService } from '../../services/signalling.service';
+import type { SSInfo } from '../../interfaces/SignalingMessage';
+export declare function SSInfoHandler(this: SignallingService, msg: SSInfo): null;

package/lib/helpers/FromStreamerHandlers/index.d.ts

@@ -0,0 +1,8 @@
+export * from './AnswerHandler';
+export * from './ConfigHandler';
+export * from './IceCandidateHandler';
+export * from './InstanceReadyHandler';
+export * from './InstanceReservedHandler';
+export * from './PingHandler';
+export * from './PlayerCountHandler';
+export * from './SSInfoHandler';

package/lib/helpers/GetNextUrl.d.ts

@@ -0,0 +1 @@
+export declare function getActiveUrl(urls: string[]): Generator<string, void, unknown>;

package/lib/helpers/KalmanFilter1D.d.ts

@@ -0,0 +1,20 @@
+import type { FilterSettings } from '../components/low-bandwidth-indicator/DataFlowConstants';
+export 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;
+}

package/lib/helpers/LatencyTimings.d.ts

@@ -0,0 +1,13 @@
+export declare class LatencyTimings {
+    TestStartTimeMs: number | null;
+    UEReceiptTimeMs: number | null;
+    UEEncodeMs: number | null;
+    UECaptureToSendMs: number | null;
+    UETransmissionTimeMs: number | null;
+    BrowserReceiptTimeMs: number | null;
+    FrameDisplayDeltaTimeMs: number | null;
+    Reset(): void;
+    SetUETimings(UETimings: any): void;
+    SetFrameDisplayDeltaTime(DeltaTimeMs: number): void;
+    OnAllLatencyTimingsReady(Timings: any): void;
+}

package/lib/helpers/TouchEmulator.d.ts

@@ -0,0 +1,24 @@
+import type { InputService } from '../services/input.service';
+export default class TouchEmulator {
+    private host;
+    private lastDistance;
+    private prevDistance;
+    private touchReset;
+    private delta;
+    private moveSensitivityScale;
+    private prevX;
+    private prevY;
+    constructor(host: InputService);
+    private getPosition;
+    private getCenter;
+    private getDistance;
+    updateDistance(touches: TouchList): {
+        x: number;
+        y: number;
+    };
+    private touchToVector2;
+    private twoFingersAction;
+    private threeFingersActionMove;
+    private twoFingersActionZoom;
+    private registerTouchEvents;
+}

package/lib/helpers/VideoRecorder.d.ts

@@ -0,0 +1,8 @@
+export declare class VideoRecorder {
+    private recordedChunks;
+    private mediaRecorder;
+    capture(canvas: any): void;
+    stop(): void;
+    handleDataAvailable(event: any): void;
+    download(): void;
+}

package/lib/helpers/WsHandlers/OnCloseHandler.d.ts

@@ -0,0 +1,2 @@
+import type { SignallingService } from '../../services/signalling.service';
+export declare function OnCloseHandler(this: SignallingService, e: CloseEvent): void;

package/lib/helpers/WsHandlers/OnErrorHandler.d.ts

@@ -0,0 +1,2 @@
+import type { SignallingService } from '../../services/signalling.service';
+export declare function OnErrorHandler(this: SignallingService, e: Event): void;

package/lib/helpers/WsHandlers/OnMessageHandler.d.ts

@@ -0,0 +1,2 @@
+import type { SignallingService } from '../../services/signalling.service';
+export declare function OnMessageHandler(this: SignallingService, e: MessageEvent<string>): void;

package/lib/helpers/WsHandlers/OpenHandler.d.ts

@@ -0,0 +1,2 @@
+import type { SignallingService } from '../../services/signalling.service';
+export declare function OnOpenHandler(this: SignallingService): void;

package/lib/helpers/WsHandlers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './OnCloseHandler';
+export * from './OnErrorHandler';
+export * from './OnMessageHandler';
+export * from './OpenHandler';

package/lib/helpers/clamp-and-keep-max-percents.d.ts

@@ -0,0 +1,2 @@
+import type { Observable } from 'rxjs';
+export declare const clampAndKeepMaxPercents: () => ((source: Observable<number>) => Observable<number>);

package/lib/helpers/deepEqual.d.ts

@@ -0,0 +1 @@
+export declare const deepEqual: (a: any, b: any) => boolean;

package/lib/helpers/dispatchResize.d.ts

@@ -0,0 +1,2 @@
+export declare const dispatchResize: () => void;
+export declare const forceResizeUnrealVideo: () => void;

package/lib/helpers/error-codes.d.ts

@@ -0,0 +1 @@
+export declare function getRtcErrorMessage(code: number | null): string | undefined;

package/lib/helpers/float-to-smooth-percents.d.ts

@@ -0,0 +1,2 @@
+import type { Observable } from 'rxjs';
+export declare const floatToSmoothPercents: () => ((source: Observable<number>) => Observable<number>);

package/lib/helpers/get-image-from-video-stream.d.ts

@@ -0,0 +1,3 @@
+import type { ImageOutputValues } from '@3dsource/utils';
+import type { StreamResolutionProps } from '../interfaces/stream-resolution.interface';
+export declare const getImageFromVideoStream: (takeSizeFrom?: "video" | "constant", imageOutput?: ImageOutputValues, sizes?: StreamResolutionProps) => string | null;

package/lib/helpers/index.d.ts

@@ -0,0 +1,21 @@
+export * from './FromStreamerHandlers';
+export * from './WsHandlers';
+export * from './clamp-and-keep-max-percents';
+export * from './CommandObserver';
+export * from './DataDecoder';
+export * from './DataFlowMonitor';
+export * from './dispatchResize';
+export * from './error-codes';
+export * from './EventWrapper';
+export * from './float-to-smooth-percents';
+export * from './get-image-from-video-stream';
+export * from './GetNextUrl';
+export * from './KalmanFilter1D';
+export * from './LatencyTimings';
+export * from './mapQpToQuality';
+export * from './prepare-commands';
+export * from './remove-exile-commands';
+export * from './resetAfk';
+export * from './resize-observer';
+export * from './TouchEmulator';
+export * from './VideoRecorder';

package/lib/helpers/mapQpToQuality.d.ts

@@ -0,0 +1,2 @@
+import type { Quality } from '../interfaces/quality.interface';
+export declare function mapQpToQuality(VideoEncoderQP: number): Quality;

package/lib/helpers/prepare-commands.d.ts

@@ -0,0 +1,52 @@
+import type { FAlignProductsToPlaneCommand, FAlignProductsToPlanePayload, FApplyCameraPresetCommand, FApplyZoomCommand, FApplyZoomPayload, FBoolPayload, FCameraBoxCommand, FCameraClampsPayload, FCameraPresetPayload, FCameraRecenterCommand, FCameraSettingsCommand, FCameraSettingsPayload, FChangeGizmoTypeCommand, FChangeResolutionCommand, FClampPanToProductsCommand, FClickSnapCommand, FComposurePayload, FControlCameraModePayload, FControlSensitivityCommand, FControlSensitivityPayload, FDebugModeCommand, FDragCommand, FDragSequenceCommand, FDragSequencePayload, FDropCommand, FDropPayload, FEnableComposureCommand, FEnableControlsCommand, FEnableSpinnerModeCommand, FEnableTeleportCommand, FExecuteConsoleCommandCommand, FFitToObjectsCommand, FFitToObjectsPayload, FFreezeFrameCommand, FFStringPayload, FFStringsPayload, FFVectorPayload, FGizmoTypePayload, FInitSequenceByObjectNameCommand, FInitSequenceByObjectNamePayload, FJumpToSequenceCommand, FJumpToSequencePayload, FLevelPayload, FLoadLevelCommand, FLoadProductCommand, FLoadSceneStateCommand, FLoadSceneStatePayload, FLoopBackCommand, FMoveSelectedCommand, FMoveSelectedPayload, FPauseSequenceCommand, FPlaySequenceCommand, FPlaySequencePayload, FProductPayload, FRenderPayload, FRequestCameraPresetCommand, FResetControlClampsCommand, FResolutionPayload, FRotatePayload, FRotateSelectedCommand, FSelectProductByObjectNameCommand, FSelectProductByObjectNamePayload, FSetCameraControlClampsCommand, FSetControlCameraModeCommand, FSetMaterialCommand, FSetMaterialPayload, FSetPawnMovementModeCommand, FSetPawnMovementModePayload, FSetProductsLocationCommand, FSetProductsLocationPayload, FSetSettingsSequenceCommand, FSettingsSequencePayload, FStopSequenceCommand, FTakeRenderCommand, FTakeSpinnerRenderCommand, FTakeSpinnerRenderPreviewCommand, FUnLoadAllLevelsCommand, FUnLoadAllProductsCommand, FUnLoadProductByObjectNameCommand, FUnselectAllProductsCommand, FWeatherCommand, FWeatherPayload } from '@struct';
+export declare const getResetControlClampsCommand: () => FResetControlClampsCommand;
+export declare const getCameraRecenterCommand: () => FCameraRecenterCommand;
+export declare const unLoadAllLevelsCommand: () => FUnLoadAllLevelsCommand;
+export declare const getDragCommand: () => FDragCommand;
+export declare const getUnselectAllProductsCommand: () => FUnselectAllProductsCommand;
+export declare const getPauseSequenceCommand: () => FPauseSequenceCommand;
+export declare const getStopSequenceCommand: () => FStopSequenceCommand;
+export declare const getUnLoadAllProductsCommand: () => FUnLoadAllProductsCommand;
+export declare const getRequestCameraPresetCommand: () => FRequestCameraPresetCommand;
+export declare const getLoopBackCommand: () => FLoopBackCommand;
+export declare const getSetFpsCommand: (fpsRequired: number) => FExecuteConsoleCommandCommand;
+export declare const getFreezeFrameCommand: (payload: FBoolPayload, source: string) => FFreezeFrameCommand;
+export declare const getDragSequenceCommand: (payload: FDragSequencePayload) => FDragSequenceCommand;
+export declare const alignProductsToPlaneCommand: (payload: FAlignProductsToPlanePayload) => FAlignProductsToPlaneCommand;
+export declare const getApplyCameraPresetCommand: (payload: FCameraPresetPayload) => FApplyCameraPresetCommand;
+export declare const getLoadSceneStateCommand: (payload: FLoadSceneStatePayload) => FLoadSceneStateCommand;
+export declare const getClickSnapCommand: (payload: FBoolPayload) => FClickSnapCommand;
+export declare const getSetControlCameraModeCommand: (payload: FControlCameraModePayload) => FSetControlCameraModeCommand;
+export declare const getSetCameraControlClampsCommand: (payload: FCameraClampsPayload) => FSetCameraControlClampsCommand;
+export declare const getSetPawnMovementModeCommand: (payload: FSetPawnMovementModePayload) => FSetPawnMovementModeCommand;
+export declare const getEnableTeleportCommand: (payload: FBoolPayload) => FEnableTeleportCommand;
+export declare const getApplyZoomCommand: (payload: FApplyZoomPayload) => FApplyZoomCommand;
+export declare const getCameraBoxCommand: (payload: FFVectorPayload) => FCameraBoxCommand;
+export declare const getDropCommand: (payload?: FDropPayload) => FDropCommand;
+export declare const getSelectProductByObjectNameCommand: (payload: FSelectProductByObjectNamePayload) => FSelectProductByObjectNameCommand;
+export declare const getChangeGizmoTypeCommand: (payload: FGizmoTypePayload) => FChangeGizmoTypeCommand;
+export declare const getWeatherCommand: (payload: FWeatherPayload) => FWeatherCommand;
+export declare const getFitToObjectsCommand: (payload?: FFitToObjectsPayload) => FFitToObjectsCommand;
+export declare const setProductsLocationCommand: (payload: FSetProductsLocationPayload) => FSetProductsLocationCommand;
+export declare const getChangeResolutionCommand: (payload: FResolutionPayload) => FChangeResolutionCommand;
+export declare const getEnableSpinnerModeCommand: (payload: FBoolPayload) => FEnableSpinnerModeCommand;
+export declare const getControlSensitivityCommand: (payload: FControlSensitivityPayload) => FControlSensitivityCommand;
+export declare const getCameraSettingsCommand: (payload: FCameraSettingsPayload) => FCameraSettingsCommand;
+export declare const getDebugModeCommand: (payload: FBoolPayload) => FDebugModeCommand;
+export declare const getEnableControlsCommand: (payload: FBoolPayload) => FEnableControlsCommand;
+export declare const getExecuteConsoleCommand: (payload: FFStringPayload) => FExecuteConsoleCommandCommand;
+export declare const getInitSequenceByObjectNameCommand: (payload: FInitSequenceByObjectNamePayload) => FInitSequenceByObjectNameCommand;
+export declare const getPlaySequenceCommand: (payload: FPlaySequencePayload) => FPlaySequenceCommand;
+export declare const getJumpToSequenceCommand: (payload: FJumpToSequencePayload) => FJumpToSequenceCommand;
+export declare const getMoveSelectedCommand: (payload: FMoveSelectedPayload) => FMoveSelectedCommand;
+export declare const getRotateSelectedCommand: (payload: FRotatePayload) => FRotateSelectedCommand;
+export declare const getTakeRenderCommand: (payload: FRenderPayload) => FTakeRenderCommand;
+export declare const getTakeSpinnerRenderPreviewCommand: (payload: FRenderPayload) => FTakeSpinnerRenderPreviewCommand;
+export declare const getTakeSpinnerRenderCommand: (payload: FRenderPayload) => FTakeSpinnerRenderCommand;
+export declare const getSetMaterialCommand: (payload: FSetMaterialPayload) => FSetMaterialCommand;
+export declare const getLoadProductCommand: (payload: FProductPayload) => FLoadProductCommand;
+export declare const getUnLoadProductByObjectNameCommand: (payload: FFStringPayload) => FUnLoadProductByObjectNameCommand;
+export declare const getLoadLevelCommand: (payload: FLevelPayload) => FLoadLevelCommand;
+export declare const getEnableComposureCommand: (payload: FComposurePayload) => FEnableComposureCommand;
+export declare const clampPanToProductsCommand: (payload?: FFStringsPayload) => FClampPanToProductsCommand;
+export declare const getSetSettingsSequenceCommand: (payload: FSettingsSequencePayload) => FSetSettingsSequenceCommand;

package/lib/helpers/remove-exile-commands.d.ts

@@ -0,0 +1,10 @@
+import type { CommandsLoaderState } from '../store/unreal.reducer';
+export declare const removeExileCommands: (state: CommandsLoaderState, idToRemove: string) => {
+    commandsInProgress: {
+        timeStamp: number;
+        command: import("../constants/struct").MetaBoxCommand;
+        id: string;
+    }[];
+    totalCommandsStarted: number;
+    totalCommandsCompleted: number;
+};

package/lib/helpers/resetAfk.d.ts

@@ -0,0 +1 @@
+export declare const resetAfk: () => void;

package/lib/helpers/resize-observer.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from 'rxjs';
+export declare function fromResizeObserver(elem: HTMLElement): Observable<ResizeObserverEntry[]>;

package/lib/interfaces/CloseReason.d.ts

@@ -0,0 +1,5 @@
+import type { WSCloseCodesValues } from './CustomCloseCodes';
+export interface CloseReason {
+    code: WSCloseCodesValues;
+    reason: string;
+}

package/lib/interfaces/CustomCloseCodes.d.ts

@@ -0,0 +1,6 @@
+export declare const WSCloseCode_NORMAL_CLOSURE = 3000;
+export declare const WSCloseCode_NORMAL_AFK_TIMEOUT = 3001;
+export declare const WSCloseCode_NORMAL_MANUAL_DISCONNECT = 3002;
+export declare const WSCloseCode_NORMAL_CIRRUS_CLOSED = 3003;
+export declare const WSCloseCodes: readonly [3000, 3001, 3002, 3003];
+export type WSCloseCodesValues = (typeof WSCloseCodes)[number];

package/lib/interfaces/LBMStats.d.ts

@@ -0,0 +1,6 @@
+import type { DataFlowCheckResult } from '../helpers/DataFlowMonitor';
+export interface LBMStats {
+    dataFlowResult: DataFlowCheckResult;
+    reason: string;
+    triggerTime: number;
+}

package/lib/interfaces/SignalingData.d.ts

@@ -0,0 +1,8 @@
+export interface SignalingData {
+    branchInfo: string;
+    cirrusVersion: string;
+    streamerVersion: string;
+    streamPath: string;
+    streamApp: string;
+    connectionId: string;
+}

package/lib/interfaces/SignalingMessage.d.ts

@@ -0,0 +1,77 @@
+import type { SignalingData } from '../interfaces/SignalingData';
+export interface InstanceReady extends InstanceMessageBase {
+    type: 'instanceReady';
+}
+export interface InstanceReserved extends InstanceMessageBase {
+    type: 'instanceReserved';
+}
+interface InstanceMessageBase extends MessageBase {
+    correlationId: string;
+    payload: {
+        instanceId: string;
+    };
+}
+export interface MessageBase {
+    type: OrchestrationMessageType;
+}
+export interface SSInfo extends MessageBase {
+    type: 'ssInfo';
+    message: string;
+    data: SignalingData;
+}
+export interface PlayerCountMessage extends MessageBase {
+    type: 'playerCount';
+    playerCount: number;
+}
+export interface AnswerMessage extends RTCSessionDescriptionInit {
+    type: RTCSdpType;
+}
+export interface ConfigMessage extends MessageBase, UnknownFields {
+    type: 'config';
+    peerConnectionOptions: RTCConfiguration;
+}
+export interface CandidateMessage extends MessageBase {
+    type: 'iceCandidate';
+    candidate: RTCIceCandidate;
+}
+export interface PingMessage extends MessageBase {
+    type: 'ping';
+    playerId: string;
+    appConnectionCounter: number;
+}
+export type UnknownFields = Record<string, unknown>;
+export declare const OrchestrationMessageTypes: {
+    readonly requestReservation: "requestReservation";
+    readonly instanceReady: "instanceReady";
+    readonly instanceReserved: "instanceReserved";
+    readonly ssInfo: "ssInfo";
+    readonly playerCount: "playerCount";
+    readonly answer: "answer";
+    readonly iceCandidate: "iceCandidate";
+    readonly ping: "ping";
+    readonly config: "config";
+};
+export interface SignalingMessageMap {
+    [OrchestrationMessageTypes.ssInfo]: SSInfo;
+    [OrchestrationMessageTypes.playerCount]: PlayerCountMessage;
+    [OrchestrationMessageTypes.answer]: AnswerMessage;
+    [OrchestrationMessageTypes.config]: ConfigMessage;
+    [OrchestrationMessageTypes.iceCandidate]: CandidateMessage;
+    [OrchestrationMessageTypes.instanceReady]: InstanceReady;
+    [OrchestrationMessageTypes.instanceReserved]: InstanceReserved;
+    [OrchestrationMessageTypes.ping]: PingMessage;
+}
+export type OrchestrationMessageType = keyof SignalingMessageMap;
+export type SignalingMessageHandler<T extends keyof SignalingMessageMap> = (msg: SignalingMessageMap[T]) => void;
+export interface PollingOrchestrationMessage {
+    mm_message?: string;
+    signallingServer?: string;
+    error?: string;
+    info?: {
+        age: number | null;
+        left: number | null;
+        percent: number | null;
+        total: number | null;
+    };
+}
+export {};

package/lib/interfaces/TelemetryEvent.d.ts

@@ -0,0 +1 @@
+export type TelemetryType = 'commandSent' | 'commandStop';

package/lib/interfaces/disconnect-reasons.d.ts

@@ -0,0 +1,9 @@
+export declare const DisconnectReason: {
+    readonly afk: "afk";
+    readonly none: "none";
+    readonly reset: "reset";
+    readonly wsOnError: "wsOnError";
+    readonly dataChannelClosed: "dataChannelClosed";
+    readonly dataChannelTimeout: "dataChannelTimeout";
+};
+export type DisconnectType = (typeof DisconnectReason)[keyof typeof DisconnectReason];

package/lib/interfaces/errors.interface.d.ts

@@ -0,0 +1,5 @@
+export interface UnrealError {
+    errorType: UnrealErrorType;
+    message: string;
+}
+export type UnrealErrorType = 'WebRTCError' | 'WebSocketError';

package/lib/interfaces/freeze-frame-message.interface.d.ts

@@ -0,0 +1,4 @@
+export interface FreezeFrameMessage {
+    dataUrl: string | null;
+    progress: number | null;
+}

package/lib/interfaces/index.d.ts

@@ -0,0 +1,16 @@
+export * from './CloseReason';
+export * from './CustomCloseCodes';
+export * from './disconnect-reasons';
+export * from './errors.interface';
+export * from './freeze-frame-message.interface';
+export * from './initial-config';
+export * from './input.interface';
+export * from './LBMStats';
+export * from './mix-panel-events';
+export * from './quality.interface';
+export * from './SignalingData';
+export * from './SignalingMessage';
+export * from './stream-config.interface';
+export * from './stream-resolution.interface';
+export * from './TelemetryEvent';
+export * from './unreal-internal-signal-events.interface';

package/lib/interfaces/initial-config.d.ts

@@ -0,0 +1,8 @@
+export interface UnrealInitialConfig {
+    customErrorsEndpoint: string;
+    commandTelemetryReceiver: string;
+    regionsPingUrl: string;
+    signalling: Record<string, string>;
+    mixpanelToken: string;
+    mixpanelStreamToken: string;
+}

package/lib/interfaces/input.interface.d.ts

@@ -0,0 +1,19 @@
+import type { EControlSchemeTypeValues } from '../constants/EControlSchemeType';
+export interface NormalizeAndQuantizeUnsignedValue {
+    inRange: boolean;
+    x: number;
+    y: number;
+}
+export interface UnquantizeAndDenormalizeUnsignedValue {
+    x: number;
+    y: number;
+}
+export interface NormalizeAndQuantizeSignedValue {
+    x: number;
+    y: number;
+}
+export interface InputProps {
+    controlScheme: EControlSchemeTypeValues;
+    suppressBrowserKeys: boolean;
+    fakeMouseWithTouches: boolean;
+}

package/lib/interfaces/mix-panel-events.d.ts

@@ -0,0 +1,8 @@
+export declare const MixPanelEvents: {
+    readonly pixelstreaming_end: "pixelstreaming_end";
+    readonly pixelstreaming_start: "pixelstreaming_start";
+    readonly render_request: "render_request";
+    readonly custom_click: "custom_click";
+    readonly route_change: "route_change";
+};
+export type MixPanelEventsValues = (typeof MixPanelEvents)[keyof typeof MixPanelEvents];

package/lib/interfaces/quality.interface.d.ts

@@ -0,0 +1 @@
+export type Quality = 'lime' | 'red' | 'orange';

package/lib/interfaces/stream-config.interface.d.ts

@@ -0,0 +1,5 @@
+export interface StreamConfig {
+    autoStart: boolean;
+    warnTimeout: number;
+    matchMakerUrls: string[];
+}

package/lib/interfaces/stream-resolution.interface.d.ts

@@ -0,0 +1,4 @@
+export interface StreamResolutionProps {
+    width: number | null;
+    height: number | null;
+}