@3dsource/angular-unreal-module 0.0.1

package/lib/interfaces/unreal-internal-signal-events.interface.d.ts

@@ -0,0 +1,83 @@
+import type { MetaBoxCommandPacket } from '@struct';
+import type { Quality } from './quality.interface';
+import type { DataFlowCheckResult } from '../helpers/DataFlowMonitor';
+export declare const UnrealInternalSignalEvents: {
+    readonly OnVideoInitialized: "OnVideoInitialized";
+    readonly RestAfkTimer: "RestAfkTimer";
+    readonly FreezeFrameStart: "FreezeFrameStart";
+    readonly UnrealCallback: "UnrealCallback";
+    readonly ClickableOverlay: "ClickableOverlay";
+    readonly VideoPlayClick: "VideoPlayClick";
+    readonly ShowPlayButton: "ShowPlayButton";
+    readonly ForceResizeViewport: "ForceResizeViewport";
+    readonly VideoAdaptedToContainer: "VideoAdaptedToContainer";
+    readonly TelemetryStart: "TelemetryStart";
+    readonly TelemetryStop: "TelemetryStop";
+    readonly TelemetryReset: "TelemetryReset";
+};
+export interface SignalDescriptor {
+    [UnrealInternalSignalEvents.UnrealCallback]: {
+        json: UnrealCallBackJson;
+    };
+    [UnrealInternalSignalEvents.ClickableOverlay]: {
+        message: string;
+        className: string;
+        isActivityDetected: boolean;
+        onOverlayClick: () => void;
+    } | void;
+    [UnrealInternalSignalEvents.VideoPlayClick]: {
+        text: string;
+    };
+    [UnrealInternalSignalEvents.ForceResizeViewport]: void;
+    [UnrealInternalSignalEvents.OnVideoInitialized]: HTMLVideoElement;
+    [UnrealInternalSignalEvents.VideoAdaptedToContainer]: void;
+    [UnrealInternalSignalEvents.ShowPlayButton]: {
+        text: string;
+        callback: () => boolean;
+    };
+    [UnrealInternalSignalEvents.RestAfkTimer]: void;
+    [UnrealInternalSignalEvents.FreezeFrameStart]: void;
+    [UnrealInternalSignalEvents.TelemetryReset]: void;
+    [UnrealInternalSignalEvents.TelemetryStart]: {
+        externalId: string;
+    };
+    [UnrealInternalSignalEvents.TelemetryStop]: {
+        externalId: string;
+        payload?: {
+            multi?: boolean;
+        };
+    };
+    [key: string]: any;
+}
+export type UnrealCallBackJson = MetaBoxCommandPacket | WrappedMetaBoxCommandPacket;
+export interface WrappedMetaBoxCommandPacket {
+    commandCallback: MetaBoxCommandPacket;
+}
+export interface IAggregatedStat {
+    quality: Quality;
+    aggregatedStats: InboundVideoStats;
+}
+export interface InboundVideoStats extends RTCInboundRtpStreamStats {
+    VideoEncoderQP: number;
+    runTime: number;
+    pixelRatio: number;
+    bytesReceivedStart: number;
+    framesDecodedStart: number;
+    timestampStart: number;
+    videoCodec: string;
+    avgBitrate: number;
+    avgFrameRate: number;
+    currentRoundTripTime: number;
+    codecs: Record<string, string>;
+    receiveToCompositeMs: number;
+    bitrate: number;
+    kalmanBitrate: number;
+    bitrateDrop: number;
+    dataFlowCheckResult: DataFlowCheckResult;
+    dataFlowBitrate: DataFlowCheckResult;
+}
+export interface AwsInstance {
+    wsUrl: string | null;
+    pollingUrl: string | null;
+    instanceName: string | null;
+}

package/lib/pipes/index.d.ts

@@ -0,0 +1 @@
+export * from './safe-html.pipe';

package/lib/pipes/safe-html.pipe.d.ts

@@ -0,0 +1,9 @@
+import type { PipeTransform } from '@angular/core';
+import type { SafeHtml, SafeResourceUrl, SafeScript, SafeStyle, SafeUrl } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export declare class SafePipe implements PipeTransform {
+    private sanitizer;
+    transform(value: any, type: string): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafePipe, "safe", true>;
+}

