@stream-io/video-client 1.40.3 → 1.41.1

package/dist/index.cjs.js

@@ -46,6 +46,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
  */
@@ -81,6 +113,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
  */
@@ -146,11 +194,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',
@@ -188,6 +240,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
  */
@@ -4003,15 +4071,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 = sdpTransform.parse(offerSdp);
     const targetCodecs = new Set(['av1', 'vp9', 'h264']);
     for (const media of parsedSdp.media) {
@@ -4022,14 +4093,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 sdpTransform.write(parsedSdp);
@@ -4959,6 +5043,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.
  */
@@ -4988,6 +5076,8 @@ class CallState {
         this.egressSubject = new rxjs.BehaviorSubject(undefined);
         this.ingressSubject = new rxjs.BehaviorSubject(undefined);
         this.recordingSubject = new rxjs.BehaviorSubject(false);
+        this.individualRecordingSubject = new rxjs.BehaviorSubject(false);
+        this.rawRecordingSubject = new rxjs.BehaviorSubject(false);
         this.sessionSubject = new rxjs.BehaviorSubject(undefined);
         this.settingsSubject = new rxjs.BehaviorSubject(undefined);
         this.transcribingSubject = new rxjs.BehaviorSubject(false);
@@ -5414,7 +5504,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);
@@ -5490,6 +5583,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.
@@ -5724,6 +5832,8 @@ class CallState {
         }), rxjs.distinctUntilChanged(isShallowEqual), rxjs.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 = {
@@ -5790,9 +5900,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),
@@ -5975,11 +6091,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.
      */
@@ -6080,7 +6208,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,
@@ -7428,10 +7556,6 @@ class TransceiverCache {
     }
 }
 
-const ensureExhausted = (x, message) => {
-    videoLoggerSystem.getLogger('helpers').warn(message, x);
-};
-
 const trackTypeToParticipantStreamKey = (trackType) => {
     switch (trackType) {
         case TrackType.SCREEN_SHARE:
@@ -7912,7 +8036,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;
@@ -9268,12 +9392,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 rxjs.BehaviorSubject({});
         this.videoTrackSubscriptionOverrides$ = this.videoTrackSubscriptionOverridesSubject.asObservable();
@@ -9313,6 +9438,10 @@ class DynascaleManager {
             }
         };
         this.setVideoTrackSubscriptionOverrides = (override, sessionIds) => {
+            this.tracer.trace('setVideoTrackSubscriptionOverrides', [
+                override,
+                sessionIds,
+            ]);
             if (!sessionIds) {
                 return setCurrentValue(this.videoTrackSubscriptionOverridesSubject, override ? { [globalOverrideKey]: override } : {});
             }
@@ -9394,6 +9523,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
@@ -9609,6 +9750,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);
                         });
                     }
@@ -9643,32 +9785,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;
@@ -11888,6 +12055,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;
@@ -11950,8 +12148,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.
      */
@@ -12294,6 +12490,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();
@@ -12626,6 +12823,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
@@ -13417,14 +13615,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.
@@ -13821,6 +14027,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);
             });
@@ -13990,7 +14197,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.
@@ -15132,7 +15339,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}`),
@@ -15780,6 +15987,10 @@ exports.AudioSettingsRequestDefaultDeviceEnum = AudioSettingsRequestDefaultDevic
 exports.AudioSettingsResponseDefaultDeviceEnum = AudioSettingsResponseDefaultDeviceEnum;
 exports.Browsers = browsers;
 exports.Call = Call;
+exports.CallRecordingFailedEventRecordingTypeEnum = CallRecordingFailedEventRecordingTypeEnum;
+exports.CallRecordingReadyEventRecordingTypeEnum = CallRecordingReadyEventRecordingTypeEnum;
+exports.CallRecordingStartedEventRecordingTypeEnum = CallRecordingStartedEventRecordingTypeEnum;
+exports.CallRecordingStoppedEventRecordingTypeEnum = CallRecordingStoppedEventRecordingTypeEnum;
 exports.CallState = CallState;
 exports.CallType = CallType;
 exports.CallTypes = CallTypes;
@@ -15793,6 +16004,8 @@ exports.ErrorFromResponse = ErrorFromResponse;
 exports.FrameRecordingSettingsRequestModeEnum = FrameRecordingSettingsRequestModeEnum;
 exports.FrameRecordingSettingsRequestQualityEnum = FrameRecordingSettingsRequestQualityEnum;
 exports.FrameRecordingSettingsResponseModeEnum = FrameRecordingSettingsResponseModeEnum;
+exports.IndividualRecordingSettingsRequestModeEnum = IndividualRecordingSettingsRequestModeEnum;
+exports.IndividualRecordingSettingsResponseModeEnum = IndividualRecordingSettingsResponseModeEnum;
 exports.IngressAudioEncodingOptionsRequestChannelsEnum = IngressAudioEncodingOptionsRequestChannelsEnum;
 exports.IngressSourceRequestFpsEnum = IngressSourceRequestFpsEnum;
 exports.IngressVideoLayerRequestCodecEnum = IngressVideoLayerRequestCodecEnum;
@@ -15804,6 +16017,8 @@ exports.OwnCapability = OwnCapability;
 exports.RNSpeechDetector = RNSpeechDetector;
 exports.RTMPBroadcastRequestQualityEnum = RTMPBroadcastRequestQualityEnum;
 exports.RTMPSettingsRequestQualityEnum = RTMPSettingsRequestQualityEnum;
+exports.RawRecordingSettingsRequestModeEnum = RawRecordingSettingsRequestModeEnum;
+exports.RawRecordingSettingsResponseModeEnum = RawRecordingSettingsResponseModeEnum;
 exports.RecordSettingsRequestModeEnum = RecordSettingsRequestModeEnum;
 exports.RecordSettingsRequestQualityEnum = RecordSettingsRequestQualityEnum;
 exports.RxUtils = rxUtils;