@stream-io/video-client 1.41.2 → 1.42.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.42.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.41.3...@stream-io/video-client-1.42.0) (2026-02-06)
+
+### Features
+
+- Detectors for broken microphone setup ([#2090](https://github.com/GetStream/stream-video-js/issues/2090)) ([552b3f4](https://github.com/GetStream/stream-video-js/commit/552b3f4e3c54e0b6fa67221cd510f4ea1f6f8a61))
+
+### Bug Fixes
+
+- **react:** apply defaultConstraints to speaking-while-muted detection stream ([#2103](https://github.com/GetStream/stream-video-js/issues/2103)) ([28b5538](https://github.com/GetStream/stream-video-js/commit/28b55380778723fc308d37396c8095a5a3ef7aa2))
+- start speaking while muted detection in pristine state too ([#2110](https://github.com/GetStream/stream-video-js/issues/2110)) ([bc093bc](https://github.com/GetStream/stream-video-js/commit/bc093bc3ac2451541524b134a9044131a69964af))
+
+## [1.41.3](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.41.2...@stream-io/video-client-1.41.3) (2026-01-30)
+
+### Bug Fixes
+
+- **react:** improve logic for calculating the lower / upper threshold for video filter degradation ([#2094](https://github.com/GetStream/stream-video-js/issues/2094)) ([5cd2d5c](https://github.com/GetStream/stream-video-js/commit/5cd2d5cb34fc7bbdfaf9529eb9f8d33a40346cab))
+- **stats:** adjust send stats frequency and include "leave reason" ([#2104](https://github.com/GetStream/stream-video-js/issues/2104)) ([0182832](https://github.com/GetStream/stream-video-js/commit/018283299bebe5d5078d4006ec86b6cd56884e77))
+
 ## [1.41.2](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.41.1...@stream-io/video-client-1.41.2) (2026-01-28)
 
 - deduplicate RN compatibility assertions ([#2101](https://github.com/GetStream/stream-video-js/issues/2101)) ([5b9e6bc](https://github.com/GetStream/stream-video-js/commit/5b9e6bc227c55b067eea6345315bca015c8a7ee4))

package/dist/index.browser.es.js

@@ -4789,7 +4789,7 @@ const hasVideo = (p) => p.publishedTracks.includes(TrackType.VIDEO);
  *
  * @param p the participant to check.
  */
-const hasAudio = (p) => p.publishedTracks.includes(TrackType.AUDIO);
+const hasAudio$1 = (p) => p.publishedTracks.includes(TrackType.AUDIO);
 /**
  * Check if a participant is screen sharing.
  *
@@ -4890,8 +4890,8 @@ const publishingVideo = (a, b) => {
  * @param b the second participant.
  */
 const publishingAudio = (a, b) => {
-    const hasA = hasAudio(a);
-    const hasB = hasAudio(b);
+    const hasA = hasAudio$1(a);
+    const hasB = hasAudio$1(b);
     if (hasA && !hasB)
         return -1;
     if (!hasA && hasB)
@@ -6188,7 +6188,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.41.2";
+const version = "1.42.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -6511,6 +6511,16 @@ const createStatsReporter = ({ subscriber, publisher, state, datacenter, polling
         stop,
     };
 };
+/**
+ * Extracts camera statistics from a media source.
+ *
+ * @param mediaSource the media source stats to extract camera info from.
+ */
+const getCameraStats = (mediaSource) => ({
+    frameRate: mediaSource.framesPerSecond,
+    frameWidth: mediaSource.width,
+    frameHeight: mediaSource.height,
+});
 /**
  * Transforms raw RTC stats into a slimmer and uniform across browsers format.
  *
@@ -6536,6 +6546,7 @@ const transform = (report, opts) => {
         }
         let trackType;
         let audioLevel;
+        let camera;
         let concealedSamples;
         let concealmentEvents;
         let packetsReceived;
@@ -6551,6 +6562,9 @@ const transform = (report, opts) => {
                     typeof mediaSource.audioLevel === 'number') {
                     audioLevel = mediaSource.audioLevel;
                 }
+                if (trackKind === 'video') {
+                    camera = getCameraStats(mediaSource);
+                }
             }
         }
         else if (kind === 'subscriber' && trackKind === 'audio') {
@@ -6584,6 +6598,7 @@ const transform = (report, opts) => {
             concealmentEvents,
             packetsReceived,
             packetsLost,
+            camera,
         };
     });
     return {
@@ -6603,6 +6618,7 @@ const getEmptyVideoStats = (stats) => {
         highestFrameWidth: 0,
         highestFrameHeight: 0,
         highestFramesPerSecond: 0,
+        camera: {},
         codec: '',
         codecPerTrackType: {},
         timestamp: Date.now(),
@@ -6647,6 +6663,9 @@ const aggregate = (stats) => {
             acc.highestFramesPerSecond = stream.framesPerSecond || 0;
             maxArea = streamArea;
         }
+        if (stream.trackType === TrackType.VIDEO) {
+            acc.camera = stream.camera;
+        }
         qualityLimitationReasons.add(stream.qualityLimitationReason || '');
         return acc;
     }, aggregatedStats);
@@ -6711,6 +6730,7 @@ const aggregateAudio = (stats) => {
 class SfuStatsReporter {
     constructor(sfuClient, { options, clientDetails, subscriber, publisher, microphone, camera, state, tracer, unifiedSessionId, }) {
         this.logger = videoLoggerSystem.getLogger('SfuStatsReporter');
+        this.reportCount = 0;
         this.inputDevices = new Map();
         this.observeDevice = (device, kind) => {
             const { browserPermissionState$ } = device.state;
@@ -6812,17 +6832,31 @@ class SfuStatsReporter {
                 throw err;
             }
         };
+        this.scheduleNextReport = () => {
+            const intervals = [1500, 3000, 3000, 5000];
+            if (this.reportCount < intervals.length) {
+                this.timeoutId = setTimeout(() => {
+                    this.flush();
+                    this.reportCount++;
+                    this.scheduleNextReport();
+                }, intervals[this.reportCount]);
+            }
+            else {
+                clearInterval(this.intervalId);
+                this.intervalId = setInterval(() => {
+                    this.flush();
+                }, this.options.reporting_interval_ms);
+            }
+        };
         this.start = () => {
             if (this.options.reporting_interval_ms <= 0)
                 return;
             this.observeDevice(this.microphone, 'mic');
             this.observeDevice(this.camera, 'camera');
+            this.reportCount = 0;
             clearInterval(this.intervalId);
-            this.intervalId = setInterval(() => {
-                this.run().catch((err) => {
-                    this.logger.warn('Failed to report stats', err);
-                });
-            }, this.options.reporting_interval_ms);
+            clearTimeout(this.timeoutId);
+            this.scheduleNextReport();
         };
         this.stop = () => {
             this.unsubscribeDevicePermissionsSubscription?.();
@@ -6834,20 +6868,13 @@ class SfuStatsReporter {
             this.intervalId = undefined;
             clearTimeout(this.timeoutId);
             this.timeoutId = undefined;
+            this.reportCount = 0;
         };
         this.flush = () => {
             this.run().catch((err) => {
                 this.logger.warn('Failed to flush report stats', err);
             });
         };
-        this.scheduleOne = (timeout) => {
-            clearTimeout(this.timeoutId);
-            this.timeoutId = setTimeout(() => {
-                this.run().catch((err) => {
-                    this.logger.warn('Failed to report stats', err);
-                });
-            }, timeout);
-        };
         this.sfuClient = sfuClient;
         this.options = options;
         this.subscriber = subscriber;
@@ -10352,7 +10379,7 @@ const getAudioStream = async (trackConstraints, tracer) => {
             videoLoggerSystem
                 .getLogger('devices')
                 .warn('Failed to get audio stream, will try again with relaxed constraints', { error, constraints, relaxedConstraints });
-            return getAudioStream(relaxedConstraints);
+            return getAudioStream(relaxedConstraints, tracer);
         }
         videoLoggerSystem.getLogger('devices').error('Failed to get audio stream', {
             error,
@@ -11349,9 +11376,6 @@ class MicrophoneManagerState extends AudioDeviceManagerState {
     }
 }
 
-const DETECTION_FREQUENCY_IN_MS = 500;
-const AUDIO_LEVEL_THRESHOLD = 150;
-const FFT_SIZE = 128;
 /**
  * Creates a new sound detector.
  *
@@ -11361,7 +11385,7 @@ const FFT_SIZE = 128;
  * @returns a clean-up function which once invoked stops the sound detector.
  */
 const createSoundDetector = (audioStream, onSoundDetectedStateChanged, options = {}) => {
-    const { detectionFrequencyInMs = DETECTION_FREQUENCY_IN_MS, audioLevelThreshold = AUDIO_LEVEL_THRESHOLD, fftSize = FFT_SIZE, destroyStreamOnStop = true, } = options;
+    const { detectionFrequencyInMs = 500, audioLevelThreshold = 150, fftSize = 128, destroyStreamOnStop = true, } = options;
     const audioContext = new AudioContext();
     const analyser = audioContext.createAnalyser();
     analyser.fftSize = fftSize;
@@ -11402,6 +11426,101 @@ const createSoundDetector = (audioStream, onSoundDetectedStateChanged, options =
     };
 };
 
+/**
+ * Analyzes frequency data to determine if audio is being captured.
+ */
+const hasAudio = (analyser, threshold) => {
+    const data = new Uint8Array(analyser.frequencyBinCount);
+    analyser.getByteFrequencyData(data);
+    return data.some((value) => value > threshold);
+};
+/** Helper for "no event" transitions */
+const noEmit = (nextState) => ({
+    shouldEmit: false,
+    nextState,
+});
+/** Helper for event-emitting transitions */
+const emit = (capturesAudio, nextState) => ({ shouldEmit: true, nextState, capturesAudio });
+/**
+ * State transition function - computes next state and whether to emit an event.
+ */
+const transitionState = (state, audioDetected, options) => {
+    if (audioDetected) {
+        return state.kind === 'IDLE' || state.kind === 'EMITTING'
+            ? emit(true, state)
+            : noEmit(state);
+    }
+    const { noAudioThresholdMs, emitIntervalMs } = options;
+    const now = Date.now();
+    switch (state.kind) {
+        case 'IDLE':
+            return noEmit({ kind: 'DETECTING', noAudioStartTime: now });
+        case 'DETECTING': {
+            const { noAudioStartTime } = state;
+            const elapsed = now - noAudioStartTime;
+            return elapsed >= noAudioThresholdMs
+                ? emit(false, { kind: 'EMITTING', noAudioStartTime, lastEmitTime: now })
+                : noEmit(state);
+        }
+        case 'EMITTING': {
+            const timeSinceLastEmit = now - state.lastEmitTime;
+            return timeSinceLastEmit >= emitIntervalMs
+                ? emit(false, { ...state, lastEmitTime: now })
+                : noEmit(state);
+        }
+    }
+};
+/**
+ * Creates and configures an audio analyzer for the given stream.
+ */
+const createAudioAnalyzer = (audioStream, fftSize) => {
+    const audioContext = new AudioContext();
+    const analyser = audioContext.createAnalyser();
+    analyser.fftSize = fftSize;
+    const microphone = audioContext.createMediaStreamSource(audioStream);
+    microphone.connect(analyser);
+    return { audioContext, analyser };
+};
+/**
+ * Creates a new no-audio detector that monitors continuous absence of audio on an audio stream.
+ *
+ * @param audioStream the audio stream to observe.
+ * @param options custom options for the no-audio detector.
+ * @returns a cleanup function which once invoked stops the no-audio detector.
+ */
+const createNoAudioDetector = (audioStream, options) => {
+    const { detectionFrequencyInMs = 350, audioLevelThreshold = 0, fftSize = 256, onCaptureStatusChange, } = options;
+    let state = { kind: 'IDLE' };
+    const { audioContext, analyser } = createAudioAnalyzer(audioStream, fftSize);
+    const detectionIntervalId = setInterval(() => {
+        const [audioTrack] = audioStream.getAudioTracks();
+        if (!audioTrack?.enabled || audioTrack.readyState === 'ended') {
+            state = { kind: 'IDLE' };
+            return;
+        }
+        const audioDetected = hasAudio(analyser, audioLevelThreshold);
+        const transition = transitionState(state, audioDetected, options);
+        state = transition.nextState;
+        if (!transition.shouldEmit)
+            return;
+        const { capturesAudio } = transition;
+        onCaptureStatusChange(capturesAudio);
+        if (capturesAudio) {
+            stop().catch((err) => {
+                const logger = videoLoggerSystem.getLogger('NoAudioDetector');
+                logger.error('Error stopping no-audio detector', err);
+            });
+        }
+    }, detectionFrequencyInMs);
+    async function stop() {
+        clearInterval(detectionIntervalId);
+        if (audioContext.state !== 'closed') {
+            await audioContext.close();
+        }
+    }
+    return stop;
+};
+
 class RNSpeechDetector {
     constructor(externalAudioStream) {
         this.pc1 = new RTCPeerConnection({});
@@ -11413,16 +11532,10 @@ class RNSpeechDetector {
      */
     async start(onSoundDetectedStateChanged) {
         try {
-            let audioStream;
-            if (this.externalAudioStream != null) {
-                audioStream = this.externalAudioStream;
-            }
-            else {
-                audioStream = await navigator.mediaDevices.getUserMedia({
-                    audio: true,
-                });
-                this.audioStream = audioStream;
-            }
+            const audioStream = this.externalAudioStream != null
+                ? this.externalAudioStream
+                : await navigator.mediaDevices.getUserMedia({ audio: true });
+            this.audioStream = audioStream;
             this.pc1.addEventListener('icecandidate', async (e) => {
                 await this.pc2.addIceCandidate(e.candidate);
             });
@@ -11446,9 +11559,9 @@ class RNSpeechDetector {
             const answer = await this.pc2.createAnswer();
             await this.pc1.setRemoteDescription(answer);
             await this.pc2.setLocalDescription(answer);
-            const unsub = this.onSpeakingDetectedStateChange(onSoundDetectedStateChanged);
+            const unsubscribe = this.onSpeakingDetectedStateChange(onSoundDetectedStateChanged);
             return () => {
-                unsub();
+                unsubscribe();
                 this.stop();
             };
         }
@@ -11488,7 +11601,7 @@ class RNSpeechDetector {
         const silenceTimeout = 5000; // Reset baseline after 5 seconds of silence
         const checkAudioLevel = async () => {
             try {
-                const stats = (await this.pc1.getStats());
+                const stats = await this.pc1.getStats();
                 const report = flatten(stats);
                 // Audio levels are present inside stats of type `media-source` and of kind `audio`
                 const audioMediaSourceStats = report.find((stat) => stat.type === 'media-source' &&
@@ -11542,8 +11655,7 @@ class RNSpeechDetector {
                 logger.error('error checking audio level from stats', error);
             }
         };
-        // Call checkAudioLevel periodically (every 100ms)
-        const intervalId = setInterval(checkAudioLevel, 100);
+        const intervalId = setInterval(checkAudioLevel, 250);
         return () => {
             clearInterval(intervalId);
             clearTimeout(speechTimer);
@@ -11569,8 +11681,11 @@ class MicrophoneManager extends AudioDeviceManager {
         super(call, new MicrophoneManagerState(disableMode), TrackType.AUDIO);
         this.speakingWhileMutedNotificationEnabled = true;
         this.soundDetectorConcurrencyTag = Symbol('soundDetectorConcurrencyTag');
+        this.silenceThresholdMs = 5000;
     }
     setup() {
+        if (this.areSubscriptionsSetUp)
+            return;
         super.setup();
         this.subscriptions.push(createSafeAsyncSubscription(combineLatest([
             this.call.state.callingState$,
@@ -11587,7 +11702,7 @@ class MicrophoneManager extends AudioDeviceManager {
                 if (!this.speakingWhileMutedNotificationEnabled)
                     return;
                 if (ownCapabilities.includes(OwnCapability.SEND_AUDIO)) {
-                    if (status === 'disabled') {
+                    if (status !== 'enabled') {
                         await this.startSpeakingWhileMutedDetection(deviceId);
                     }
                     else {
@@ -11636,6 +11751,40 @@ class MicrophoneManager extends AudioDeviceManager {
                 });
             }
         }));
+        if (!isReactNative()) {
+            const unsubscribe = createSafeAsyncSubscription(combineLatest([this.state.status$, this.state.mediaStream$]), async ([status, mediaStream]) => {
+                if (this.noAudioDetectorCleanup) {
+                    const cleanup = this.noAudioDetectorCleanup;
+                    this.noAudioDetectorCleanup = undefined;
+                    await cleanup().catch((err) => {
+                        this.logger.warn('Failed to stop no-audio detector', err);
+                    });
+                }
+                if (status !== 'enabled' || !mediaStream)
+                    return;
+                if (this.silenceThresholdMs <= 0)
+                    return;
+                const deviceId = this.state.selectedDevice;
+                const devices = getCurrentValue(this.listDevices());
+                const label = devices.find((d) => d.deviceId === deviceId)?.label;
+                this.noAudioDetectorCleanup = createNoAudioDetector(mediaStream, {
+                    noAudioThresholdMs: this.silenceThresholdMs,
+                    emitIntervalMs: this.silenceThresholdMs,
+                    onCaptureStatusChange: (capturesAudio) => {
+                        const event = {
+                            type: 'mic.capture_report',
+                            call_cid: this.call.cid,
+                            capturesAudio,
+                            deviceId,
+                            label,
+                        };
+                        this.call.tracer.trace('mic.capture_report', event);
+                        this.call.streamClient.dispatchEvent(event);
+                    },
+                });
+            });
+            this.subscriptions.push(unsubscribe);
+        }
     }
     /**
      * Enables noise cancellation for the microphone.
@@ -11733,6 +11882,45 @@ class MicrophoneManager extends AudioDeviceManager {
         this.speakingWhileMutedNotificationEnabled = false;
         await this.stopSpeakingWhileMutedDetection();
     }
+    /**
+     * Sets the silence threshold in milliseconds for no-audio detection.
+     * When the microphone is enabled but produces no audio for this duration,
+     * a 'mic.capture_report' event will be emitted.
+     *
+     * @param thresholdMs the threshold in milliseconds (default: 5000).
+     *   Set to 0 or a negative value to disable no-audio detection.
+     */
+    setSilenceThreshold(thresholdMs) {
+        this.silenceThresholdMs = thresholdMs;
+    }
+    /**
+     * Performs audio capture test on a specific microphone.
+     *
+     * This method is only available in browser environments (not React Native).
+     *
+     * @param deviceId The device ID to test.
+     * @param options Optional test configuration.
+     * @returns Promise that resolves with the test result (true or false).
+     */
+    async performTest(deviceId, options) {
+        if (isReactNative())
+            throw new Error('Not available in React Native');
+        const stream = await this.getStream({ deviceId: { exact: deviceId } });
+        const { testDurationMs = 3000 } = options || {};
+        const { promise, resolve } = promiseWithResolvers();
+        const cleanup = createNoAudioDetector(stream, {
+            noAudioThresholdMs: testDurationMs,
+            emitIntervalMs: testDurationMs,
+            onCaptureStatusChange: async (capturesAudio) => {
+                resolve(capturesAudio);
+                await cleanup().catch((err) => {
+                    this.logger.warn('Failed to stop detector during test', err);
+                });
+                disposeOfMediaStream(stream);
+            },
+        });
+        return promise;
+    }
     /**
      * Applies the audio settings to the microphone.
      * @param settings the audio settings to apply.
@@ -11781,13 +11969,12 @@ class MicrophoneManager extends AudioDeviceManager {
     }
     async startSpeakingWhileMutedDetection(deviceId) {
         await withoutConcurrency(this.soundDetectorConcurrencyTag, async () => {
-            await this.stopSpeakingWhileMutedDetection();
             if (isReactNative()) {
                 this.rnSpeechDetector = new RNSpeechDetector();
                 const unsubscribe = await this.rnSpeechDetector.start((event) => {
                     this.state.setSpeakingWhileMuted(event.isSoundDetected);
                 });
-                this.soundDetectorCleanup = () => {
+                this.soundDetectorCleanup = async () => {
                     unsubscribe();
                     this.rnSpeechDetector = undefined;
                 };
@@ -11795,6 +11982,7 @@ class MicrophoneManager extends AudioDeviceManager {
             else {
                 // Need to start a new stream that's not connected to publisher
                 const stream = await this.getStream({
+                    ...this.state.defaultConstraints,
                     deviceId: { exact: deviceId },
                 });
                 this.soundDetectorCleanup = createSoundDetector(stream, (event) => {
@@ -11874,6 +12062,8 @@ class ScreenShareManager extends AudioDeviceManager {
         super(call, new ScreenShareState(), TrackType.SCREEN_SHARE);
     }
     setup() {
+        if (this.areSubscriptionsSetUp)
+            return;
         super.setup();
         this.subscriptions.push(createSubscription(this.call.state.settings$, (settings) => {
             const maybeTargetResolution = settings?.screensharing.target_resolution;
@@ -12220,6 +12410,9 @@ class Call {
                 this.leaveCallHooks.add(registerEventHandlers(this, this.dispatcher));
                 this.registerEffects();
                 this.registerReconnectHandlers();
+                // Set up the device managers again. Although this is already done
+                // in the DeviceManager's constructor, they'll need to be re-set up
+                // in the cases where a call instance is recycled (join -> leave -> join).
                 this.camera.setup();
                 this.microphone.setup();
                 this.screenShare.setup();
@@ -12447,6 +12640,8 @@ class Call {
                 }
                 this.statsReporter?.stop();
                 this.statsReporter = undefined;
+                const leaveReason = message ?? reason ?? 'user is leaving the call';
+                this.tracer.trace('call.leaveReason', leaveReason);
                 this.sfuStatsReporter?.flush();
                 this.sfuStatsReporter?.stop();
                 this.sfuStatsReporter = undefined;
@@ -12454,7 +12649,7 @@ class Call {
                 this.subscriber = undefined;
                 this.publisher?.dispose();
                 this.publisher = undefined;
-                await this.sfuClient?.leaveAndClose(message ?? reason ?? 'user is leaving the call');
+                await this.sfuClient?.leaveAndClose(leaveReason);
                 this.sfuClient = undefined;
                 this.dynascaleManager.setSfuClient(undefined);
                 await this.dynascaleManager.dispose();
@@ -12596,6 +12791,7 @@ class Call {
          * Unless you are implementing a custom "ringing" flow, you should not use this method.
          */
         this.accept = async () => {
+            this.tracer.trace('call.accept', '');
             return this.streamClient.post(`${this.streamClientBasePath}/accept`);
         };
         /**
@@ -12608,6 +12804,7 @@ class Call {
          * @param reason the reason for rejecting the call.
          */
         this.reject = async (reason = 'decline') => {
+            this.tracer.trace('call.reject', reason);
             return this.streamClient.post(`${this.streamClientBasePath}/reject`, { reason: reason });
         };
         /**
@@ -13371,11 +13568,6 @@ class Call {
                     trackTypes.push(screenShareAudio);
                 }
             }
-            if (track.kind === 'video') {
-                // schedules calibration report - the SFU will use the performance stats
-                // to adjust the quality thresholds as early as possible
-                this.sfuStatsReporter?.scheduleOne(3000);
-            }
             await this.updateLocalStreamState(mediaStream, ...trackTypes);
         };
         /**
@@ -15320,7 +15512,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.41.2", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.42.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -15956,5 +16148,5 @@ const humanize = (n) => {
     return String(n);
 };
 
-export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallRecordingFailedEventRecordingTypeEnum, CallRecordingReadyEventRecordingTypeEnum, CallRecordingStartedEventRecordingTypeEnum, CallRecordingStoppedEventRecordingTypeEnum, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, CreateDeviceRequestPushProviderEnum, DebounceType, DeviceManager, DeviceManagerState, DynascaleManager, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, IndividualRecordingSettingsRequestModeEnum, IndividualRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressSourceRequestFpsEnum, IngressVideoLayerRequestCodecEnum, LayoutSettingsRequestNameEnum, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RNSpeechDetector, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RawRecordingSettingsRequestModeEnum, RawRecordingSettingsResponseModeEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, SfuJoinError, models as SfuModels, SpeakerManager, SpeakerState, StartClosedCaptionsRequestLanguageEnum, StartTranscriptionRequestLanguageEnum, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestLanguageEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseLanguageEnum, TranscriptionSettingsResponseModeEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceState, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio, hasPausedTrack, hasScreenShare, hasScreenShareAudio, hasVideo, humanize, isPinned, livestreamOrAudioRoomSortPreset, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishingAudio, publishingVideo, reactionType, resolveDeviceId, role, screenSharing, setDeviceInfo, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking, videoLoggerSystem, withParticipantSource };
+export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallRecordingFailedEventRecordingTypeEnum, CallRecordingReadyEventRecordingTypeEnum, CallRecordingStartedEventRecordingTypeEnum, CallRecordingStoppedEventRecordingTypeEnum, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, CreateDeviceRequestPushProviderEnum, DebounceType, DeviceManager, DeviceManagerState, DynascaleManager, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, IndividualRecordingSettingsRequestModeEnum, IndividualRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressSourceRequestFpsEnum, IngressVideoLayerRequestCodecEnum, LayoutSettingsRequestNameEnum, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RNSpeechDetector, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RawRecordingSettingsRequestModeEnum, RawRecordingSettingsResponseModeEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, SfuJoinError, models as SfuModels, SpeakerManager, SpeakerState, StartClosedCaptionsRequestLanguageEnum, StartTranscriptionRequestLanguageEnum, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestLanguageEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseLanguageEnum, TranscriptionSettingsResponseModeEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceState, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio$1 as hasAudio, hasPausedTrack, hasScreenShare, hasScreenShareAudio, hasVideo, humanize, isPinned, livestreamOrAudioRoomSortPreset, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishingAudio, publishingVideo, reactionType, resolveDeviceId, role, screenSharing, setDeviceInfo, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking, videoLoggerSystem, withParticipantSource };
 //# sourceMappingURL=index.browser.es.js.map