package/lib/services/afk.service.d.ts

@@ -0,0 +1,38 @@
+import { SubService } from './sub.service';
+import * as i0 from "@angular/core";
+export declare class AFKService extends SubService {
+    private enabled;
+    private closeTimeout;
+    private active;
+    private warnTimer;
+    private countdown;
+    private countdownTimer;
+    private selectWarnTimeout;
+    constructor();
+    initAfk(): void;
+    init(): void;
+    private hideOverlay;
+    /**
+     * Start a timer which when elapsed will warn the user they are inactive.
+     */
+    private startAfkWarningTimer;
+    /**
+     * If the user interacts, then reset the warning timer.
+     */
+    private resetAfkWarningTimer;
+    /**
+     * Update the count-down spans number for the overlay
+     * @param countdown the count down number to be inserted into the span for updating
+     */
+    private updateCountDown;
+    /**
+     * Update the text overlays inner text
+     * @param message the update text to be inserted into the overlay
+     */
+    private dispatchMessage;
+    private stop;
+    private reset;
+    private showAfkOverlay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AFKService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AFKService>;
+}

package/lib/services/aggregator.service.d.ts

@@ -0,0 +1,53 @@
+import type { Observable } from 'rxjs';
+import { Subject } from 'rxjs';
+import { FreezeFrameService } from './freeze-frame.service';
+import { SignallingService } from './signalling.service';
+import { Store } from '@ngrx/store';
+import { VideoService } from './video.service';
+import { VideoStreamStatusService } from './video-stream-status.service';
+import { WebRtcPlayerService } from './web-rtc-player.service';
+import * as i0 from "@angular/core";
+export declare class AggregatorService {
+    readonly store: Store<any>;
+    readonly selectStreamConfig: import("@angular/core").Signal<import("@3dsource/angular-unreal-module").StreamConfig | undefined>;
+    readonly videoService: VideoService;
+    readonly webrtcPlayer: WebRtcPlayerService;
+    readonly freezeFrame: FreezeFrameService;
+    readonly signallingSrv: SignallingService;
+    readonly stats: VideoStreamStatusService;
+    /**
+     * /Never called for now
+     * @
+     */
+    destroy$: Subject<void>;
+    responseEventListeners: Map<string, (data: unknown) => void>;
+    disconnect$: Observable<boolean>;
+    unlockViewport$: Observable<boolean>;
+    constructor();
+    init(): void;
+    private initialize;
+    /**
+     * @deprecated
+     * Hack for 3DS platform;
+     * TODO remove ASAP, use {@link BasicConfiguratorApiService.toMetaBoxHandlers.watchCallbacks}
+     * Add external responses to the list of responses
+     */
+    private addExternalResponses;
+    addResponseEventListener(name: string, listener: (data: unknown) => void): void;
+    showOnScreenKeyboard<T extends {
+        showOnScreenKeyboard: boolean;
+    }>(command: T): void;
+    exposeApi(): void;
+    removeLoadScreen(): void;
+    startListenCallbacks(): void;
+    private showMessageFromUnreal;
+    resetResponseList(): void;
+    listenSignaling(): void;
+    listenWebRTC(): void;
+    dataChannelMessageHandler(data: number[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AggregatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AggregatorService>;
+}
+export declare const filteredLogs: {
+    command: string;
+}[];

package/lib/services/command-telemetry.service.d.ts

@@ -0,0 +1,71 @@
+import * as i0 from "@angular/core";
+export declare class CommandTelemetryService {
+    private readonly appId;
+    private commandsSent;
+    private exileTimout;
+    private pollingTime;
+    private commandSequenceNumber;
+    /**
+     * The time the telemetry service was started.
+     * Initialized at a moment when connectToSignaling() was called.
+     * @private
+     */
+    private startTime;
+    private lastTime;
+    private uuid;
+    private viewId;
+    private readonly sessionId;
+    private readonly userId;
+    private payloads;
+    private readonly httpClient;
+    private readonly unrealInitialConfig;
+    constructor();
+    private get timeNow();
+    private get sessionTime();
+    private get canSkipSending();
+    decorate(funcToDecorate: IToBeDecorated): (data: any) => void;
+    private start;
+    private reset;
+    private trackStartCommand;
+    private trackStopCommand;
+    private pushStatToBuffer;
+    private trackTime;
+    private send;
+    /**
+     * Listens for Unreal Engine callbacks.
+     * Subscribes to the Unreal Engine event loop back and filters out events that do not have a tracking ID.
+     * When a callback with a tracking ID is received,
+     * it stops tracking the time for that command and filters out commands
+     * that have exceeded the timeout limit.
+     */
+    private listenCallbacks;
+    private pushData;
+    /**
+     * Removes commands that have exceeded the timeout limit.
+     * Iterates over all the commands sent and checks if the difference between the current time
+     * and the time the command was sent is greater than the timeout limit.
+     * If it is, the command is marked for deletion.
+     * After checking all commands, those marked for deletion are removed from the commands sent.
+     * This method is used to ensure that commands that are not responded to within a certain time frame
+     * do not remain in the commandsSent object indefinitely, which could lead to memory leaks over time.
+     */
+    private removeExileCommands;
+    /**
+     * Wraps the provided function with telemetry tracking.
+     * Generates a unique tracking ID and adds it to the data object.
+     * Pushes the command sent to the payloads with the tracking ID.
+     * Starts tracking the time for the command.
+     * Finally, calls the provided function with the modified data object.
+     *
+     * @param {IToBeDecorated} funcToDecorate - The function to be decorated with telemetry tracking.
+     * @param {any} data - The data object to be passed to the function. It will be augmented with a unique tracking ID.
+     */
+    private wrapper;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandTelemetryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommandTelemetryService>;
+}
+type IToBeDecorated = (data: any) => unknown;
+export declare function TelemetryStart(externalId: string): void;
+export declare function TelemetryStop(externalId: string, payload?: any): void;
+export declare function ResetTelemetry(): void;
+export {};

package/lib/services/console-extensions.service.d.ts

@@ -0,0 +1,10 @@
+import { SubService } from '../services/sub.service';
+import * as i0 from "@angular/core";
+export declare class ConsoleExtensionsService extends SubService {
+    private httpClient;
+    private isDevMode;
+    init(): void;
+    private unrealHelp;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConsoleExtensionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConsoleExtensionsService>;
+}

package/lib/services/dev-mode.service.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class DevModeService {
+    get isDevMode(): boolean;
+    setDevMode(value: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevModeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevModeService>;
+}

package/lib/services/freeze-frame.service.d.ts

@@ -0,0 +1,16 @@
+import { SubService } from './sub.service';
+import * as i0 from "@angular/core";
+export declare class FreezeFrameService extends SubService {
+    receiving: boolean;
+    private size;
+    private jpeg;
+    private freezeFrameOverlay;
+    init(): void;
+    setData(view: Uint8Array): void;
+    private dispatchInProgress;
+    start(view: Uint8Array): void;
+    invalidate(): void;
+    private showFreezeFrame;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FreezeFrameService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FreezeFrameService>;
+}

package/lib/services/image-capture.service.d.ts

@@ -0,0 +1,30 @@
+import type { FVector2DJson } from '@struct';
+import type { Observable } from 'rxjs';
+import type { ImageOutputValues } from '@3dsource/utils';
+import type { StreamResolutionProps } from '../interfaces/stream-resolution.interface';
+import * as i0 from "@angular/core";
+interface CameraEntity {
+    id: string;
+    label: string;
+    order: number;
+}
+export declare class ImageCaptureService {
+    #private;
+    getCurrentCamera(imageOutput: ImageOutputValues, lockViewPortWithVideoFreeze?: boolean, resolution?: FVector2DJson): Observable<string | null>;
+    captureCameras(imageOutput: ImageOutputValues, cameraList: CameraEntity[]): Observable<string[]>;
+    /**
+     * Get freeze-frame image from Unreal
+     * @param totalImages - total images in queue will be shown in progress bar
+     * @param index
+     */
+    getFreezeImage(index: number, totalImages: number): Observable<string | null>;
+    /**
+     * Get freeze-frame image from Unreal;
+     * No progress bar will be shown
+     */
+    getFreezeImage(): Observable<string | null>;
+    getVideoSnapshot(imageOutput?: ImageOutputValues, resolution?: StreamResolutionProps): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageCaptureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImageCaptureService>;
+}
+export {};

package/lib/services/index.d.ts

@@ -0,0 +1,17 @@
+export * from './afk.service';
+export * from './aggregator.service';
+export * from './command-telemetry.service';
+export * from './console-extensions.service';
+export * from './dev-mode.service';
+export * from './freeze-frame.service';
+export * from './image-capture.service';
+export * from './input.service';
+export * from './mix-panel.service';
+export * from './regions-ping.service';
+export * from './signalling.service';
+export * from './stream-status-telemetry.service';
+export * from './sub.service';
+export * from './unreal-communicator.service';
+export * from './video.service';
+export * from './video-stream-status.service';
+export * from './web-rtc-player.service';

package/lib/services/input.service.d.ts

@@ -0,0 +1,53 @@
+import type { IKeyCode } from '@3dsource/utils';
+import { SubService } from '../services/sub.service';
+export declare class InputService extends SubService {
+    private commandsSender;
+    private isDevMode;
+    readonly defaultKeys: (17 | 37 | 38 | 39 | 40 | 46 | 65 | 68 | 83 | 87 | 107 | 109 | 187 | 189)[];
+    private availableKeys;
+    private options;
+    private reInit$;
+    private deactivatedVideoTrigger$;
+    private normalizeAndQuantizeUnsigned;
+    private unQuantizeAndDenormalizeUnsigned;
+    private normalizeAndQuantizeSigned;
+    video: HTMLVideoElement;
+    videoBoundingRect: DOMRect;
+    fingerIds: Map<any, any>;
+    maxByteValue: number;
+    fingers: number[];
+    private offsetParams;
+    constructor();
+    useKeyboardKeys(keys: IKeyCode[]): void;
+    private setup;
+    /**
+     * We use `object-fit: cover` on the video element. Since the video can have
+     * a different aspect ratio from its container (and potentially be larger),
+     * we need to calculate offsets and scale factors to map container (e.g., mouse)
+     * coordinates back to the actual video coordinates.
+     *
+     * @param videoElement The video element whose scaling and positioning we need
+     * @returns Object containing offset and scale info for coordinate normalization
+     * @private
+     */
+    private getObjectFitOffset;
+    private setupNormalizeAndQuantize;
+    private sendInputData;
+    private registerInputs;
+    private getTouchPositionWithOffset;
+    private getMousePositionWithOffset;
+    private registerTouchEvents;
+    focusWindow(): void;
+    emitMouseMove(x: number, y: number, deltaX: number, deltaY: number): void;
+    emitMouseDown(button: number, x: number, y: number): void;
+    emitMouseUp(button: number, x: number, y: number): void;
+    emitMouseWheel(delta: number, x: number, y: number): void;
+    private releaseMouseButtons;
+    private pressMouseButtons;
+    private registerHoveringMouseEvents;
+    private registerMouseEnterAndLeaveEvents;
+    private isKeyCodeBrowserKey;
+    private getKeyCode;
+    private registerKeyboardEvents;
+    private startListenKeys;
+}

package/lib/services/mix-panel.service.d.ts

@@ -0,0 +1,11 @@
+import type { MixPanelEventsValues } from '../interfaces/mix-panel-events';
+import type { Dict } from 'mixpanel-browser';
+import * as i0 from "@angular/core";
+export declare class MixPanelService {
+    #private;
+    init(): void;
+    trackMetabox(event: MixPanelEventsValues | string, data?: Dict): void;
+    trackStream(event: MixPanelEventsValues | string, data?: Dict): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MixPanelService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MixPanelService>;
+}

package/lib/services/regions-ping.service.d.ts

@@ -0,0 +1,34 @@
+import type { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class RegionsPingService {
+    private httpClient;
+    private unrealInitialConfig;
+    config: {
+        ping_count: number;
+        ping_timeout: number;
+        max_parallel_requests: number;
+        bust_cache: boolean;
+    };
+    getFastest(regionListUrl?: string): Observable<string | undefined>;
+    getPingResult(providers: ProvidersData): Observable<PingResult | null>;
+    getProviders(regionList?: string): Observable<ProvidersData>;
+    private startPinging;
+    private checkLatency;
+    private fetchWithTimeout;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegionsPingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RegionsPingService>;
+}
+interface ProvidersData {
+    timeout?: number;
+    regions: Region[];
+}
+interface Region {
+    region_code: string;
+    url: string;
+    timeout?: number;
+}
+interface PingResult {
+    region_code: string | undefined;
+    result: number[];
+}
+export {};

package/lib/services/signalling.service.d.ts

@@ -0,0 +1,41 @@
+import { Subject } from 'rxjs';
+import { SubService } from './sub.service';
+import type { CloseReason } from '../interfaces/CloseReason';
+import type { ConfigMessage, MessageBase } from '../interfaces/SignalingMessage';
+import * as i0 from "@angular/core";
+export declare class SignallingService extends SubService {
+    private readonly httpClient;
+    private readonly regionsPingService;
+    onConfig$: Subject<ConfigMessage>;
+    onWebRtcIce$: Subject<RTCIceCandidate>;
+    onWebRtcAnswer$: Subject<RTCSessionDescriptionInit | null>;
+    private ws;
+    protected wsTimeoutHandler: ReturnType<typeof setTimeout>;
+    private wsMsgHandlers;
+    protected correlationId: string;
+    protected environmentId: string;
+    private establishingConnection;
+    private isCirrusConnected;
+    private establishingConnectionDrop$;
+    constructor();
+    protected initEstablishingConnection(): void;
+    private stopEstablishingConnection;
+    private connectToSignaling;
+    private connectToSignalingAfterPing;
+    showStatusMessage(message: string | null): void;
+    /**
+     * Close the connection with the signaling server
+     * @param data
+     */
+    close(data: CloseReason | void): void;
+    send(data: string | object): void;
+    protected watchTimeoutOrErrorAndReconnectLater(): void;
+    protected stopRetryTimer(): void;
+    private initWebSocket;
+    private httpUrlToWs;
+    private clearWs;
+    protected handleMessage(msg: MessageBase): void;
+    private setHandlersFromStream;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignallingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SignallingService>;
+}

package/lib/services/stream-status-telemetry.service.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class StreamStatusTelemetryService {
+    #private;
+    constructor();
+    private mapEventData;
+    private initTelemetry;
+    private trackEventToMixPanel;
+    init(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StreamStatusTelemetryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StreamStatusTelemetryService>;
+}

package/lib/services/sub.service.d.ts

@@ -0,0 +1,5 @@
+import { Store } from '@ngrx/store';
+export declare class SubService {
+    store: Store<any>;
+    disconnect$: import("rxjs").Observable<false>;
+}

package/lib/services/unreal-communicator.service.d.ts

@@ -0,0 +1,38 @@
+import type { MetaBoxCommandPacket } from '@struct';
+import * as i0 from "@angular/core";
+export declare class UnrealCommunicatorService {
+    private telemetry;
+    private afkService;
+    private freezeFrame;
+    private webrtcPlayer;
+    private videoService;
+    private consoleExtensions;
+    private store;
+    private destroy$;
+    private cirrusConnected;
+    constructor();
+    destroy(): void;
+    sendCommandToUnreal(data: MetaBoxCommandPacket): void;
+    emitUIInteraction(descriptor: MetaBoxCommandPacket): void;
+    /**
+       A build-in command can be sent to the UE4 client. The commands are defined by a
+       JSON descriptor and will be executed automatically.
+       The currently supported commands are:
+  
+       1. A command to run any console command:
+       "{ ConsoleCommand: <string> }"
+  
+       2. A command to change the resolution to the given width and height.
+       "{ Resolution.Width: <value>, Resolution.Height: <value> } }"
+       */
+    emitCommand(descriptor: MetaBoxCommandPacket): void;
+    sendInputData(data: ArrayBuffer): void;
+    private emitDescriptor;
+    private requestInitialSettings;
+    private requestQualityControl;
+    private listenVideo;
+    private prepareScreen;
+    private showPlayOverlay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnrealCommunicatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UnrealCommunicatorService>;
+}

package/lib/services/video-stream-status.service.d.ts

@@ -0,0 +1,24 @@
+import type { IAggregatedStat } from '../interfaces/unreal-internal-signal-events.interface';
+import type { Observable } from 'rxjs';
+import { LatencyTimings } from '../helpers/LatencyTimings';
+import { SubService } from './sub.service';
+import * as i0 from "@angular/core";
+export declare class VideoStreamStatusService extends SubService {
+    readonly latencyTestTimings: LatencyTimings;
+    private readonly webrtcPlayer;
+    private aggregatedStats;
+    private VideoEncoderQP;
+    private kalmanFilter1D;
+    readonly videoStats$: Observable<IAggregatedStat>;
+    constructor();
+    /**
+     * Aggregate video stats and emit it as videoStats$
+     */
+    private aggregateStats;
+    setEncoder(data: any): void;
+    private getStats;
+    private generateAggregatedStatsFunction;
+    private onAggregatedStats;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VideoStreamStatusService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VideoStreamStatusService>;
+}

package/lib/services/video.service.d.ts

@@ -0,0 +1,17 @@
+import { SubService } from './sub.service';
+import * as i0 from "@angular/core";
+export declare class VideoService extends SubService {
+    video: HTMLVideoElement | null;
+    audio: HTMLAudioElement | null;
+    container: HTMLDivElement | null;
+    create(): void;
+    private destroy;
+    private createWebRtcVideo;
+    attachVideoStream(stream: MediaStream): void;
+    attachAudioStream(stream: MediaStream): void;
+    private createWebRtcAudio;
+    private playAudio;
+    play(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VideoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VideoService>;
+}

package/lib/services/web-rtc-player.service.d.ts

@@ -0,0 +1,44 @@
+import { Subject } from 'rxjs';
+import { SubService } from './sub.service';
+import type { ConfigMessage } from '../interfaces/SignalingMessage';
+import * as i0 from "@angular/core";
+export declare class WebRtcPlayerService extends SubService {
+    pcClient: RTCPeerConnection | null;
+    onAudioTrack$: Subject<MediaStream>;
+    onVideoTrack$: Subject<MediaStream>;
+    onDataChannelMessage$: Subject<number[]>;
+    onWebRtcCandidate$: Subject<RTCIceCandidate>;
+    onWebRtcOffer$: Subject<RTCSessionDescriptionInit>;
+    private cfg;
+    private useMic;
+    private forceTURN;
+    private preferSFU;
+    private autoPlayAudio;
+    private startVideoMuted;
+    private forceMonoAudio;
+    private forceMaxBundle;
+    private dcClient;
+    private sdpConstraints;
+    private dataChannelOptions;
+    private webRtcErrorTimeout;
+    createWebRtcOffer(): Promise<void>;
+    private dispatchWebRtcError;
+    private createOffer;
+    createDataChannel(pc: RTCPeerConnection, label: string, options: RTCDataChannelInit): RTCDataChannel | null;
+    private setupTransceiversAsync;
+    private setupDataChannelCallbacks;
+    private onDataChannelConnected;
+    private handleCreateOffer;
+    receiveAnswer(answer: RTCSessionDescriptionInit): void;
+    handleCandidateFromServer(iceCandidate: RTCIceCandidate): void;
+    mungeSDP(offer: RTCSessionDescriptionInit): void;
+    /**
+     * Closes existing PeerConnection
+     */
+    closePC(): void;
+    canSend(): boolean | null;
+    send(data: ArrayBuffer): void;
+    setConfig(parOptions?: ConfigMessage): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebRtcPlayerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebRtcPlayerService>;
+}

package/lib/store/index.d.ts

@@ -0,0 +1,5 @@
+export * from './unreal.actions';
+export * from './unreal.effects';
+export * from './unreal.feature';
+export * from './unreal.reducer';
+export * from './unreal.selectors';