@stream-io/video-client 1.40.3 → 1.41.1

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.41.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.41.0...@stream-io/video-client-1.41.1) (2026-01-26)
+
+### Bug Fixes
+
+- **safari:** Handle interrupted AudioContext and AudioSession states ([#2098](https://github.com/GetStream/stream-video-js/issues/2098)) ([975901f](https://github.com/GetStream/stream-video-js/commit/975901f399b46479928ec1e9f32da7e47bba9ad3))
+- use multiple settings to determine default audio device RN-338 ([#2096](https://github.com/GetStream/stream-video-js/issues/2096)) ([19cf136](https://github.com/GetStream/stream-video-js/commit/19cf13651112b647903587a84a70a555fc68fc9c)), closes [2BSettingsPriority.swift#L19](https://github.com/GetStream/2BSettingsPriority.swift/issues/L19)
+
+## [1.41.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.40.3...@stream-io/video-client-1.41.0) (2026-01-20)
+
+### Features
+
+- **recording:** Support for Individual, Raw and Composite recording ([#2071](https://github.com/GetStream/stream-video-js/issues/2071)) ([e53269c](https://github.com/GetStream/stream-video-js/commit/e53269ce697121b70dbebaf4a6d2cf875440a2af))
+- stereo audio output support RN-332 ([#2038](https://github.com/GetStream/stream-video-js/issues/2038)) ([2938037](https://github.com/GetStream/stream-video-js/commit/2938037d18e70ccf112a089eb3ec44cb034aed1d))
+
+### Bug Fixes
+
+- add start bitrate even if there is no existing fmtp line ([#2088](https://github.com/GetStream/stream-video-js/issues/2088)) ([ae1f496](https://github.com/GetStream/stream-video-js/commit/ae1f4965a7ab0b00dbdea45090c6aed49eafabb7))
+
 ## [1.40.3](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.40.2...@stream-io/video-client-1.40.3) (2026-01-16)
 
 ### Bug Fixes

package/dist/index.browser.es.js

@@ -26,6 +26,38 @@ const AudioSettingsResponseDefaultDeviceEnum = {
     SPEAKER: 'speaker',
     EARPIECE: 'earpiece',
 };
+/**
+ * @export
+ */
+const CallRecordingFailedEventRecordingTypeEnum = {
+    COMPOSITE: 'composite',
+    INDIVIDUAL: 'individual',
+    RAW: 'raw',
+};
+/**
+ * @export
+ */
+const CallRecordingReadyEventRecordingTypeEnum = {
+    COMPOSITE: 'composite',
+    INDIVIDUAL: 'individual',
+    RAW: 'raw',
+};
+/**
+ * @export
+ */
+const CallRecordingStartedEventRecordingTypeEnum = {
+    COMPOSITE: 'composite',
+    INDIVIDUAL: 'individual',
+    RAW: 'raw',
+};
+/**
+ * @export
+ */
+const CallRecordingStoppedEventRecordingTypeEnum = {
+    COMPOSITE: 'composite',
+    INDIVIDUAL: 'individual',
+    RAW: 'raw',
+};
 /**
  * @export
  */
@@ -61,6 +93,22 @@ const FrameRecordingSettingsResponseModeEnum = {
     DISABLED: 'disabled',
     AUTO_ON: 'auto-on',
 };
+/**
+ * @export
+ */
+const IndividualRecordingSettingsRequestModeEnum = {
+    AVAILABLE: 'available',
+    DISABLED: 'disabled',
+    AUTO_ON: 'auto-on',
+};
+/**
+ * @export
+ */
+const IndividualRecordingSettingsResponseModeEnum = {
+    AVAILABLE: 'available',
+    DISABLED: 'disabled',
+    AUTO_ON: 'auto-on',
+};
 /**
  * @export
  */
@@ -126,11 +174,15 @@ const OwnCapability = {
     START_BROADCAST_CALL: 'start-broadcast-call',
     START_CLOSED_CAPTIONS_CALL: 'start-closed-captions-call',
     START_FRAME_RECORD_CALL: 'start-frame-record-call',
+    START_INDIVIDUAL_RECORD_CALL: 'start-individual-record-call',
+    START_RAW_RECORD_CALL: 'start-raw-record-call',
     START_RECORD_CALL: 'start-record-call',
     START_TRANSCRIPTION_CALL: 'start-transcription-call',
     STOP_BROADCAST_CALL: 'stop-broadcast-call',
     STOP_CLOSED_CAPTIONS_CALL: 'stop-closed-captions-call',
     STOP_FRAME_RECORD_CALL: 'stop-frame-record-call',
+    STOP_INDIVIDUAL_RECORD_CALL: 'stop-individual-record-call',
+    STOP_RAW_RECORD_CALL: 'stop-raw-record-call',
     STOP_RECORD_CALL: 'stop-record-call',
     STOP_TRANSCRIPTION_CALL: 'stop-transcription-call',
     UPDATE_CALL: 'update-call',
@@ -168,6 +220,22 @@ const RTMPSettingsRequestQualityEnum = {
     PORTRAIT_1080X1920: 'portrait-1080x1920',
     PORTRAIT_1440X2560: 'portrait-1440x2560',
 };
+/**
+ * @export
+ */
+const RawRecordingSettingsRequestModeEnum = {
+    AVAILABLE: 'available',
+    DISABLED: 'disabled',
+    AUTO_ON: 'auto-on',
+};
+/**
+ * @export
+ */
+const RawRecordingSettingsResponseModeEnum = {
+    AVAILABLE: 'available',
+    DISABLED: 'disabled',
+    AUTO_ON: 'auto-on',
+};
 /**
  * @export
  */
@@ -3983,15 +4051,18 @@ const extractMid = (transceiver, transceiverInitIndex, sdp) => {
         return '';
     return String(transceiverInitIndex);
 };
-/*
- * Sets the start bitrate for the VP9 and H264 codecs in the SDP.
+/**
+ * Sets the start bitrate for the VP9, H264, and AV1 codecs in the SDP.
  *
  * @param offerSdp the offer SDP to modify.
- * @param startBitrate the start bitrate in kbps to set. Default is 1000 kbps.
+ * @param maxBitrateKbps the maximum bitrate in kbps.
+ * @param startBitrateFactor the factor (0-1) to multiply with maxBitrateKbps to get the start bitrate.
+ * @param targetMid the media ID to target.
  */
 const setStartBitrate = (offerSdp, maxBitrateKbps, startBitrateFactor, targetMid) => {
     // start bitrate should be between 300kbps and max-bitrate-kbps
-    const startBitrate = Math.max(Math.min(maxBitrateKbps, startBitrateFactor * maxBitrateKbps), 300);
+    // Clamp to max first, then ensure minimum of 300 (but never exceed max)
+    const startBitrate = Math.min(maxBitrateKbps, Math.max(300, startBitrateFactor * maxBitrateKbps));
     const parsedSdp = parse(offerSdp);
     const targetCodecs = new Set(['av1', 'vp9', 'h264']);
     for (const media of parsedSdp.media) {
@@ -4002,14 +4073,27 @@ const setStartBitrate = (offerSdp, maxBitrateKbps, startBitrateFactor, targetMid
         for (const rtp of media.rtp) {
             if (!targetCodecs.has(rtp.codec.toLowerCase()))
                 continue;
-            for (const fmtp of media.fmtp) {
-                if (fmtp.payload === rtp.payload) {
-                    if (!fmtp.config.includes('x-google-start-bitrate')) {
-                        fmtp.config += `;x-google-start-bitrate=${startBitrate}`;
-                    }
-                    break;
+            // Find existing fmtp entry for this payload
+            // Guard against media.fmtp being undefined when SDP has no a=fmtp lines
+            const fmtpList = media.fmtp ?? (media.fmtp = []);
+            const existingFmtp = fmtpList.find((fmtp) => fmtp.payload === rtp.payload);
+            if (existingFmtp) {
+                // Append to existing fmtp if not already present
+                // Guard against undefined or empty config from malformed SDP
+                const config = existingFmtp.config ?? '';
+                if (!config.includes('x-google-start-bitrate')) {
+                    existingFmtp.config = config
+                        ? `${config};x-google-start-bitrate=${startBitrate}`
+                        : `x-google-start-bitrate=${startBitrate}`;
                 }
             }
+            else {
+                // Create new fmtp entry if none exists
+                fmtpList.push({
+                    payload: rtp.payload,
+                    config: `x-google-start-bitrate=${startBitrate}`,
+                });
+            }
         }
     }
     return write(parsedSdp);
@@ -4939,6 +5023,10 @@ const paginatedLayoutSortPreset = combineComparators(pinned, ifInvisibleOrUnknow
  */
 const livestreamOrAudioRoomSortPreset = combineComparators(ifInvisibleBy(combineComparators(dominantSpeaker, speaking, reactionType('raised-hand'), withVideoIngressSource, publishingVideo, publishingAudio)), role('admin', 'host', 'speaker'));
 
+const ensureExhausted = (x, message) => {
+    videoLoggerSystem.getLogger('helpers').warn(message, x);
+};
+
 /**
  * Returns the default egress object - when no egress data is available.
  */
@@ -4968,6 +5056,8 @@ class CallState {
         this.egressSubject = new BehaviorSubject(undefined);
         this.ingressSubject = new BehaviorSubject(undefined);
         this.recordingSubject = new BehaviorSubject(false);
+        this.individualRecordingSubject = new BehaviorSubject(false);
+        this.rawRecordingSubject = new BehaviorSubject(false);
         this.sessionSubject = new BehaviorSubject(undefined);
         this.settingsSubject = new BehaviorSubject(undefined);
         this.transcribingSubject = new BehaviorSubject(false);
@@ -5394,7 +5484,10 @@ class CallState {
             this.setCurrentValue(this.customSubject, call.custom);
             this.setCurrentValue(this.egressSubject, call.egress);
             this.setCurrentValue(this.ingressSubject, call.ingress);
-            this.setCurrentValue(this.recordingSubject, call.recording);
+            const { individual_recording, composite_recording, raw_recording } = call.egress;
+            this.setCurrentValue(this.recordingSubject, call.recording || composite_recording?.status === 'running');
+            this.setCurrentValue(this.individualRecordingSubject, individual_recording?.status === 'running');
+            this.setCurrentValue(this.rawRecordingSubject, raw_recording?.status === 'running');
             const s = this.setCurrentValue(this.sessionSubject, call.session);
             this.updateParticipantCountFromSession(s);
             this.setCurrentValue(this.settingsSubject, call.settings);
@@ -5470,6 +5563,21 @@ class CallState {
                 },
             }));
         };
+        this.updateFromRecordingEvent = (type, running) => {
+            // handle the legacy format, where `type` is absent in the emitted events
+            if (type === undefined || type === 'composite') {
+                this.setCurrentValue(this.recordingSubject, running);
+            }
+            else if (type === 'individual') {
+                this.setCurrentValue(this.individualRecordingSubject, running);
+            }
+            else if (type === 'raw') {
+                this.setCurrentValue(this.rawRecordingSubject, running);
+            }
+            else {
+                ensureExhausted(type, 'Unknown recording type');
+            }
+        };
         this.updateParticipantCountFromSession = (session) => {
             // when in JOINED state, we should use the participant count coming through
             // the SFU healthcheck event, as it's more accurate.
@@ -5704,6 +5812,8 @@ class CallState {
         }), distinctUntilChanged(isShallowEqual), shareReplay({ bufferSize: 1, refCount: true }));
         this.participantCount$ = duc(this.participantCountSubject);
         this.recording$ = duc(this.recordingSubject);
+        this.individualRecording$ = duc(this.individualRecordingSubject);
+        this.rawRecording$ = duc(this.rawRecordingSubject);
         this.transcribing$ = duc(this.transcribingSubject);
         this.captioning$ = duc(this.captioningSubject);
         this.eventHandlers = {
@@ -5770,9 +5880,15 @@ class CallState {
             },
             'call.permissions_updated': this.updateOwnCapabilities,
             'call.reaction_new': this.updateParticipantReaction,
-            'call.recording_started': () => this.setCurrentValue(this.recordingSubject, true),
-            'call.recording_stopped': () => this.setCurrentValue(this.recordingSubject, false),
-            'call.recording_failed': () => this.setCurrentValue(this.recordingSubject, false),
+            'call.recording_started': (e) => {
+                this.updateFromRecordingEvent(e.recording_type, true);
+            },
+            'call.recording_stopped': (e) => {
+                this.updateFromRecordingEvent(e.recording_type, false);
+            },
+            'call.recording_failed': (e) => {
+                this.updateFromRecordingEvent(e.recording_type, false);
+            },
             'call.rejected': (e) => this.updateFromCallResponse(e.call),
             'call.ring': (e) => this.updateFromCallResponse(e.call),
             'call.missed': (e) => this.updateFromCallResponse(e.call),
@@ -5955,11 +6071,23 @@ class CallState {
         return this.getCurrentValue(this.ingress$);
     }
     /**
-     * Will provide the recording state of this call.
+     * Will provide the composite recording state of this call.
      */
     get recording() {
         return this.getCurrentValue(this.recording$);
     }
+    /**
+     * Will provide the individual recording state of this call.
+     */
+    get individualRecording() {
+        return this.getCurrentValue(this.individualRecording$);
+    }
+    /**
+     * Will provide the raw recording state of this call.
+     */
+    get rawRecording() {
+        return this.getCurrentValue(this.rawRecording$);
+    }
     /**
      * Will provide the session data of this call.
      */
@@ -6060,7 +6188,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.40.3";
+const version = "1.41.1";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -7408,10 +7536,6 @@ class TransceiverCache {
     }
 }
 
-const ensureExhausted = (x, message) => {
-    videoLoggerSystem.getLogger('helpers').warn(message, x);
-};
-
 const trackTypeToParticipantStreamKey = (trackType) => {
     switch (trackType) {
         case TrackType.SCREEN_SHARE:
@@ -7892,7 +8016,7 @@ class Publisher extends BasePeerConnection {
                     let sdp = dangerouslyForceCodec
                         ? removeCodecsExcept(baseSdp, dangerouslyForceCodec, fmtpLine)
                         : baseSdp;
-                    if (dangerouslySetStartBitrateFactor) {
+                    if (dangerouslySetStartBitrateFactor !== undefined) {
                         this.transceiverCache.items().forEach((t) => {
                             if (t.publishOption.trackType !== TrackType.VIDEO)
                                 return;
@@ -9248,12 +9372,13 @@ class DynascaleManager {
     /**
      * Creates a new DynascaleManager instance.
      */
-    constructor(callState, speaker) {
+    constructor(callState, speaker, tracer) {
         /**
          * The viewport tracker instance.
          */
         this.viewportTracker = new ViewportTracker();
         this.logger = videoLoggerSystem.getLogger('DynascaleManager');
+        this.useWebAudio = isSafari();
         this.pendingSubscriptionsUpdate = null;
         this.videoTrackSubscriptionOverridesSubject = new BehaviorSubject({});
         this.videoTrackSubscriptionOverrides$ = this.videoTrackSubscriptionOverridesSubject.asObservable();
@@ -9293,6 +9418,10 @@ class DynascaleManager {
             }
         };
         this.setVideoTrackSubscriptionOverrides = (override, sessionIds) => {
+            this.tracer.trace('setVideoTrackSubscriptionOverrides', [
+                override,
+                sessionIds,
+            ]);
             if (!sessionIds) {
                 return setCurrentValue(this.videoTrackSubscriptionOverridesSubject, override ? { [globalOverrideKey]: override } : {});
             }
@@ -9374,6 +9503,18 @@ class DynascaleManager {
         this.setViewport = (element) => {
             return this.viewportTracker.setViewport(element);
         };
+        /**
+         * Sets whether to use WebAudio API for audio playback.
+         * Must be set before joining the call.
+         *
+         * @internal
+         *
+         * @param useWebAudio whether to use WebAudio API.
+         */
+        this.setUseWebAudio = (useWebAudio) => {
+            this.tracer.trace('setUseWebAudio', useWebAudio);
+            this.useWebAudio = useWebAudio;
+        };
         /**
          * Binds a DOM <video> element to the given session id.
          * This method will make sure that the video element will play
@@ -9589,6 +9730,7 @@ class DynascaleManager {
                         // we will play audio directly through the audio element in other browsers
                         audioElement.muted = false;
                         audioElement.play().catch((e) => {
+                            this.tracer.trace('audioPlaybackError', e.message);
                             this.logger.warn(`Failed to play audio stream`, e);
                         });
                     }
@@ -9623,32 +9765,57 @@ class DynascaleManager {
             };
         };
         this.getOrCreateAudioContext = () => {
-            if (this.audioContext || !isSafari())
+            if (!this.useWebAudio)
+                return;
+            if (this.audioContext)
                 return this.audioContext;
             const context = new AudioContext();
+            this.tracer.trace('audioContext.create', context.state);
             if (context.state === 'suspended') {
                 document.addEventListener('click', this.resumeAudioContext);
             }
-            // @ts-expect-error audioSession is available in Safari only
+            context.addEventListener('statechange', () => {
+                this.tracer.trace('audioContext.state', context.state);
+                if (context.state === 'interrupted') {
+                    this.resumeAudioContext();
+                }
+            });
             const audioSession = navigator.audioSession;
             if (audioSession) {
                 // https://github.com/w3c/audio-session/blob/main/explainer.md
                 audioSession.type = 'play-and-record';
+                let isSessionInterrupted = false;
+                audioSession.addEventListener('statechange', () => {
+                    this.tracer.trace('audioSession.state', audioSession.state);
+                    if (audioSession.state === 'interrupted') {
+                        isSessionInterrupted = true;
+                    }
+                    else if (isSessionInterrupted) {
+                        this.resumeAudioContext();
+                        isSessionInterrupted = false;
+                    }
+                });
             }
             return (this.audioContext = context);
         };
         this.resumeAudioContext = () => {
-            if (this.audioContext?.state === 'suspended') {
-                this.audioContext
-                    .resume()
-                    .catch((err) => this.logger.warn(`Can't resume audio context`, err))
-                    .then(() => {
+            if (!this.audioContext)
+                return;
+            const { state } = this.audioContext;
+            if (state === 'suspended' || state === 'interrupted') {
+                const tag = 'audioContext.resume';
+                this.audioContext.resume().then(() => {
+                    this.tracer.trace(tag, this.audioContext?.state);
                     document.removeEventListener('click', this.resumeAudioContext);
+                }, (err) => {
+                    this.tracer.trace(`${tag}Error`, this.audioContext?.state);
+                    this.logger.warn(`Can't resume audio context`, err);
                 });
             }
         };
         this.callState = callState;
         this.speaker = speaker;
+        this.tracer = tracer;
     }
     setSfuClient(sfuClient) {
         this.sfuClient = sfuClient;
@@ -11868,6 +12035,37 @@ class SpeakerManager {
         this.state = new SpeakerState(call.tracer);
         this.setup();
     }
+    apply(settings) {
+        if (!isReactNative()) {
+            return;
+        }
+        /// Determines if the speaker should be enabled based on a priority hierarchy of
+        /// settings.
+        ///
+        /// The priority order is as follows:
+        /// 1. If video camera is set to be on by default, speaker is enabled
+        /// 2. If audio speaker is set to be on by default, speaker is enabled
+        /// 3. If the default audio device is set to speaker, speaker is enabled
+        ///
+        /// This ensures that the speaker state aligns with the most important user
+        /// preference or system requirement.
+        const speakerOnWithSettingsPriority = settings.video.camera_default_on ||
+            settings.audio.speaker_default_on ||
+            settings.audio.default_device ===
+                AudioSettingsRequestDefaultDeviceEnum.SPEAKER;
+        const defaultDevice = speakerOnWithSettingsPriority
+            ? AudioSettingsRequestDefaultDeviceEnum.SPEAKER
+            : AudioSettingsRequestDefaultDeviceEnum.EARPIECE;
+        if (this.defaultDevice !== defaultDevice) {
+            this.call.logger.debug('SpeakerManager: setting default device', {
+                defaultDevice,
+            });
+            this.defaultDevice = defaultDevice;
+            globalThis.streamRNVideoSDK?.callManager.setup({
+                defaultDevice,
+            });
+        }
+    }
     setup() {
         if (this.areSubscriptionsSetUp) {
             return;
@@ -11930,8 +12128,6 @@ class SpeakerManager {
     /**
      * Set the volume of a participant.
      *
-     * Note: This method is not supported in React Native.
-     *
      * @param sessionId the participant's session id.
      * @param volume a number between 0 and 1. Set it to `undefined` to use the default volume.
      */
@@ -12274,6 +12470,7 @@ class Call {
                 this.ringingSubject.next(false);
                 this.cancelAutoDrop();
                 this.clientStore.unregisterCall(this);
+                globalThis.streamRNVideoSDK?.callManager.stop();
                 this.camera.dispose();
                 this.microphone.dispose();
                 this.screenShare.dispose();
@@ -12606,6 +12803,7 @@ class Call {
             // re-apply them on later reconnections or server-side data fetches
             if (!this.deviceSettingsAppliedOnce && this.state.settings) {
                 await this.applyDeviceConfig(this.state.settings, true);
+                globalThis.streamRNVideoSDK?.callManager.start();
                 this.deviceSettingsAppliedOnce = true;
             }
             // We shouldn't persist the `ring` and `notify` state after joining the call
@@ -13397,14 +13595,22 @@ class Call {
         /**
          * Starts recording the call
          */
-        this.startRecording = async (request) => {
-            return this.streamClient.post(`${this.streamClientBasePath}/start_recording`, request ? request : {});
+        this.startRecording = async (dataOrType, type) => {
+            type = typeof dataOrType === 'string' ? dataOrType : type;
+            dataOrType = typeof dataOrType === 'string' ? undefined : dataOrType;
+            const endpoint = !type
+                ? `/start_recording`
+                : `/recordings/${encodeURIComponent(type)}/start`;
+            return this.streamClient.post(`${this.streamClientBasePath}${endpoint}`, dataOrType);
         };
         /**
          * Stops recording the call
          */
-        this.stopRecording = async () => {
-            return this.streamClient.post(`${this.streamClientBasePath}/stop_recording`, {});
+        this.stopRecording = async (type) => {
+            const endpoint = !type
+                ? `/stop_recording`
+                : `/recordings/${encodeURIComponent(type)}/stop`;
+            return this.streamClient.post(`${this.streamClientBasePath}${endpoint}`);
         };
         /**
          * Starts the transcription of the call.
@@ -13801,6 +14007,7 @@ class Call {
          * @internal
          */
         this.applyDeviceConfig = async (settings, publish) => {
+            this.speaker.apply(settings);
             await this.camera.apply(settings.video, publish).catch((err) => {
                 this.logger.warn('Camera init failed', err);
             });
@@ -13970,7 +14177,7 @@ class Call {
         this.microphone = new MicrophoneManager(this);
         this.speaker = new SpeakerManager(this);
         this.screenShare = new ScreenShareManager(this);
-        this.dynascaleManager = new DynascaleManager(this.state, this.speaker);
+        this.dynascaleManager = new DynascaleManager(this.state, this.speaker, this.tracer);
     }
     /**
      * A flag indicating whether the call is "ringing" type of call.
@@ -15114,7 +15321,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.40.3", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.41.1", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -15750,5 +15957,5 @@ const humanize = (n) => {
     return String(n);
 };
 
-export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, CreateDeviceRequestPushProviderEnum, DebounceType, DeviceManager, DeviceManagerState, DynascaleManager, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressSourceRequestFpsEnum, IngressVideoLayerRequestCodecEnum, LayoutSettingsRequestNameEnum, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RNSpeechDetector, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, 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, 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