@stream-io/video-client 1.15.6 → 1.16.0

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import 'webrtc-adapter';
 export * from './src/gen/coordinator';
-export * from './src/gen/shims';
 export * from './src/coordinator/connection/types';
 export * as SfuEvents from './src/gen/video/sfu/event/events';
 export * as SfuModels from './src/gen/video/sfu/models/models';

package/dist/index.es.js

@@ -9,8 +9,6 @@ import { parse } from 'sdp-transform';
 import { UAParser } from 'ua-parser-js';
 import https from 'https';
 
-/* tslint:disable */
-/* eslint-disable */
 /**
  * @export
  */
@@ -25,80 +23,6 @@ const AudioSettingsResponseDefaultDeviceEnum = {
     SPEAKER: 'speaker',
     EARPIECE: 'earpiece',
 };
-/**
- * @export
- */
-const BlockListOptionsBehaviorEnum = {
-    FLAG: 'flag',
-    BLOCK: 'block',
-    SHADOW_BLOCK: 'shadow_block',
-};
-/**
- * @export
- */
-const ChannelConfigWithInfoAutomodEnum = {
-    DISABLED: 'disabled',
-    SIMPLE: 'simple',
-    AI: 'AI',
-};
-/**
- * @export
- */
-const ChannelConfigWithInfoAutomodBehaviorEnum = {
-    FLAG: 'flag',
-    BLOCK: 'block',
-    SHADOW_BLOCK: 'shadow_block',
-};
-/**
- * @export
- */
-const ChannelConfigWithInfoBlocklistBehaviorEnum = {
-    FLAG: 'flag',
-    BLOCK: 'block',
-    SHADOW_BLOCK: 'shadow_block',
-};
-/**
- * All possibility of string to use
- * @export
- */
-const ChannelOwnCapability = {
-    BAN_CHANNEL_MEMBERS: 'ban-channel-members',
-    CAST_POLL_VOTE: 'cast-poll-vote',
-    CONNECT_EVENTS: 'connect-events',
-    CREATE_ATTACHMENT: 'create-attachment',
-    CREATE_CALL: 'create-call',
-    DELETE_ANY_MESSAGE: 'delete-any-message',
-    DELETE_CHANNEL: 'delete-channel',
-    DELETE_OWN_MESSAGE: 'delete-own-message',
-    FLAG_MESSAGE: 'flag-message',
-    FREEZE_CHANNEL: 'freeze-channel',
-    JOIN_CALL: 'join-call',
-    JOIN_CHANNEL: 'join-channel',
-    LEAVE_CHANNEL: 'leave-channel',
-    MUTE_CHANNEL: 'mute-channel',
-    PIN_MESSAGE: 'pin-message',
-    QUERY_POLL_VOTES: 'query-poll-votes',
-    QUOTE_MESSAGE: 'quote-message',
-    READ_EVENTS: 'read-events',
-    SEARCH_MESSAGES: 'search-messages',
-    SEND_CUSTOM_EVENTS: 'send-custom-events',
-    SEND_LINKS: 'send-links',
-    SEND_MESSAGE: 'send-message',
-    SEND_POLL: 'send-poll',
-    SEND_REACTION: 'send-reaction',
-    SEND_REPLY: 'send-reply',
-    SEND_TYPING_EVENTS: 'send-typing-events',
-    SET_CHANNEL_COOLDOWN: 'set-channel-cooldown',
-    SKIP_SLOW_MODE: 'skip-slow-mode',
-    SLOW_MODE: 'slow-mode',
-    TYPING_EVENTS: 'typing-events',
-    UPDATE_ANY_MESSAGE: 'update-any-message',
-    UPDATE_CHANNEL: 'update-channel',
-    UPDATE_CHANNEL_MEMBERS: 'update-channel-members',
-    UPDATE_OWN_MESSAGE: 'update-own-message',
-    UPDATE_THREAD: 'update-thread',
-    UPLOAD_FILE: 'upload-file',
-};
 /**
  * @export
  */
