uneeq-js 3.0.16-preview.99 → 3.2.0

package/dist/lib/audio-speak.d.ts

@@ -0,0 +1,7 @@
+import type { Session } from "../session";
+/**
+ * Sends audio data over the session's signaling channel.
+ * @param session The session instance (must have audioStreamId and signaling)
+ * @param audio The audio data (base64 string, Uint8Array, or Blob)
+ */
+export declare function speakAudioSend(session: Session | undefined, audio: string | Uint8Array | Blob): Promise<void>;

package/dist/lib/audio-speak.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/logger.d.ts

@@ -1,6 +1,7 @@
-import pino from 'pino';
+import pino from "pino";
 export default class Logger {
     private static instance;
+    private static formatLogMessage;
     static fatal(log: string, ...args: unknown[]): void;
     static error(log: string, ...args: unknown[]): void;
     static warn(log: string, ...args: unknown[]): void;
@@ -9,4 +10,5 @@ export default class Logger {
     static trace(log: string, ...args: unknown[]): void;
     static getLogger(): pino.Logger;
     static setLevel(level: string): void;
+    static serialiseError(err: unknown): string;
 }

package/dist/node_modules_ws_browser_js.index.js

@@ -0,0 +1,22 @@
+"use strict";
+/*
+ * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
+ * This devtool is neither made for production nor for readable output files.
+ * It uses "eval()" calls to create a separate source file in the browser devtools.
+ * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
+ * or disable the default devtool with "devtool: false".
+ * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
+ */
+(Object(typeof self !== "undefined" ? self : this)["webpackChunkUneeq"] = Object(typeof self !== "undefined" ? self : this)["webpackChunkUneeq"] || []).push([["node_modules_ws_browser_js"],{
+
+/***/ "./node_modules/ws/browser.js":
+/*!************************************!*\
+  !*** ./node_modules/ws/browser.js ***!
+  \************************************/
+/***/ ((module) => {
+
+eval("\n\nmodule.exports = function () {\n  throw new Error(\n    'ws does not work in the browser. Browser clients must use the native ' +\n      'WebSocket object'\n  );\n};\n\n\n//# sourceURL=webpack://Uneeq/./node_modules/ws/browser.js?");
+
+/***/ })
+
+}]);

package/dist/session-transfer-manager.d.ts

@@ -1,10 +1,10 @@
 import { type Session } from "./session";
 import { type Signaling } from "./signaling";
 export declare class SessionTransferManager {
-    session: Session;
+    private readonly session;
     isTransferSessionInProgress: boolean;
     constructor(session: Session);
     private addTransferSessionListener;
-    private transferSession;
+    transferSession(): void;
     switchLiveVideo(videoContainer: HTMLDivElement, newSignaling: Signaling): void;
 }

package/dist/session.d.ts

@@ -1,46 +1,54 @@
 import { Signaling } from "./signaling";
 import { type UneeqConfig } from "./types/UneeqConfig";
 import { type UneeqMessage } from "./types/UneeqMessages";
-import { SpeechRecognition } from "./speech-recognition";
+import { type SpeechRecognitionInterface } from "./types/SpeechRecognitionInterface";
 import { Subject } from "rxjs";
 import { type DataChannelMessage } from "./webrtc-data-channel/DataChannelMessage";
 import { type PromptMetadata } from "./types/PromptMetadata";
 import { type CameraAnchorDistance, type CameraAnchorHorizontal } from "./webrtc-data-channel/messages/CameraAnchor";
+import { SessionTransferManager } from "./session-transfer-manager";
+export declare const VIDEO_REVEAL_DELAY_MS = 750;
 export declare class Session {
     readonly config: UneeqConfig;
     id: string;
     signaling?: Signaling;
     messages: Subject<UneeqMessage>;
-    speechRec?: SpeechRecognition;
+    speechRec?: SpeechRecognitionInterface;
     promptMetadata: PromptMetadata;
+    audioStreamId?: number;
+    readonly sessionTransferManager: SessionTransferManager;
     private jwt;
     private welcomeRequested;
-    private readonly sessionTransferManager;
+    private resolutionLogged;
     constructor(config: UneeqConfig);
     updatePromptMetadata(metadata: object): void;
     setEnableMicrophone(enable: boolean): void;
     setCameraAnchorDistance(position: CameraAnchorDistance, duration?: number, signaling?: Signaling | undefined): void;
     setCameraAnchorHorizontal(position: CameraAnchorHorizontal, duration?: number, signaling?: Signaling | undefined): void;
     createSession(): void;
-    createSignaling(videoElement?: HTMLDivElement, isStreamTransferring?: boolean): Signaling;
+    createSignaling(videoElement?: HTMLDivElement): Signaling;
     private signalingEventHandler;
     private handleSessionReady;
     private initSpeechRecognition;
+    private createGoogleSTT;
+    private createDeepgramSTT;
     protected getSpeechOptions(jwt: string): {
         apiUrl: string;
+        assetBasePath: string | undefined;
+        enableInterrupt: boolean | undefined;
+        enableVad: boolean | undefined;
         jwtToken: string;
         hintPhrases: string | undefined;
         hintPhrasesBoost: number | undefined;
         locales: string | undefined;
         messages: Subject<UneeqMessage>;
-        sessionId: string;
-        assetBasePath: string | undefined;
         promptMetadata: PromptMetadata;
-        enableVad: boolean | undefined;
-        enableInterrupt: boolean | undefined;
+        sessionId: string;
         sendMessage: (msg: DataChannelMessage) => void;
     };
     private initMetadata;
     private handleDataChannelMessage;
+    private handleChannelMessageError;
     private sendWelcomePrompt;
+    private listenForTabClosure;
 }

package/dist/signaling.d.ts

@@ -1,27 +1,31 @@
-import { ReplaySubject, type Subject } from 'rxjs';
+import { ReplaySubject } from 'rxjs';
 import { PixelStreaming } from '@epicgames-ps/lib-pixelstreamingfrontend-ue5.4';
 import { type SignalingEvent } from './types/SignalingEvents';
 import { type DataChannelMessage } from './webrtc-data-channel/DataChannelMessage';
-import { type UneeqMessage } from './types/UneeqMessages';
-import { SessionEndedReason } from './types/SessionEnded';
+import { type Session } from './session';
 export declare class Signaling {
+    private readonly session;
     private readonly connectionUrl;
     videoContainerElement?: HTMLDivElement | undefined;
-    private readonly clientMessages?;
-    isStreamTransferring: boolean;
-    forceTURN: boolean;
     stream?: PixelStreaming;
     messages: ReplaySubject<SignalingEvent>;
-    videoElem?: HTMLVideoElement;
+    videoElement?: HTMLVideoElement;
     audioElement?: HTMLAudioElement;
     videoInitialized: boolean;
     dataChannelOpen: boolean;
+    sceneReady: boolean;
     private readonly maxReconnectAttempts;
     private reconnectionAttempts;
     private allowReconnection;
     private isReconnectInProgress;
-    private readonly reconnectionUiContainer;
-    constructor(connectionUrl: string, videoContainerElement?: HTMLDivElement | undefined, clientMessages?: Subject<UneeqMessage> | undefined, isStreamTransferring?: boolean, forceTURN?: boolean);
+    private audioStatsInternal?;
+    private freezeCount;
+    private lastDecodedFrames;
+    private lastCheckTime;
+    private audioStatsAnalyzer?;
+    private readonly config;
+    private readonly clientMessages;
+    constructor(session: Session, connectionUrl: string, videoContainerElement?: HTMLDivElement | undefined);
     init(): void;
     private addStreamHandlers;
     private addWebSocketHandlers;
@@ -29,19 +33,32 @@ export declare class Signaling {
     private handleVideoInitialized;
     playAudioElement(): void;
     pauseAudioElement(): void;
+    /**
+     * Handle the case where the audio element is not found.
+     * Log an error and send a message to the client.
+     *
+     * TODO: In future make this a fatal error that will end the session, when we give users more information about errors
+     */
+    private handleMissingAudioElement;
+    startAudioStatsMonitor(intervalMs?: number): void;
+    stopAudioStatsMonitor(): void;
     private handleDataChannelOpen;
     private handleWebRtcFailed;
     private handleWebRtcDisconnected;
     private handleWebRtcStats;
+    private checkForFreeze;
     private reconnectIfSafe;
     private handleDataChannelMessage;
     private handleIndexInQueueMessage;
     private handleRendererTakenMessage;
     private handleRendererGoneEvent;
-    private createReconnectionUi;
-    hideReconnectionUi(): void;
-    showReconnectionUi(): void;
+    private handleSwitchRendererRequestEvent;
     socketSend(msg: any): void;
     dataSend(data: DataChannelMessage): void;
-    endSession(reason?: SessionEndedReason, sendMessageToClient?: boolean): void;
+    dataSendBinary(data: Uint8Array): void;
+    private uint8ToBase64;
+    endSession(reason?: string, sendMessageToClient?: boolean): void;
+    streamDisconnect(): void;
+    startSoftSwitch(): void;
+    stopSoftSwitch(): void;
 }

package/dist/speech-recognition.d.ts

@@ -1,3 +1,4 @@
+import { MicVAD } from './lib/vad/real-time-vad';
 import { type SpeechRecognitionOptions } from './types/SpeechHandlerOptions';
 import { type PromptMetadata } from './types/PromptMetadata';
 export declare class SpeechRecognition {
@@ -5,17 +6,17 @@ export declare class SpeechRecognition {
     private ws;
     private mediaRecorder;
     private readonly speechBuffer;
-    private micVad;
     private recordingLive;
     private headerBlob;
     private scriptsLoadedPromise;
-    private digitalHumanSpeaking;
-    private stream?;
     private reconnectWs;
     private wsReconnectMessageQueue;
     private storedTranscription?;
     private awaitingFinalTranscript;
-    private interruptionBlocked;
+    stream?: MediaStream;
+    micVad: MicVAD;
+    digitalHumanSpeaking: boolean;
+    interruptionBlocked: boolean;
     constructor(options: SpeechRecognitionOptions);
     startRecognition(): void;
     stopRecognition(): void;
@@ -50,6 +51,7 @@ export declare class SpeechRecognition {
     private handlePttTranscriptionResult;
     private handleVadTranscriptionResult;
     private sendChatPrompt;
+    private sendInterimTranscription;
     private dataChannelMsgSend;
     private clientMsgSend;
 }

package/dist/speech-recognition.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/elevenlabs-stt.d.ts

@@ -0,0 +1,57 @@
+import { type Subject } from 'rxjs';
+import { type UneeqMessage } from './types/UneeqMessages';
+import { type DataChannelMessage } from './webrtc-data-channel/DataChannelMessage';
+import { type PromptMetadata } from './types/PromptMetadata';
+export interface ElevenLabsSTTOptions {
+    tokenEndpoint: string;
+    jwtToken: string;
+    sessionId: string;
+    modelId?: string;
+    languageCode?: string;
+    audioFormat?: 'pcm_8000' | 'pcm_16000' | 'pcm_22050' | 'pcm_24000' | 'pcm_44100' | 'pcm_48000' | 'ulaw_8000';
+    vadSilenceThresholdSecs?: number;
+    vadThreshold?: number;
+    minSpeechDurationMs?: number;
+    minSilenceDurationMs?: number;
+    echoCancellation?: boolean;
+    noiseSuppression?: boolean;
+    autoGainControl?: boolean;
+    telemetryEnabled?: boolean;
+    promptMetadata: PromptMetadata;
+    messages: Subject<UneeqMessage>;
+    sendMessage: (msg: DataChannelMessage) => void;
+    enableInterrupt?: boolean;
+}
+export declare class ElevenLabsSTT {
+    private readonly options;
+    private scribe;
+    private isConnected;
+    private isMuted;
+    private isReconnecting;
+    private shouldReconnect;
+    private digitalHumanSpeaking;
+    private interruptionBlocked;
+    private currentTranscript;
+    private isUserCurrentlySpeaking;
+    constructor(options: ElevenLabsSTTOptions);
+    startRecognition(): Promise<void>;
+    stopRecognition(): Promise<void>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    setChatMetadata(chatMetadata: PromptMetadata): void;
+    pauseVadIfInterruptNotAllowed(): void;
+    private connect;
+    private disconnect;
+    private getToken;
+    private setupEventHandlers;
+    private handleAppMessages;
+    private handlePartialTranscript;
+    private handleCommittedTranscript;
+    private handleConnectionOpen;
+    private handleConnectionClose;
+    private handleError;
+    private sendChatPrompt;
+    private handleSpeakingEnd;
+    private dataChannelMsgSend;
+    private clientMsgSend;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export type { UneeqConfig } from './types/UneeqConfig';
+export { SpeechRecognitionProvider } from './types/UneeqConfig';
+export * from './types/UneeqMessages';
+export { Uneeq } from './uneeq';
+export type { SpeechTranscriptionResult } from './types/SpeechTranscriptionResult';
+export { CameraAnchorDistance, CameraAnchorHorizontal } from './webrtc-data-channel/messages/CameraAnchor';
+export { LogLevel } from './types/LogLevel';
+export type { ElevenLabsSTTOptions } from './elevenlabs-stt';

package/dist/src/lib/audio-speak.d.ts

@@ -0,0 +1,7 @@
+import type { Session } from "../session";
+/**
+ * Sends audio data over the session's signaling channel.
+ * @param session The session instance (must have audioStreamId and signaling)
+ * @param audio The audio data (base64 string, Uint8Array, or Blob)
+ */
+export declare function speakAudioSend(session: Session | undefined, audio: string | Uint8Array | Blob): Promise<void>;

package/dist/src/lib/audio-speak.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/session-transfer-manager.d.ts

@@ -0,0 +1,10 @@
+import { type Session } from "./session";
+import { type Signaling } from "./signaling";
+export declare class SessionTransferManager {
+    private readonly session;
+    isTransferSessionInProgress: boolean;
+    constructor(session: Session);
+    private addTransferSessionListener;
+    transferSession(): void;
+    switchLiveVideo(videoContainer: HTMLDivElement, newSignaling: Signaling): void;
+}

package/dist/src/session-transfer-manager.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/session.d.ts

@@ -0,0 +1,55 @@
+import { Signaling } from "./signaling";
+import { type UneeqConfig } from "./types/UneeqConfig";
+import { type UneeqMessage } from "./types/UneeqMessages";
+import { SpeechRecognition } from "./speech-recognition";
+import { ElevenLabsSTT } from "./elevenlabs-stt";
+import { Subject } from "rxjs";
+import { type DataChannelMessage } from "./webrtc-data-channel/DataChannelMessage";
+import { type PromptMetadata } from "./types/PromptMetadata";
+import { type CameraAnchorDistance, type CameraAnchorHorizontal } from "./webrtc-data-channel/messages/CameraAnchor";
+import { SessionTransferManager } from "./session-transfer-manager";
+export declare const VIDEO_REVEAL_DELAY_MS = 750;
+export declare class Session {
+    readonly config: UneeqConfig;
+    id: string;
+    signaling?: Signaling;
+    messages: Subject<UneeqMessage>;
+    speechRec?: SpeechRecognition | ElevenLabsSTT;
+    promptMetadata: PromptMetadata;
+    audioStreamId?: number;
+    readonly sessionTransferManager: SessionTransferManager;
+    private jwt;
+    private welcomeRequested;
+    private resolutionLogged;
+    constructor(config: UneeqConfig);
+    updatePromptMetadata(metadata: object): void;
+    setEnableMicrophone(enable: boolean): void;
+    setCameraAnchorDistance(position: CameraAnchorDistance, duration?: number, signaling?: Signaling | undefined): void;
+    setCameraAnchorHorizontal(position: CameraAnchorHorizontal, duration?: number, signaling?: Signaling | undefined): void;
+    createSession(): void;
+    createSignaling(videoElement?: HTMLDivElement): Signaling;
+    private signalingEventHandler;
+    private handleSessionReady;
+    private initSpeechRecognition;
+    private createGoogleSTT;
+    private createElevenLabsSTT;
+    protected getSpeechOptions(jwt: string): {
+        apiUrl: string;
+        assetBasePath: string | undefined;
+        enableInterrupt: boolean | undefined;
+        enableVad: boolean | undefined;
+        jwtToken: string;
+        hintPhrases: string | undefined;
+        hintPhrasesBoost: number | undefined;
+        locales: string | undefined;
+        messages: Subject<UneeqMessage>;
+        promptMetadata: PromptMetadata;
+        sessionId: string;
+        sendMessage: (msg: DataChannelMessage) => void;
+    };
+    private initMetadata;
+    private handleDataChannelMessage;
+    private handleChannelMessageError;
+    private sendWelcomePrompt;
+    private listenForTabClosure;
+}

package/dist/src/session.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/signaling.d.ts

@@ -0,0 +1,64 @@
+import { ReplaySubject } from 'rxjs';
+import { PixelStreaming } from '@epicgames-ps/lib-pixelstreamingfrontend-ue5.4';
+import { type SignalingEvent } from './types/SignalingEvents';
+import { type DataChannelMessage } from './webrtc-data-channel/DataChannelMessage';
+import { type Session } from './session';
+export declare class Signaling {
+    private readonly session;
+    private readonly connectionUrl;
+    videoContainerElement?: HTMLDivElement | undefined;
+    stream?: PixelStreaming;
+    messages: ReplaySubject<SignalingEvent>;
+    videoElement?: HTMLVideoElement;
+    audioElement?: HTMLAudioElement;
+    videoInitialized: boolean;
+    dataChannelOpen: boolean;
+    sceneReady: boolean;
+    private readonly maxReconnectAttempts;
+    private reconnectionAttempts;
+    private allowReconnection;
+    private isReconnectInProgress;
+    private audioStatsInternal?;
+    private freezeCount;
+    private lastDecodedFrames;
+    private lastCheckTime;
+    private audioStatsAnalyzer?;
+    private readonly config;
+    private readonly clientMessages;
+    constructor(session: Session, connectionUrl: string, videoContainerElement?: HTMLDivElement | undefined);
+    init(): void;
+    private addStreamHandlers;
+    private addWebSocketHandlers;
+    private handleWebSocketError;
+    private handleVideoInitialized;
+    playAudioElement(): void;
+    pauseAudioElement(): void;
+    /**
+     * Handle the case where the audio element is not found.
+     * Log an error and send a message to the client.
+     *
+     * TODO: In future make this a fatal error that will end the session, when we give users more information about errors
+     */
+    private handleMissingAudioElement;
+    startAudioStatsMonitor(intervalMs?: number): void;
+    stopAudioStatsMonitor(): void;
+    private handleDataChannelOpen;
+    private handleWebRtcFailed;
+    private handleWebRtcDisconnected;
+    private handleWebRtcStats;
+    private checkForFreeze;
+    private reconnectIfSafe;
+    private handleDataChannelMessage;
+    private handleIndexInQueueMessage;
+    private handleRendererTakenMessage;
+    private handleRendererGoneEvent;
+    private handleSwitchRendererRequestEvent;
+    socketSend(msg: any): void;
+    dataSend(data: DataChannelMessage): void;
+    dataSendBinary(data: Uint8Array): void;
+    private uint8ToBase64;
+    endSession(reason?: string, sendMessageToClient?: boolean): void;
+    streamDisconnect(): void;
+    startSoftSwitch(): void;
+    stopSoftSwitch(): void;
+}

package/dist/src/signaling.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/types/UneeqConfig.d.ts

@@ -0,0 +1,138 @@
+import { type CameraAnchorDistance, type CameraAnchorHorizontal } from "../webrtc-data-channel/messages/CameraAnchor";
+import { type LogLevel } from "./LogLevel";
+import { type UneeqMessage } from "./UneeqMessages";
+export declare enum SpeechRecognitionProvider {
+    Google = "google",
+    ElevenLabs = "elevenLabs"
+}
+export interface UneeqConfig {
+    sessionId: string;
+    sessionToken: string;
+    connectionUrl: string;
+    personaId: string;
+    videoContainerElement?: HTMLDivElement;
+    logLevel?: LogLevel | string;
+    enableMicrophone?: boolean;
+    assetBasePath?: string;
+    welcomePrompt?: string;
+    backgroundUrl?: string;
+    enableVad?: boolean;
+    enableInterruptBySpeech?: boolean;
+    cameraAnchorDistance: CameraAnchorDistance;
+    cameraAnchorHorizontal: CameraAnchorHorizontal;
+    forceTURN?: boolean;
+    /**
+     * This option specifies up to four locales that the Digital Human should understand a person speaking (speech recognition)
+     * The locales are specified in the BCP-47 format e.g "en-US".
+     * The first locale is considered the primary locale.
+     * Locales should be separated with a colon e.g "en-US:en-GB:en-AU".
+     */
+    speechRecognitionLocales?: string;
+    /**
+     * Speech Recognition Hint Phrases
+     * A comma separated list of phrases the speech recognition system should expect.
+     */
+    speechRecognitionHintPhrases?: string;
+    /**
+     * Speech Recognition Hint Phrases Boost
+     * An integer number between 0 and 20 that can be used to boost the hint phrases likely hood to match.
+     */
+    speechRecognitionHintPhrasesBoost?: number;
+    /**
+     * Speech recognition provider selection.
+     * @default SpeechRecognitionProvider.Google
+     *
+     * Supported values:
+     * - 'google': Uses UneeQ's speech-recognition-service (existing implementation)
+     * - 'elevenLabs': Uses ElevenLabs Scribe 2 real-time STT
+     *
+     * Any other value will log a warning and default to 'google'.
+     */
+    speechRecognitionProvider?: SpeechRecognitionProvider | 'google' | 'elevenLabs';
+    /**
+     * Configuration for ElevenLabs STT provider.
+     * These options only apply when using ElevenLabs - they are ignored when using Google STT provider.
+     */
+    elevenLabsConfig?: {
+        /**
+         * Backend endpoint that provides ElevenLabs tokens.
+         * If not specified, will be auto-constructed as: ${connectionUrl}/elevenlabs/token
+         * @default `${connectionUrl}/elevenlabs/token`
+         */
+        tokenEndpoint?: string;
+        /**
+         * ElevenLabs model ID to use for transcription.
+         * @default 'scribe_v2_realtime'
+         */
+        modelId?: string;
+        /**
+         * Language code in ISO-639-1 or ISO-639-3 format (e.g., 'en', 'es', 'fr').
+         * If not specified, ElevenLabs will auto-detect the language.
+         * @default undefined (auto-detect)
+         */
+        languageCode?: string;
+        /**
+         * Audio format for streaming to ElevenLabs.
+         * @default 'pcm_16000'
+         */
+        audioFormat?: 'pcm_8000' | 'pcm_16000' | 'pcm_22050' | 'pcm_24000' | 'pcm_44100' | 'pcm_48000' | 'ulaw_8000';
+        /**
+         * VAD (Voice Activity Detection) configuration.
+         */
+        vad?: {
+            /**
+             * Seconds of silence before VAD commits the transcript.
+             * Range: 0.3 - 3.0 seconds
+             * @default 1.5
+             */
+            silenceThresholdSecs?: number;
+            /**
+             * VAD sensitivity threshold for speech detection.
+             * Range: 0.1 - 0.9
+             * @default 0.4
+             */
+            threshold?: number;
+            /**
+             * Minimum speech duration in milliseconds to trigger detection.
+             * Range: 50 - 2000 ms
+             * @default 100
+             */
+            minSpeechDurationMs?: number;
+            /**
+             * Minimum silence duration in milliseconds for segment boundary.
+             * Range: 50 - 2000 ms
+             * @default 100
+             */
+            minSilenceDurationMs?: number;
+        };
+        /**
+         * Microphone audio processing configuration.
+         */
+        microphone?: {
+            /**
+             * Enable echo cancellation (removes feedback from speakers).
+             * @default true
+             */
+            echoCancellation?: boolean;
+            /**
+             * Enable noise suppression (reduces background noise).
+             * @default true
+             */
+            noiseSuppression?: boolean;
+            /**
+             * Enable automatic gain control (normalizes volume levels).
+             * @default true
+             */
+            autoGainControl?: boolean;
+        };
+        /**
+         * Enable telemetry data collection by ElevenLabs.
+         * @default false
+         */
+        telemetryEnabled?: boolean;
+    };
+    customMetadata?: object;
+    messageHandler?: (msg: UneeqMessage) => void;
+    webRtcStatsEmitMessages?: boolean;
+    webRtcStatsLogMessages?: boolean;
+}

package/dist/src/uneeq.d.ts

@@ -0,0 +1,26 @@
+import { type UneeqConfig } from "./types/UneeqConfig";
+import type { CameraAnchorDistance, CameraAnchorHorizontal } from "./webrtc-data-channel/messages/CameraAnchor";
+export declare class Uneeq {
+    private readonly config;
+    private session?;
+    constructor(config: UneeqConfig);
+    init(): void;
+    private ensureSessionExists;
+    chatPrompt(chatPrompt: string): void;
+    speak(speech: string): void;
+    openAudioStream(): void;
+    closeAudioStream(): void;
+    interruptAudioStream(): void;
+    speakAudio(audio: string | Uint8Array | Blob): Promise<void>;
+    cameraAnchorDistance(position: CameraAnchorDistance, duration?: number): void;
+    cameraAnchorHorizontal(position: CameraAnchorHorizontal, duration?: number): void;
+    endSession(): void;
+    unmuteDigitalHuman(): void;
+    muteDigitalHuman(): void;
+    stopSpeaking(): void;
+    setCustomPromptMetadata(metadata: object): void;
+    enableMicrophone(enable?: boolean): void;
+    pauseSpeechRecognition(): Promise<boolean>;
+    resumeSpeechRecognition(): Promise<boolean>;
+    setWebRtcStatsEnabled(emitMessages: boolean, logMessages: boolean): void;
+}

package/dist/src/uneeq.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/stats.d.ts

@@ -0,0 +1,11 @@
+export declare class Stats {
+    private readonly stream;
+    private readonly videoElement?;
+    private readonly audioElement?;
+    constructor(stream: any, videoElement?: HTMLVideoElement | undefined, audioElement?: HTMLAudioElement | undefined);
+    analyzeAudioStats(): Promise<void>;
+    private getInboundAudioStats;
+    private getCodecFromStats;
+    private logAudioStats;
+    private logElementStatus;
+}

package/dist/stats.spec.d.ts

@@ -0,0 +1 @@
+export {};