@@ -108,6 +32,16 @@ const CreateDeviceRequestPushProviderEnum = {
     HUAWEI: 'huawei',
     XIAOMI: 'xiaomi',
 };
+/**
+ * @export
+ */
+const LayoutSettingsRequestNameEnum = {
+    SPOTLIGHT: 'spotlight',
+    GRID: 'grid',
+    SINGLE_PARTICIPANT: 'single-participant',
+    MOBILE: 'mobile',
+    CUSTOM: 'custom',
+};
 /**
  * @export
  */
@@ -150,6 +84,36 @@ const OwnCapability = {
     UPDATE_CALL_PERMISSIONS: 'update-call-permissions',
     UPDATE_CALL_SETTINGS: 'update-call-settings',
 };
+/**
+ * @export
+ */
+const RTMPBroadcastRequestQualityEnum = {
+    _360P: '360p',
+    _480P: '480p',
+    _720P: '720p',
+    _1080P: '1080p',
+    _1440P: '1440p',
+    PORTRAIT_360X640: 'portrait-360x640',
+    PORTRAIT_480X854: 'portrait-480x854',
+    PORTRAIT_720X1280: 'portrait-720x1280',
+    PORTRAIT_1080X1920: 'portrait-1080x1920',
+    PORTRAIT_1440X2560: 'portrait-1440x2560',
+};
+/**
+ * @export
+ */
+const RTMPSettingsRequestQualityEnum = {
+    _360P: '360p',
+    _480P: '480p',
+    _720P: '720p',
+    _1080P: '1080p',
+    _1440P: '1440p',
+    PORTRAIT_360X640: 'portrait-360x640',
+    PORTRAIT_480X854: 'portrait-480x854',
+    PORTRAIT_720X1280: 'portrait-720x1280',
+    PORTRAIT_1080X1920: 'portrait-1080x1920',
+    PORTRAIT_1440X2560: 'portrait-1440x2560',
+};
 /**
  * @export
  */
@@ -181,6 +145,44 @@ const TranscriptionSettingsRequestClosedCaptionModeEnum = {
     DISABLED: 'disabled',
     AUTO_ON: 'auto-on',
 };
+/**
+ * @export
+ */
+const TranscriptionSettingsRequestLanguageEnum = {
+    AUTO: 'auto',
+    EN: 'en',
+    FR: 'fr',
+    ES: 'es',
+    DE: 'de',
+    IT: 'it',
+    NL: 'nl',
+    PT: 'pt',
+    PL: 'pl',
+    CA: 'ca',
+    CS: 'cs',
+    DA: 'da',
+    EL: 'el',
+    FI: 'fi',
+    ID: 'id',
+    JA: 'ja',
+    RU: 'ru',
+    SV: 'sv',
+    TA: 'ta',
+    TH: 'th',
+    TR: 'tr',
+    HU: 'hu',
+    RO: 'ro',
+    ZH: 'zh',
+    AR: 'ar',
+    TL: 'tl',
+    HE: 'he',
+    HI: 'hi',
+    HR: 'hr',
+    KO: 'ko',
+    MS: 'ms',
+    NO: 'no',
+    UK: 'uk',
+};
 /**
  * @export
  */
@@ -197,6 +199,44 @@ const TranscriptionSettingsResponseClosedCaptionModeEnum = {
     DISABLED: 'disabled',
     AUTO_ON: 'auto-on',
 };
+/**
+ * @export
+ */
+const TranscriptionSettingsResponseLanguageEnum = {
+    AUTO: 'auto',
+    EN: 'en',
+    FR: 'fr',
+    ES: 'es',
+    DE: 'de',
+    IT: 'it',
+    NL: 'nl',
+    PT: 'pt',
+    PL: 'pl',
+    CA: 'ca',
+    CS: 'cs',
+    DA: 'da',
+    EL: 'el',
+    FI: 'fi',
+    ID: 'id',
+    JA: 'ja',
+    RU: 'ru',
+    SV: 'sv',
+    TA: 'ta',
+    TH: 'th',
+    TR: 'tr',
+    HU: 'hu',
+    RO: 'ro',
+    ZH: 'zh',
+    AR: 'ar',
+    TL: 'tl',
+    HE: 'he',
+    HI: 'hi',
+    HR: 'hr',
+    KO: 'ko',
+    MS: 'ms',
+    NO: 'no',
+    UK: 'uk',
+};
 /**
  * @export
  */
@@ -4184,7 +4224,7 @@ const livestreamOrAudioRoomSortPreset = combineComparators(ifInvisibleBy(combine
  */
 const defaultEgress = {
     broadcasting: false,
-    hls: { playlist_url: '' },
+    hls: { playlist_url: '', status: '' },
     rtmps: [],
 };
 /**
@@ -4647,21 +4687,19 @@ class CallState {
             this.setCurrentValue(this.egressSubject, (egress = defaultEgress) => ({
                 ...egress,
                 broadcasting: false,
+                hls: {
+                    ...egress.hls,
+                    status: '',
+                },
             }));
         };
         this.updateFromHLSBroadcastingFailed = () => {
             this.setCurrentValue(this.egressSubject, (egress = defaultEgress) => ({
                 ...egress,
                 broadcasting: false,
-            }));
-        };
-        this.updateFromHLSBroadcastStarted = (event) => {
-            this.setCurrentValue(this.egressSubject, (egress = defaultEgress) => ({
-                ...egress,
-                broadcasting: true,
                 hls: {
                     ...egress.hls,
-                    playlist_url: event.hls_playlist_url,
+                    status: '',
                 },
             }));
         };
@@ -4872,21 +4910,16 @@ class CallState {
         this.captioning$ = duc(this.captioningSubject);
         this.eventHandlers = {
             // these events are not updating the call state:
-            'call.deleted': undefined,
             'call.permission_request': undefined,
             'call.recording_ready': undefined,
+            'call.rtmp_broadcast_failed': undefined,
+            'call.rtmp_broadcast_started': undefined,
+            'call.rtmp_broadcast_stopped': undefined,
             'call.transcription_ready': undefined,
             'call.user_muted': undefined,
             'connection.error': undefined,
             'connection.ok': undefined,
             'health.check': undefined,
-            'user.banned': undefined,
-            'user.deactivated': undefined,
-            'user.deleted': undefined,
-            'user.muted': undefined,
-            'user.presence.changed': undefined,
-            'user.reactivated': undefined,
-            'user.unbanned': undefined,
             'user.updated': undefined,
             custom: undefined,
             // events that update call state:
@@ -4903,12 +4936,15 @@ class CallState {
                 this.setCurrentValue(this.captioningSubject, false);
             },
             'call.created': (e) => this.updateFromCallResponse(e.call),
+            'call.deleted': (e) => this.updateFromCallResponse(e.call),
             'call.ended': (e) => {
                 this.updateFromCallResponse(e.call);
                 this.setCurrentValue(this.endedBySubject, e.user);
             },
             'call.hls_broadcasting_failed': this.updateFromHLSBroadcastingFailed,
-            'call.hls_broadcasting_started': this.updateFromHLSBroadcastStarted,
+            'call.hls_broadcasting_started': (e) => {
+                this.updateFromCallResponse(e.call);
+            },
             'call.hls_broadcasting_stopped': this.updateFromHLSBroadcastStopped,
             'call.live_started': (e) => this.updateFromCallResponse(e.call),
             'call.member_added': this.updateFromMemberAdded,
@@ -7357,7 +7393,7 @@ const aggregate = (stats) => {
     return report;
 };
 
-const version = "1.15.6";
+const version = "1.16.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -9338,7 +9374,7 @@ class MicrophoneManagerState extends InputMediaDeviceManagerState {
 }
 
 const DETECTION_FREQUENCY_IN_MS = 500;
-const AUDIO_LEVEL_THRESHOLD$1 = 150;
+const AUDIO_LEVEL_THRESHOLD = 150;
 const FFT_SIZE = 128;
 /**
  * Creates a new sound detector.
@@ -9349,7 +9385,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$1, fftSize = FFT_SIZE, destroyStreamOnStop = true, } = options;
+    const { detectionFrequencyInMs = DETECTION_FREQUENCY_IN_MS, audioLevelThreshold = AUDIO_LEVEL_THRESHOLD, fftSize = FFT_SIZE, destroyStreamOnStop = true, } = options;
     const audioContext = new AudioContext();
     const analyser = audioContext.createAnalyser();
     analyser.fftSize = fftSize;
@@ -9390,7 +9426,6 @@ const createSoundDetector = (audioStream, onSoundDetectedStateChanged, options =
     };
 };
 
-const AUDIO_LEVEL_THRESHOLD = 0.2;
 class RNSpeechDetector {
     constructor() {
         this.pc1 = new RTCPeerConnection({});
@@ -9399,7 +9434,7 @@ class RNSpeechDetector {
     /**
      * Starts the speech detection.
      */
-    async start() {
+    async start(onSoundDetectedStateChanged) {
         try {
             this.cleanupAudioStream();
             const audioStream = await navigator.mediaDevices.getUserMedia({
@@ -9412,6 +9447,14 @@ class RNSpeechDetector {
             this.pc2.addEventListener('icecandidate', async (e) => {
                 await this.pc1.addIceCandidate(e.candidate);
             });
+            this.pc2.addEventListener('track', (e) => {
+                e.streams[0].getTracks().forEach((track) => {
+                    // In RN, the remote track is automatically added to the audio output device
+                    // so we need to mute it to avoid hearing the audio back
+                    // @ts-ignore _setVolume is a private method in react-native-webrtc
+                    track._setVolume(0);
+                });
+            });
             audioStream
                 .getTracks()
                 .forEach((track) => this.pc1.addTrack(track, audioStream));
@@ -9421,12 +9464,16 @@ class RNSpeechDetector {
             const answer = await this.pc2.createAnswer();
             await this.pc1.setRemoteDescription(answer);
             await this.pc2.setLocalDescription(answer);
-            const audioTracks = audioStream.getAudioTracks();
-            // We need to mute the audio track for this temporary stream, or else you will hear yourself twice while in the call.
-            audioTracks.forEach((track) => (track.enabled = false));
+            const unsub = this.onSpeakingDetectedStateChange(onSoundDetectedStateChanged);
+            return () => {
+                unsub();
+                this.stop();
+            };
         }
         catch (error) {
-            console.error('Error connecting and negotiating between PeerConnections:', error);
+            const logger = getLogger(['RNSpeechDetector']);
+            logger('error', 'error handling permissions: ', error);
+            return () => { };
         }
     }
     /**
@@ -9436,40 +9483,85 @@ class RNSpeechDetector {
         this.pc1.close();
         this.pc2.close();
         this.cleanupAudioStream();
-        if (this.intervalId) {
-            clearInterval(this.intervalId);
-        }
     }
     /**
      * Public method that detects the audio levels and returns the status.
      */
     onSpeakingDetectedStateChange(onSoundDetectedStateChanged) {
-        this.intervalId = setInterval(async () => {
-            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' &&
-                stat.kind === 'audio');
-            if (audioMediaSourceStats) {
-                const { audioLevel } = audioMediaSourceStats;
-                if (audioLevel) {
-                    if (audioLevel >= AUDIO_LEVEL_THRESHOLD) {
-                        onSoundDetectedStateChanged({
-                            isSoundDetected: true,
-                            audioLevel,
-                        });
-                    }
-                    else {
-                        onSoundDetectedStateChanged({
-                            isSoundDetected: false,
-                            audioLevel: 0,
-                        });
+        const initialBaselineNoiseLevel = 0.13;
+        let baselineNoiseLevel = initialBaselineNoiseLevel;
+        let speechDetected = false;
+        let intervalId;
+        let speechTimer;
+        let silenceTimer;
+        let audioLevelHistory = []; // Store recent audio levels for smoother detection
+        const historyLength = 10;
+        const silenceThreshold = 1.1;
+        const resetThreshold = 0.9;
+        const speechTimeout = 500; // Speech is set to true after 500ms of audio detection
+        const silenceTimeout = 5000; // Reset baseline after 5 seconds of silence
+        const checkAudioLevel = async () => {
+            try {
+                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' &&
+                    stat.kind === 'audio');
+                if (audioMediaSourceStats) {
+                    const { audioLevel } = audioMediaSourceStats;
+                    if (audioLevel) {
+                        // Update audio level history (with max historyLength sized array)
+                        audioLevelHistory.push(audioLevel);
+                        if (audioLevelHistory.length > historyLength) {
+                            audioLevelHistory.shift();
+                        }
+                        // Calculate average audio level
+                        const avgAudioLevel = audioLevelHistory.reduce((a, b) => a + b, 0) /
+                            audioLevelHistory.length;
+                        // Update baseline (if necessary) based on silence detection
+                        if (avgAudioLevel < baselineNoiseLevel * silenceThreshold) {
+                            if (!silenceTimer) {
+                                silenceTimer = setTimeout(() => {
+                                    baselineNoiseLevel = Math.min(avgAudioLevel * resetThreshold, initialBaselineNoiseLevel);
+                                }, silenceTimeout);
+                            }
+                        }
+                        else {
+                            clearTimeout(silenceTimer);
+                            silenceTimer = undefined;
+                        }
+                        // Speech detection with hysteresis
+                        if (avgAudioLevel > baselineNoiseLevel * 1.5) {
+                            if (!speechDetected) {
+                                speechDetected = true;
+                                onSoundDetectedStateChanged({
+                                    isSoundDetected: true,
+                                    audioLevel,
+                                });
+                            }
+                            clearTimeout(speechTimer);
+                            speechTimer = setTimeout(() => {
+                                speechDetected = false;
+                                onSoundDetectedStateChanged({
+                                    isSoundDetected: false,
+                                    audioLevel: 0,
+                                });
+                            }, speechTimeout);
+                        }
                     }
                 }
             }
-        }, 1000);
+            catch (error) {
+                const logger = getLogger(['RNSpeechDetector']);
+                logger('error', 'error checking audio level from stats', error);
+            }
+        };
+        // Call checkAudioLevel periodically (every 100ms)
+        intervalId = setInterval(checkAudioLevel, 100);
         return () => {
-            clearInterval(this.intervalId);
+            clearInterval(intervalId);
+            clearTimeout(speechTimer);
+            clearTimeout(silenceTimer);
         };
     }
     cleanupAudioStream() {
@@ -9487,9 +9579,7 @@ class RNSpeechDetector {
 }
 
 class MicrophoneManager extends InputMediaDeviceManager {
-    constructor(call, disableMode = isReactNative()
-        ? 'disable-tracks'
-        : 'stop-tracks') {
+    constructor(call, disableMode = 'stop-tracks') {
         super(call, new MicrophoneManagerState(disableMode), TrackType.AUDIO);
         this.speakingWhileMutedNotificationEnabled = true;
         this.soundDetectorConcurrencyTag = Symbol('soundDetectorConcurrencyTag');
@@ -9670,13 +9760,11 @@ class MicrophoneManager extends InputMediaDeviceManager {
             await this.stopSpeakingWhileMutedDetection();
             if (isReactNative()) {
                 this.rnSpeechDetector = new RNSpeechDetector();
-                await this.rnSpeechDetector.start();
-                const unsubscribe = this.rnSpeechDetector?.onSpeakingDetectedStateChange((event) => {
+                const unsubscribe = await this.rnSpeechDetector.start((event) => {
                     this.state.setSpeakingWhileMuted(event.isSoundDetected);
                 });
                 this.soundDetectorCleanup = () => {
                     unsubscribe();
-                    this.rnSpeechDetector?.stop();
                     this.rnSpeechDetector = undefined;
                 };
             }
@@ -10359,6 +10447,12 @@ class Call {
         this.create = async (data) => {
             return this.getOrCreate(data);
         };
+        /**
+         * Deletes the call.
+         */
+        this.delete = async (data = {}) => {
+            return this.streamClient.post(`${this.streamClientBasePath}/delete`, data);
+        };
         /**
          * A shortcut for {@link Call.get} with `ring` parameter set to `true`.
          * Will send a `call.ring` event to the call members.
@@ -11369,8 +11463,8 @@ class Call {
         /**
          * Stops the livestreaming of the call.
          */
-        this.stopLive = async () => {
-            return this.streamClient.post(`${this.streamClientBasePath}/stop_live`, {});
+        this.stopLive = async (data = {}) => {
+            return this.streamClient.post(`${this.streamClientBasePath}/stop_live`, data);
         };
         /**
          * Starts the broadcasting of the call.
@@ -11384,6 +11478,24 @@ class Call {
         this.stopHLS = async () => {
             return this.streamClient.post(`${this.streamClientBasePath}/stop_broadcasting`, {});
         };
+        /**
+         * Starts the RTMP-out broadcasting of the call.
+         */
+        this.startRTMPBroadcasts = async (data) => {
+            return this.streamClient.post(`${this.streamClientBasePath}/rtmp_broadcasts`, data);
+        };
+        /**
+         * Stops all RTMP-out broadcasting of the call.
+         */
+        this.stopAllRTMPBroadcasts = async () => {
+            return this.streamClient.post(`${this.streamClientBasePath}/rtmp_broadcasts/stop`);
+        };
+        /**
+         * Stops the RTMP-out broadcasting of the call specified by it's name.
+         */
+        this.stopRTMPBroadcast = async (name) => {
+            return this.streamClient.post(`${this.streamClientBasePath}/rtmp_broadcasts/${name}/stop`);
+        };
         /**
          * Updates the call settings or custom data.
          *
@@ -12862,7 +12974,7 @@ class StreamClient {
             return await this.wsConnection.connect(this.defaultWSTimeout);
         };
         this.getUserAgent = () => {
-            const version = "1.15.6";
+            const version = "1.16.0";
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };
@@ -13371,5 +13483,5 @@ class StreamVideoClient {
 }
 StreamVideoClient._instanceMap = new Map();
 
-export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, BlockListOptionsBehaviorEnum, browsers as Browsers, Call, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, ChannelConfigWithInfoAutomodBehaviorEnum, ChannelConfigWithInfoAutomodEnum, ChannelConfigWithInfoBlocklistBehaviorEnum, ChannelOwnCapability, CreateDeviceRequestPushProviderEnum, DebounceType, DynascaleManager, ErrorFromResponse, InputMediaDeviceManager, InputMediaDeviceManagerState, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, models as SfuModels, SpeakerManager, SpeakerState, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseModeEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceInfo, getDeviceState, getLogLevel, getLogger, getOSInfo, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio, hasScreenShare, hasScreenShareAudio, hasVideo, isPinned, livestreamOrAudioRoomSortPreset, logLevels, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishingAudio, publishingVideo, reactionType, role, screenSharing, setDeviceInfo, setLogLevel, setLogger, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking };
+export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, CreateDeviceRequestPushProviderEnum, DebounceType, DynascaleManager, ErrorFromResponse, InputMediaDeviceManager, InputMediaDeviceManagerState, LayoutSettingsRequestNameEnum, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, models as SfuModels, SpeakerManager, SpeakerState, 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, getDeviceInfo, getDeviceState, getLogLevel, getLogger, getOSInfo, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio, hasScreenShare, hasScreenShareAudio, hasVideo, isPinned, livestreamOrAudioRoomSortPreset, logLevels, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishingAudio, publishingVideo, reactionType, role, screenSharing, setDeviceInfo, setLogLevel, setLogger, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking };
 //# sourceMappingURL=index.es.js.map