@stream-io/video-client 0.2.3 → 0.3.1

package/dist/index.browser.es.js

@@ -4,7 +4,7 @@ import { ServiceType, stackIntercept } from '@protobuf-ts/runtime-rpc';
 import axios, { AxiosHeaders } from 'axios';
 export { AxiosError } from 'axios';
 import { TwirpFetchTransport } from '@protobuf-ts/twirp-transport';
-import { ReplaySubject, BehaviorSubject, takeWhile, filter, pairwise, tap, debounce, timer, map as map$2, Observable, debounceTime, concatMap, from, shareReplay, merge, combineLatest } from 'rxjs';
+import { ReplaySubject, BehaviorSubject, distinctUntilChanged as distinctUntilChanged$1, Observable, debounceTime, concatMap, from, shareReplay, merge, map as map$2, combineLatest, filter, pairwise, takeWhile, tap, debounce, timer } from 'rxjs';
 import * as SDP from 'sdp-transform';
 import WebSocket from 'isomorphic-ws';
 import { take, map as map$1, distinctUntilChanged } from 'rxjs/operators';
@@ -6520,8 +6520,8 @@ class Publisher {
                 track.removeEventListener('ended', handleTrackEnded);
             });
             if (!transceiver) {
-                const metadata = this.state.metadata;
-                const targetResolution = metadata === null || metadata === void 0 ? void 0 : metadata.settings.video.target_resolution;
+                const { settings } = this.state;
+                const targetResolution = settings === null || settings === void 0 ? void 0 : settings.video.target_resolution;
                 const videoEncodings = trackType === TrackType.VIDEO
                     ? findOptimalVideoLayers(track, targetResolution)
                     : undefined;
@@ -6799,8 +6799,8 @@ class Publisher {
                 }
                 return String(media.mid);
             };
-            const metadata = this.state.metadata;
-            const targetResolution = metadata === null || metadata === void 0 ? void 0 : metadata.settings.video.target_resolution;
+            const { settings } = this.state;
+            const targetResolution = settings === null || settings === void 0 ? void 0 : settings.video.target_resolution;
             return this.pc
                 .getTransceivers()
                 .filter((t) => t.direction === 'sendonly' && t.sender.track)
@@ -6893,7 +6893,6 @@ class Publisher {
         this.pc = this.createPeerConnection(connectionConfig);
         this.sfuClient = sfuClient;
         this.state = state;
-        this.dispatcher = dispatcher;
         this.isDtxEnabled = isDtxEnabled;
         this.isRedEnabled = isRedEnabled;
         this.preferredVideoCodec = preferredVideoCodec;
@@ -7521,17 +7520,6 @@ const retryable = (rpc, logger) => __awaiter(void 0, void 0, void 0, function* (
     return rpcCallResult;
 });
 
-/**
- * Watches for `call.live_started` events.
- */
-const watchCallLiveStarted = (state) => {
-    return function onCallLiveStarted(event) {
-        if (event.type !== 'call.live_started')
-            return;
-        state.setMetadata((metadata) => (Object.assign(Object.assign({}, metadata), { backstage: false })));
-    };
-};
-
 /**
  * Gets the current value of an observable, or undefined if the observable has
  * not emitted a value yet.
@@ -7974,71 +7962,29 @@ class CallState {
      *
      */
     constructor() {
-        /**
-         * The raw call metadata object, as defined on the backend.
-         *
-         * @internal
-         */
-        this.metadataSubject = new BehaviorSubject(undefined);
-        /**
-         * The list of members of the current call.
-         *
-         * @internal
-         */
+        this.backstageSubject = new BehaviorSubject(false);
+        this.blockedUserIdsSubject = new BehaviorSubject([]);
+        this.createdAtSubject = new BehaviorSubject(new Date());
+        this.endedAtSubject = new BehaviorSubject(undefined);
+        this.startsAtSubject = new BehaviorSubject(undefined);
+        this.updatedAtSubject = new BehaviorSubject(new Date());
+        this.createdBySubject = new BehaviorSubject(undefined);
+        this.customSubject = new BehaviorSubject({});
+        this.egressSubject = new BehaviorSubject(undefined);
+        this.ingressSubject = new BehaviorSubject(undefined);
+        this.recordingSubject = new BehaviorSubject(false);
+        this.sessionSubject = new BehaviorSubject(undefined);
+        this.settingsSubject = new BehaviorSubject(undefined);
+        this.transcribingSubject = new BehaviorSubject(false);
+        this.endedBySubject = new BehaviorSubject(undefined);
         this.membersSubject = new BehaviorSubject([]);
-        /**
-         * The list of capabilities of the current user.
-         *
-         * @private
-         */
         this.ownCapabilitiesSubject = new BehaviorSubject([]);
-        /**
-         * The calling state.
-         *
-         * @internal
-         */
         this.callingStateSubject = new BehaviorSubject(CallingState.UNKNOWN);
-        /**
-         * The time the call session actually started.
-         *
-         * @internal
-         */
         this.startedAtSubject = new BehaviorSubject(undefined);
-        /**
-         * The server-side counted number of participants connected to the current call.
-         * This number includes the anonymous participants as well.
-         *
-         * @internal
-         */
         this.participantCountSubject = new BehaviorSubject(0);
-        /**
-         * The server-side counted number of anonymous participants connected to the current call.
-         * This number excludes the regular participants.
-         *
-         * @internal
-         */
         this.anonymousParticipantCountSubject = new BehaviorSubject(0);
-        /**
-         * All participants of the current call (including the logged-in user).
-         *
-         * @internal
-         */
         this.participantsSubject = new BehaviorSubject([]);
-        /**
-         * The latest stats report of the current call.
-         * When stats gathering is enabled, this observable will emit a new value
-         * at a regular (configurable) interval.
-         *
-         * Consumers of this observable can implement their own batching logic
-         * in case they want to show historical stat data.
-         *
-         * @internal
-         */
         this.callStatsReportSubject = new BehaviorSubject(undefined);
-        /**
-         * Emits a list of details about recordings performed for the current call.
-         */
-        this.callRecordingListSubject = new BehaviorSubject([]);
         /**
          * A list of comparators that are used to sort the participants.
          *
@@ -8121,15 +8067,6 @@ class CallState {
         this.setCallingState = (state) => {
             return this.setCurrentValue(this.callingStateSubject, state);
         };
-        /**
-         * Sets the list of call recordings.
-         *
-         * @internal
-         * @param recordings the list of call recordings.
-         */
-        this.setCallRecordingsList = (recordings) => {
-            return this.setCurrentValue(this.callRecordingListSubject, recordings);
-        };
         /**
          * Sets the call stats report.
          *
@@ -8139,16 +8076,6 @@ class CallState {
         this.setCallStatsReport = (report) => {
             return this.setCurrentValue(this.callStatsReportSubject, report);
         };
-        /**
-         * Sets the metadata of the current call.
-         *
-         * @internal
-         *
-         * @param metadata the metadata to set.
-         */
-        this.setMetadata = (metadata) => {
-            return this.setCurrentValue(this.metadataSubject, metadata);
-        };
         /**
          * Sets the members of the current call.
          *
@@ -8247,6 +8174,19 @@ class CallState {
                 return p;
             }));
         };
+        /**
+         * Updates the call state with the data received from the server.
+         *
+         * @internal
+         *
+         * @param event the video event that our backend sent us.
+         */
+        this.updateFromEvent = (event) => {
+            const update = this.eventHandlers[event.type];
+            if (update) {
+                update(event);
+            }
+        };
         /**
          * Updates the participant pinned state with server side pinning data.
          *
@@ -8275,25 +8215,174 @@ class CallState {
                 return participant;
             }));
         };
-        this.logger = getLogger(['call-state']);
+        /**
+         * Updates the call state with the data received from the server.
+         *
+         * @internal
+         *
+         * @param call the call response from the server.
+         */
+        this.updateFromCallResponse = (call) => {
+            this.setCurrentValue(this.backstageSubject, call.backstage);
+            this.setCurrentValue(this.blockedUserIdsSubject, call.blocked_user_ids);
+            this.setCurrentValue(this.createdAtSubject, new Date(call.created_at));
+            this.setCurrentValue(this.updatedAtSubject, new Date(call.updated_at));
+            this.setCurrentValue(this.startsAtSubject, call.starts_at ? new Date(call.starts_at) : undefined);
+            this.setCurrentValue(this.endedAtSubject, call.ended_at ? new Date(call.ended_at) : undefined);
+            this.setCurrentValue(this.createdBySubject, call.created_by);
+            this.setCurrentValue(this.customSubject, call.custom);
+            this.setCurrentValue(this.egressSubject, call.egress);
+            this.setCurrentValue(this.ingressSubject, call.ingress);
+            this.setCurrentValue(this.recordingSubject, call.recording);
+            this.setCurrentValue(this.sessionSubject, call.session);
+            this.setCurrentValue(this.settingsSubject, call.settings);
+            this.setCurrentValue(this.transcribingSubject, call.transcribing);
+        };
+        this.updateFromMemberRemoved = (event) => {
+            this.setCurrentValue(this.membersSubject, (members) => members.filter((m) => event.members.indexOf(m.user_id) === -1));
+        };
+        this.updateFromMemberAdded = (event) => {
+            this.setCurrentValue(this.membersSubject, (members) => [
+                ...members,
+                ...event.members,
+            ]);
+        };
+        this.updateFromBroadcastStopped = () => {
+            this.setCurrentValue(this.egressSubject, (egress) => (Object.assign(Object.assign({}, egress), { broadcasting: false })));
+        };
+        this.updateFromBroadcastStarted = (event) => {
+            this.setCurrentValue(this.egressSubject, (egress) => (Object.assign(Object.assign({}, egress), { broadcasting: true, hls: Object.assign(Object.assign({}, egress.hls), { playlist_url: event.hls_playlist_url }) })));
+        };
+        this.updateFromSessionParticipantLeft = (event) => {
+            this.setCurrentValue(this.sessionSubject, (session) => {
+                if (!session) {
+                    this.logger('warn', `Received call.session_participant_left event but no session is available.`, event);
+                    return session;
+                }
+                const { participants, participants_count_by_role } = session;
+                const { user, user_session_id } = event.participant;
+                return Object.assign(Object.assign({}, session), { participants: participants.filter((p) => p.user_session_id !== user_session_id), participants_count_by_role: Object.assign(Object.assign({}, participants_count_by_role), { [user.role]: Math.max(0, (participants_count_by_role[user.role] || 0) - 1) }) });
+            });
+        };
+        this.updateFromSessionParticipantJoined = (event) => {
+            this.setCurrentValue(this.sessionSubject, (session) => {
+                if (!session) {
+                    this.logger('warn', `Received call.session_participant_joined event but no session is available.`, event);
+                    return session;
+                }
+                const { participants, participants_count_by_role } = session;
+                const { user } = event.participant;
+                return Object.assign(Object.assign({}, session), { participants: [...participants, event.participant], participants_count_by_role: Object.assign(Object.assign({}, participants_count_by_role), { [user.role]: (participants_count_by_role[user.role] || 0) + 1 }) });
+            });
+        };
+        this.updateMembers = (event) => {
+            this.setCurrentValue(this.membersSubject, (members) => members.map((member) => {
+                const memberUpdate = event.members.find((m) => m.user_id === member.user_id);
+                return memberUpdate ? memberUpdate : member;
+            }));
+        };
+        this.updateParticipantReaction = (event) => {
+            const { user, custom, type, emoji_code } = event.reaction;
+            this.setParticipants((participants) => {
+                return participants.map((p) => {
+                    // skip if the reaction is not for this participant
+                    if (p.userId !== user.id)
+                        return p;
+                    // update the participant with the new reaction
+                    return Object.assign(Object.assign({}, p), { reaction: {
+                            type,
+                            emoji_code,
+                            custom,
+                        } });
+                });
+            });
+        };
+        this.unblockUser = (event) => {
+            this.setCurrentValue(this.blockedUserIdsSubject, (current) => {
+                if (!current)
+                    return current;
+                return current.filter((id) => id !== event.user.id);
+            });
+        };
+        this.blockUser = (event) => {
+            this.setCurrentValue(this.blockedUserIdsSubject, (current) => [
+                ...(current || []),
+                event.user.id,
+            ]);
+        };
+        this.updateOwnCapabilities = (event) => {
+            var _a;
+            if (event.user.id === ((_a = this.localParticipant) === null || _a === void 0 ? void 0 : _a.userId)) {
+                this.setCurrentValue(this.ownCapabilitiesSubject, event.own_capabilities);
+            }
+        };
+        this.logger = getLogger(['CallState']);
         this.participants$ = this.participantsSubject.pipe(map$1((ps) => ps.sort(this.sortParticipantsBy)));
         this.localParticipant$ = this.participants$.pipe(map$1((participants) => participants.find(isStreamVideoLocalParticipant)));
         this.remoteParticipants$ = this.participants$.pipe(map$1((participants) => participants.filter((p) => !p.isLocalParticipant)));
         this.pinnedParticipants$ = this.participants$.pipe(map$1((participants) => participants.filter((p) => !!p.pin)));
         this.dominantSpeaker$ = this.participants$.pipe(map$1((participants) => participants.find((p) => p.isDominantSpeaker)));
-        this.hasOngoingScreenShare$ = this.participants$.pipe(map$1((participants) => {
-            return participants.some((p) => p.publishedTracks.includes(TrackType.SCREEN_SHARE));
-        }), distinctUntilChanged());
+        this.hasOngoingScreenShare$ = this.participants$.pipe(map$1((participants) => participants.some((p) => p.publishedTracks.includes(TrackType.SCREEN_SHARE))), distinctUntilChanged());
         this.startedAt$ = this.startedAtSubject.asObservable();
         this.participantCount$ = this.participantCountSubject.asObservable();
         this.anonymousParticipantCount$ =
             this.anonymousParticipantCountSubject.asObservable();
         this.callStatsReport$ = this.callStatsReportSubject.asObservable();
-        this.callRecordingList$ = this.callRecordingListSubject.asObservable();
-        this.metadata$ = this.metadataSubject.asObservable();
         this.members$ = this.membersSubject.asObservable();
         this.ownCapabilities$ = this.ownCapabilitiesSubject.asObservable();
         this.callingState$ = this.callingStateSubject.asObservable();
+        this.backstage$ = this.backstageSubject.asObservable();
+        this.blockedUserIds$ = this.blockedUserIdsSubject.asObservable();
+        this.createdAt$ = this.createdAtSubject.asObservable();
+        this.endedAt$ = this.endedAtSubject.asObservable();
+        this.startsAt$ = this.startsAtSubject.asObservable();
+        this.updatedAt$ = this.updatedAtSubject.asObservable();
+        this.createdBy$ = this.createdBySubject.asObservable();
+        this.custom$ = this.customSubject.asObservable();
+        this.egress$ = this.egressSubject.asObservable();
+        this.ingress$ = this.ingressSubject.asObservable();
+        this.recording$ = this.recordingSubject.asObservable();
+        this.session$ = this.sessionSubject.asObservable();
+        this.settings$ = this.settingsSubject.asObservable();
+        this.transcribing$ = this.transcribingSubject.asObservable();
+        this.endedBy$ = this.endedBySubject.asObservable();
+        this.eventHandlers = {
+            // these events are not updating the call state:
+            'call.permission_request': undefined,
+            'call.user_muted': undefined,
+            'connection.error': undefined,
+            'connection.ok': undefined,
+            'health.check': undefined,
+            custom: undefined,
+            // events that update call state:
+            'call.accepted': (e) => this.updateFromCallResponse(e.call),
+            'call.created': (e) => this.updateFromCallResponse(e.call),
+            'call.notification': (e) => this.updateFromCallResponse(e.call),
+            'call.rejected': (e) => this.updateFromCallResponse(e.call),
+            'call.ring': (e) => this.updateFromCallResponse(e.call),
+            'call.live_started': (e) => this.updateFromCallResponse(e.call),
+            'call.updated': (e) => this.updateFromCallResponse(e.call),
+            'call.session_started': (e) => this.updateFromCallResponse(e.call),
+            'call.session_ended': (e) => this.updateFromCallResponse(e.call),
+            'call.ended': (e) => {
+                this.updateFromCallResponse(e.call);
+                this.setCurrentValue(this.endedBySubject, e.user);
+            },
+            'call.recording_started': () => this.setCurrentValue(this.recordingSubject, true),
+            'call.recording_stopped': () => this.setCurrentValue(this.recordingSubject, false),
+            'call.broadcasting_started': this.updateFromBroadcastStarted,
+            'call.broadcasting_stopped': this.updateFromBroadcastStopped,
+            'call.session_participant_joined': this.updateFromSessionParticipantJoined,
+            'call.session_participant_left': this.updateFromSessionParticipantLeft,
+            'call.blocked_user': this.blockUser,
+            'call.unblocked_user': this.unblockUser,
+            'call.permissions_updated': this.updateOwnCapabilities,
+            'call.member_added': this.updateFromMemberAdded,
+            'call.member_removed': this.updateFromMemberRemoved,
+            'call.member_updated': this.updateMembers,
+            'call.member_updated_permission': this.updateMembers,
+            'call.reaction_new': this.updateParticipantReaction,
+        };
     }
     /**
      * The server-side counted number of participants connected to the current call.
@@ -8358,24 +8447,12 @@ class CallState {
     get callingState() {
         return this.getCurrentValue(this.callingState$);
     }
-    /**
-     * The list of call recordings.
-     */
-    get callRecordingsList() {
-        return this.getCurrentValue(this.callRecordingList$);
-    }
     /**
      * The call stats report.
      */
     get callStatsReport() {
         return this.getCurrentValue(this.callStatsReport$);
     }
-    /**
-     * The metadata of the current call.
-     */
-    get metadata() {
-        return this.getCurrentValue(this.metadata$);
-    }
     /**
      * The members of the current call.
      */
@@ -8388,6 +8465,96 @@ class CallState {
     get ownCapabilities() {
         return this.getCurrentValue(this.ownCapabilities$);
     }
+    /**
+     * The backstage state.
+     */
+    get backstage() {
+        return this.getCurrentValue(this.backstage$);
+    }
+    /**
+     * Will provide the list of blocked user IDs.
+     */
+    get blockedUserIds() {
+        return this.getCurrentValue(this.blockedUserIds$);
+    }
+    /**
+     * Will provide the time when this call has been created.
+     */
+    get createdAt() {
+        return this.getCurrentValue(this.createdAt$);
+    }
+    /**
+     * Will provide the time when this call has been ended.
+     */
+    get endedAt() {
+        return this.getCurrentValue(this.endedAt$);
+    }
+    /**
+     * Will provide the time when this call has been scheduled to start.
+     */
+    get startsAt() {
+        return this.getCurrentValue(this.startsAt$);
+    }
+    /**
+     * Will provide the time when this call has been updated.
+     */
+    get updatedAt() {
+        return this.getCurrentValue(this.updatedAt$);
+    }
+    /**
+     * Will provide the user who created this call.
+     */
+    get createdBy() {
+        return this.getCurrentValue(this.createdBy$);
+    }
+    /**
+     * Will provide the custom data of this call.
+     */
+    get custom() {
+        return this.getCurrentValue(this.custom$);
+    }
+    /**
+     * Will provide the egress data of this call.
+     */
+    get egress() {
+        return this.getCurrentValue(this.egress$);
+    }
+    /**
+     * Will provide the ingress data of this call.
+     */
+    get ingress() {
+        return this.getCurrentValue(this.ingress$);
+    }
+    /**
+     * Will provide the recording state of this call.
+     */
+    get recording() {
+        return this.getCurrentValue(this.recording$);
+    }
+    /**
+     * Will provide the session data of this call.
+     */
+    get session() {
+        return this.getCurrentValue(this.session$);
+    }
+    /**
+     * Will provide the settings of this call.
+     */
+    get settings() {
+        return this.getCurrentValue(this.settings$);
+    }
+    /**
+     * Will provide the transcribing state of this call.
+     */
+    get transcribing() {
+        return this.getCurrentValue(this.transcribing$);
+    }
+    /**
+     * Will provide the user who ended this call.
+     */
+    get endedBy() {
+        return this.getCurrentValue(this.endedBy$);
+    }
 }
 
 /**
@@ -8459,40 +8626,16 @@ const watchCallEnded = (call) => {
         return __awaiter(this, void 0, void 0, function* () {
             if (event.type !== 'call.ended')
                 return;
-            if (call.state.callingState === CallingState.RINGING ||
-                call.state.callingState === CallingState.JOINED ||
-                call.state.callingState === CallingState.JOINING) {
-                call.state.setMetadata(event.call);
+            const { callingState } = call.state;
+            if (callingState === CallingState.RINGING ||
+                callingState === CallingState.JOINED ||
+                callingState === CallingState.JOINING) {
                 yield call.leave();
             }
         });
     };
 };
-/**
- * An event handler which listens to `call.updated` events
- * and updates the given call state accordingly.
- */
-const watchCallUpdated = (state) => {
-    return function onCallUpdated(event) {
-        if (event.type !== 'call.updated')
-            return;
-        state.setMetadata(event.call);
-    };
-};
 
-/**
- * Event handler that watches for `call.permissions_updated` events
- */
-const watchCallPermissionsUpdated = (state) => {
-    return function onCallPermissionsUpdated(event) {
-        if (event.type !== 'call.permissions_updated')
-            return;
-        const { localParticipant } = state;
-        if (event.user.id === (localParticipant === null || localParticipant === void 0 ? void 0 : localParticipant.userId)) {
-            state.setOwnCapabilities(event.own_capabilities);
-        }
-    };
-};
 /**
  * Event handler that watches for `callGrantsUpdated` events.
  *
@@ -8606,57 +8749,6 @@ const watchPinsUpdated = (state) => {
     };
 };
 
-/**
- * Watches for `call.member_added` events.
- */
-const watchCallMemberAdded = (state) => {
-    return function onCallMemberAdded(event) {
-        if (event.type !== 'call.member_added')
-            return;
-        state.setMembers((members) => [...members, ...event.members]);
-    };
-};
-/**
- * Watches for `call.member_removed` events.
- */
-const watchCallMemberRemoved = (state) => {
-    return function onCallMemberRemoved(event) {
-        if (event.type !== 'call.member_removed')
-            return;
-        state.setMembers((members) => members.filter((m) => event.members.indexOf(m.user_id) === -1));
-    };
-};
-/**
- * Watches for `call.member_updated_permission` events.
- */
-const watchCallMemberUpdatedPermission = (state) => {
-    return function onCallMemberUpdated(event) {
-        if (event.type !== 'call.member_updated_permission')
-            return;
-        state.setMembers((members) => members.map((member) => {
-            const memberUpdate = event.members.find((m) => m.user_id === member.user_id);
-            if (memberUpdate) {
-                member.user.role = memberUpdate.role;
-                member = Object.assign({}, member);
-            }
-            return member;
-        }));
-    };
-};
-/**
- * Watches for `call.member_updated` events.
- */
-const watchCallMemberUpdated = (state) => {
-    return function onCallMemberUpdated(event) {
-        if (event.type !== 'call.member_updated')
-            return;
-        state.setMembers((members) => members.map((member) => {
-            const memberUpdate = event.members.find((m) => m.user_id === member.user_id);
-            return memberUpdate ? memberUpdate : member;
-        }));
-    };
-};
-
 /**
  * An event responder which handles the `participantJoined` event.
  */
@@ -8738,74 +8830,6 @@ const watchTrackUnpublished = (state) => {
 };
 const unique = (v, i, arr) => arr.indexOf(v) === i;
 
-/**
- * Watches the delivery of CallReactionEvent.
- *
- * @param state the state store to update.
- */
-const watchNewReactions = (state) => {
-    return function onNewReactions(event) {
-        if (event.type !== 'call.reaction_new')
-            return;
-        const { reaction } = event;
-        const { user, custom, type, emoji_code } = reaction;
-        state.setParticipants((participants) => {
-            return participants.map((p) => {
-                // skip if the reaction is not for this participant
-                if (p.userId !== user.id)
-                    return p;
-                // update the participant with the new reaction
-                return Object.assign(Object.assign({}, p), { reaction: {
-                        type,
-                        emoji_code,
-                        custom,
-                    } });
-            });
-        });
-    };
-};
-
-/**
- * Watches for `call.recording_started` events.
- */
-const watchCallRecordingStarted = (state) => {
-    return function onCallRecordingStarted(event) {
-        if (event.type !== 'call.recording_started')
-            return;
-        state.setMetadata((metadata) => (Object.assign(Object.assign({}, metadata), { recording: true })));
-    };
-};
-/**
- * Watches for `call.recording_stopped` events.
- */
-const watchCallRecordingStopped = (state) => {
-    return function onCallRecordingStopped(event) {
-        if (event.type !== 'call.recording_stopped')
-            return;
-        state.setMetadata((metadata) => (Object.assign(Object.assign({}, metadata), { recording: false })));
-    };
-};
-/**
- * Watches for `call.broadcasting_started` events.
- */
-const watchCallBroadcastingStarted = (state) => {
-    return function onCallBroadcastingStarted(event) {
-        if (event.type !== 'call.broadcasting_started')
-            return;
-        state.setMetadata((metadata) => (Object.assign(Object.assign({}, metadata), { egress: Object.assign(Object.assign({}, metadata.egress), { broadcasting: true, hls: Object.assign(Object.assign({}, metadata.egress.hls), { playlist_url: event.hls_playlist_url }) }) })));
-    };
-};
-/**
- * Watches for `call.broadcasting_stopped` events.
- */
-const watchCallBroadcastingStopped = (state) => {
-    return function onCallBroadcastingStopped(event) {
-        if (event.type !== 'call.broadcasting_stopped')
-            return;
-        state.setMetadata((metadata) => (Object.assign(Object.assign({}, metadata), { egress: Object.assign(Object.assign({}, metadata.egress), { broadcasting: false }) })));
-    };
-};
-
 /**
  * Watches for `dominantSpeakerChanged` events.
  */
@@ -8848,98 +8872,6 @@ const watchAudioLevelChanged = (dispatcher, state) => {
     });
 };
 
-/**
- * Watch for call.session_started events and update the call metadata.
- *
- * @param state the call state.
- */
-const watchCallSessionStarted = (state) => {
-    return function onCallSessionStarted(event) {
-        if (event.type !== 'call.session_started')
-            return;
-        state.setMetadata(event.call);
-    };
-};
-/**
- * Watch for call.session_ended events and update the call metadata.
- *
- * @param state the call state.
- */
-const watchCallSessionEnded = (state) => {
-    return function onCallSessionEnded(event) {
-        if (event.type !== 'call.session_ended')
-            return;
-        state.setMetadata(event.call);
-    };
-};
-/**
- * Watch for call.session_participant_joined events and update the call metadata.
- *
- * @param state the call state.
- */
-const watchCallSessionParticipantJoined = (state) => {
-    return function onCallParticipantJoined(event) {
-        if (event.type !== 'call.session_participant_joined')
-            return;
-        const { participant } = event;
-        state.setMetadata((metadata) => {
-            if (!metadata || !metadata.session) {
-                state.logger('warn', `Received call.session_participant_joined event but the metadata structure is invalid.`, event);
-                return metadata;
-            }
-            const { session } = metadata;
-            const { participants, participants_count_by_role } = session;
-            const { user } = participant;
-            return Object.assign(Object.assign({}, metadata), { session: Object.assign(Object.assign({}, session), { participants: [...participants, participant], participants_count_by_role: Object.assign(Object.assign({}, participants_count_by_role), { [user.role]: (participants_count_by_role[user.role] || 0) + 1 }) }) });
-        });
-    };
-};
-/**
- * Watch for call.session_participant_left events and update the call metadata.
- *
- * @param state the call state.
- */
-const watchCallSessionParticipantLeft = (state) => {
-    return function onCallParticipantLeft(event) {
-        if (event.type !== 'call.session_participant_left')
-            return;
-        const { user, user_session_id } = event.participant;
-        state.setMetadata((metadata) => {
-            if (!metadata || !metadata.session) {
-                state.logger('warn', `Received call.session_participant_left event but the metadata structure is invalid.`, event);
-                return metadata;
-            }
-            const { session } = metadata;
-            const { participants, participants_count_by_role } = session;
-            return Object.assign(Object.assign({}, metadata), { session: Object.assign(Object.assign({}, session), { participants: participants.filter((p) => p.user_session_id !== user_session_id), participants_count_by_role: Object.assign(Object.assign({}, participants_count_by_role), { [user.role]: Math.max(0, (participants_count_by_role[user.role] || 0) - 1) }) }) });
-        });
-    };
-};
-
-/**
- * Event handler that watches for `call.blocked_user` events,
- * updates the call store `blocked_user_ids` property by adding
- * `event.user_id` to the list
- */
-const watchBlockedUser = (state) => (event) => {
-    if (event.type !== 'call.blocked_user')
-        return;
-    state.setMetadata((metadata) => (Object.assign(Object.assign({}, metadata), { blocked_user_ids: [...((metadata === null || metadata === void 0 ? void 0 : metadata.blocked_user_ids) || []), event.user.id] })));
-};
-/**
- * Event handler that watches for `call.unblocked_user` events,
- * updates the call store `blocked_user_ids` property by
- * removing `event.user_id` from the list
- */
-const watchUnblockedUser = (state) => (event) => {
-    if (event.type !== 'call.unblocked_user')
-        return;
-    state.setMetadata((metadata) => {
-        const blocked_user_ids = ((metadata === null || metadata === void 0 ? void 0 : metadata.blocked_user_ids) || []).filter((userId) => event.user.id !== userId);
-        return Object.assign(Object.assign({}, metadata), { blocked_user_ids });
-    });
-};
-
 /**
  * Registers the default event handlers for a call during its lifecycle.
  *
@@ -8948,29 +8880,8 @@ const watchUnblockedUser = (state) => (event) => {
  * @param dispatcher the dispatcher.
  */
 const registerEventHandlers = (call, state, dispatcher) => {
-    const coordinatorEvents = {
-        'call.blocked_user': watchBlockedUser(state),
-        'call.broadcasting_started': watchCallBroadcastingStarted(state),
-        'call.broadcasting_stopped': watchCallBroadcastingStopped(state),
-        'call.ended': watchCallEnded(call),
-        'call.live_started': watchCallLiveStarted(state),
-        'call.member_added': watchCallMemberAdded(state),
-        'call.member_removed': watchCallMemberRemoved(state),
-        'call.member_updated': watchCallMemberUpdated(state),
-        'call.member_updated_permission': watchCallMemberUpdatedPermission(state),
-        'call.permissions_updated': watchCallPermissionsUpdated(state),
-        'call.reaction_new': watchNewReactions(state),
-        'call.recording_started': watchCallRecordingStarted(state),
-        'call.recording_stopped': watchCallRecordingStopped(state),
-        'call.session_started': watchCallSessionStarted(state),
-        'call.session_ended': watchCallSessionEnded(state),
-        'call.session_participant_joined': watchCallSessionParticipantJoined(state),
-        'call.session_participant_left': watchCallSessionParticipantLeft(state),
-        'call.unblocked_user': watchUnblockedUser(state),
-        'call.updated': watchCallUpdated(state),
-        'call.user_muted': () => console.log('call.user_muted received'),
-    };
     const eventHandlers = [
+        call.on('call.ended', watchCallEnded(call)),
         watchLiveEnded(dispatcher, call),
         watchSfuErrorReports(dispatcher),
         watchChangePublishQuality(dispatcher, call),
@@ -8985,10 +8896,6 @@ const registerEventHandlers = (call, state, dispatcher) => {
         call.on('callGrantsUpdated', watchCallGrantsUpdated(state)),
         call.on('pinsUpdated', watchPinsUpdated(state)),
     ];
-    Object.keys(coordinatorEvents).forEach((event) => {
-        const eventName = event;
-        eventHandlers.push(call.on(eventName, coordinatorEvents[eventName]));
-    });
     if (call.ringing) {
         // these events are only relevant when the call is ringing
         eventHandlers.push(registerRingingCallEventHandlers(call));
@@ -9607,7 +9514,592 @@ const getClientDetails = () => {
     };
 };
 
-/**
+class InputMediaDeviceManagerState {
+    constructor() {
+        this.statusSubject = new BehaviorSubject(undefined);
+        this.mediaStreamSubject = new BehaviorSubject(undefined);
+        this.selectedDeviceSubject = new BehaviorSubject(undefined);
+        /**
+         * Gets the current value of an observable, or undefined if the observable has
+         * not emitted a value yet.
+         *
+         * @param observable$ the observable to get the value from.
+         */
+        this.getCurrentValue = getCurrentValue;
+        /**
+         * Updates the value of the provided Subject.
+         * An `update` can either be a new value or a function which takes
+         * the current value and returns a new value.
+         *
+         * @internal
+         *
+         * @param subject the subject to update.
+         * @param update the update to apply to the subject.
+         * @return the updated value.
+         */
+        this.setCurrentValue = setCurrentValue;
+        this.mediaStream$ = this.mediaStreamSubject.asObservable();
+        this.selectedDevice$ = this.selectedDeviceSubject
+            .asObservable()
+            .pipe(distinctUntilChanged$1());
+        this.status$ = this.statusSubject.asObservable();
+    }
+    /**
+     * The device status
+     */
+    get status() {
+        return this.getCurrentValue(this.status$);
+    }
+    /**
+     * The currently selected device
+     */
+    get selectedDevice() {
+        return this.getCurrentValue(this.selectedDevice$);
+    }
+    /**
+     * The current media stream, or `undefined` if the device is currently disabled.
+     */
+    get mediaStream() {
+        return this.getCurrentValue(this.mediaStream$);
+    }
+    /**
+     * @internal
+     * @param status
+     */
+    setStatus(status) {
+        this.setCurrentValue(this.statusSubject, status);
+    }
+    /**
+     * @internal
+     * @param stream
+     */
+    setMediaStream(stream) {
+        this.setCurrentValue(this.mediaStreamSubject, stream);
+        if (stream) {
+            this.setDevice(this.getDeviceIdFromStream(stream));
+        }
+    }
+    /**
+     * @internal
+     * @param stream
+     */
+    setDevice(deviceId) {
+        this.setCurrentValue(this.selectedDeviceSubject, deviceId);
+    }
+}
+
+class CameraManagerState extends InputMediaDeviceManagerState {
+    constructor() {
+        super();
+        this.directionSubject = new BehaviorSubject(undefined);
+        this.direction$ = this.directionSubject
+            .asObservable()
+            .pipe(distinctUntilChanged$1());
+    }
+    /**
+     * The preferred camera direction
+     * front - means the camera facing the user
+     * back - means the camera facing the environment
+     */
+    get direction() {
+        return this.getCurrentValue(this.direction$);
+    }
+    /**
+     * @internal
+     */
+    setDirection(direction) {
+        this.setCurrentValue(this.directionSubject, direction);
+    }
+    /**
+     * @internal
+     */
+    setMediaStream(stream) {
+        var _a;
+        super.setMediaStream(stream);
+        if (stream) {
+            // RN getSettings() doesn't return facingMode, so we don't verify camera direction
+            const direction = isReactNative()
+                ? this.direction
+                : ((_a = stream.getVideoTracks()[0]) === null || _a === void 0 ? void 0 : _a.getSettings().facingMode) === 'environment'
+                    ? 'back'
+                    : 'front';
+            this.setDirection(direction);
+        }
+    }
+    getDeviceIdFromStream(stream) {
+        var _a;
+        return (_a = stream.getVideoTracks()[0]) === null || _a === void 0 ? void 0 : _a.getSettings().deviceId;
+    }
+}
+
+const getDevices = (constraints) => {
+    return new Observable((subscriber) => {
+        navigator.mediaDevices
+            .getUserMedia(constraints)
+            .then((media) => {
+            // in Firefox, devices can be enumerated after userMedia is requested
+            // and permissions granted. Otherwise, device labels are empty
+            navigator.mediaDevices.enumerateDevices().then((devices) => {
+                subscriber.next(devices);
+                // If we stop the tracks before enumerateDevices -> the labels won't show up in Firefox
+                disposeOfMediaStream(media);
+                subscriber.complete();
+            });
+        })
+            .catch((error) => {
+            getLogger(['devices'])('error', 'Failed to get devices', error);
+            subscriber.error(error);
+        });
+    });
+};
+/**
+ * [Tells if the browser supports audio output change on 'audio' elements](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId).
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ */
+const checkIfAudioOutputChangeSupported = () => {
+    if (typeof document === 'undefined')
+        return false;
+    const element = document.createElement('audio');
+    return element.sinkId !== undefined;
+};
+/**
+ * The default constraints used to request audio devices.
+ */
+const audioDeviceConstraints = {
+    audio: {
+        autoGainControl: true,
+        noiseSuppression: true,
+        echoCancellation: true,
+    },
+};
+/**
+ * The default constraints used to request video devices.
+ */
+const videoDeviceConstraints = {
+    video: {
+        width: 1280,
+        height: 720,
+    },
+};
+// Audio and video devices are requested in two separate requests: that way users will be presented with two separate prompts -> they can give access to just camera, or just microphone
+const deviceChange$ = new Observable((subscriber) => {
+    var _a, _b;
+    const deviceChangeHandler = () => subscriber.next();
+    (_b = (_a = navigator.mediaDevices).addEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, 'devicechange', deviceChangeHandler);
+    return () => {
+        var _a, _b;
+        return (_b = (_a = navigator.mediaDevices).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, 'devicechange', deviceChangeHandler);
+    };
+}).pipe(debounceTime(500), concatMap(() => from(navigator.mediaDevices.enumerateDevices())), shareReplay(1));
+const audioDevices$ = merge(getDevices(audioDeviceConstraints), deviceChange$).pipe(shareReplay(1));
+const videoDevices$ = merge(getDevices(videoDeviceConstraints), deviceChange$).pipe(shareReplay(1));
+/**
+ * Prompts the user for a permission to use audio devices (if not already granted) and lists the available 'audioinput' devices, if devices are added/removed the list is updated.
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @returns
+ */
+const getAudioDevices = () => audioDevices$.pipe(map$2((values) => values.filter((d) => d.kind === 'audioinput')));
+/**
+ * Prompts the user for a permission to use video devices (if not already granted) and lists the available 'videoinput' devices, if devices are added/removed the list is updated.
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @returns
+ */
+const getVideoDevices = () => videoDevices$.pipe(map$2((values) => values.filter((d) => d.kind === 'videoinput' && d.deviceId.length)));
+/**
+ * Prompts the user for a permission to use audio devices (if not already granted) and lists the available 'audiooutput' devices, if devices are added/removed the list is updated. Selecting 'audiooutput' device only makes sense if [the browser has support for changing audio output on 'audio' elements](#checkifaudiooutputchangesupported)
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @returns
+ */
+const getAudioOutputDevices = () => {
+    return audioDevices$.pipe(map$2((values) => values.filter((d) => d.kind === 'audiooutput')));
+};
+const getStream = (constraints) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return yield navigator.mediaDevices.getUserMedia(constraints);
+    }
+    catch (e) {
+        getLogger(['devices'])('error', `Failed get user media`, {
+            error: e,
+            constraints: constraints,
+        });
+        throw e;
+    }
+});
+/**
+ * Returns an audio media stream that fulfills the given constraints.
+ * If no constraints are provided, it uses the browser's default ones.
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @param trackConstraints the constraints to use when requesting the stream.
+ * @returns the new `MediaStream` fulfilling the given constraints.
+ */
+const getAudioStream = (trackConstraints) => __awaiter(void 0, void 0, void 0, function* () {
+    const constraints = {
+        audio: Object.assign(Object.assign({}, audioDeviceConstraints.audio), trackConstraints),
+    };
+    return getStream(constraints);
+});
+/**
+ * Returns a video media stream that fulfills the given constraints.
+ * If no constraints are provided, it uses the browser's default ones.
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @param trackConstraints the constraints to use when requesting the stream.
+ * @returns a new `MediaStream` fulfilling the given constraints.
+ */
+const getVideoStream = (trackConstraints) => __awaiter(void 0, void 0, void 0, function* () {
+    const constraints = {
+        video: Object.assign(Object.assign({}, videoDeviceConstraints.video), trackConstraints),
+    };
+    return getStream(constraints);
+});
+/**
+ * Prompts the user for a permission to share a screen.
+ * If the user grants the permission, a screen sharing stream is returned. Throws otherwise.
+ *
+ * The callers of this API are responsible to handle the possible errors.
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ *
+ * @param options any additional options to pass to the [`getDisplayMedia`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getDisplayMedia) API.
+ */
+const getScreenShareStream = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return yield navigator.mediaDevices.getDisplayMedia(Object.assign({ video: true, audio: false }, options));
+    }
+    catch (e) {
+        getLogger(['devices'])('error', 'Failed to get screen share stream', e);
+        throw e;
+    }
+});
+const watchForDisconnectedDevice = (kind, deviceId$) => {
+    let devices$;
+    switch (kind) {
+        case 'audioinput':
+            devices$ = getAudioDevices();
+            break;
+        case 'videoinput':
+            devices$ = getVideoDevices();
+            break;
+        case 'audiooutput':
+            devices$ = getAudioOutputDevices();
+            break;
+    }
+    return combineLatest([devices$, deviceId$]).pipe(filter(([devices, deviceId]) => !!deviceId && !devices.find((d) => d.deviceId === deviceId)), map$2(() => true));
+};
+/**
+ * Notifies the subscriber if a given 'audioinput' device is disconnected
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @param deviceId$ an Observable that specifies which device to watch for
+ * @returns
+ */
+const watchForDisconnectedAudioDevice = (deviceId$) => {
+    return watchForDisconnectedDevice('audioinput', deviceId$);
+};
+/**
+ * Notifies the subscriber if a given 'videoinput' device is disconnected
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @param deviceId$ an Observable that specifies which device to watch for
+ * @returns
+ */
+const watchForDisconnectedVideoDevice = (deviceId$) => {
+    return watchForDisconnectedDevice('videoinput', deviceId$);
+};
+/**
+ * Notifies the subscriber if a given 'audiooutput' device is disconnected
+ *
+ * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
+ * @param deviceId$ an Observable that specifies which device to watch for
+ * @returns
+ */
+const watchForDisconnectedAudioOutputDevice = (deviceId$) => {
+    return watchForDisconnectedDevice('audiooutput', deviceId$);
+};
+const watchForAddedDefaultDevice = (kind) => {
+    let devices$;
+    switch (kind) {
+        case 'audioinput':
+            devices$ = getAudioDevices();
+            break;
+        case 'videoinput':
+            devices$ = getVideoDevices();
+            break;
+        case 'audiooutput':
+            devices$ = getAudioOutputDevices();
+            break;
+        default:
+            throw new Error('Unknown MediaDeviceKind', kind);
+    }
+    return devices$.pipe(pairwise(), filter(([prev, current]) => {
+        const prevDefault = prev.find((device) => device.deviceId === 'default');
+        const currentDefault = current.find((device) => device.deviceId === 'default');
+        return !!(current.length > prev.length &&
+            prevDefault &&
+            currentDefault &&
+            prevDefault.groupId !== currentDefault.groupId);
+    }), map$2(() => true));
+};
+/**
+ * Notifies the subscriber about newly added default audio input device.
+ * @returns Observable<boolean>
+ */
+const watchForAddedDefaultAudioDevice = () => watchForAddedDefaultDevice('audioinput');
+/**
+ * Notifies the subscriber about newly added default audio output device.
+ * @returns Observable<boolean>
+ */
+const watchForAddedDefaultAudioOutputDevice = () => watchForAddedDefaultDevice('audiooutput');
+/**
+ * Notifies the subscriber about newly added default video input device.
+ * @returns Observable<boolean>
+ */
+const watchForAddedDefaultVideoDevice = () => watchForAddedDefaultDevice('videoinput');
+/**
+ * Deactivates MediaStream (stops and removes tracks) to be later garbage collected
+ *
+ * @param stream MediaStream
+ * @returns void
+ */
+const disposeOfMediaStream = (stream) => {
+    if (!stream.active)
+        return;
+    stream.getTracks().forEach((track) => {
+        track.stop();
+        stream.removeTrack(track);
+    });
+    // @ts-expect-error release() is present in react-native-webrtc and must be called to dispose the stream
+    if (typeof stream.release === 'function') {
+        // @ts-expect-error
+        stream.release();
+    }
+};
+
+class InputMediaDeviceManager {
+    constructor(call, state) {
+        this.call = call;
+        this.state = state;
+    }
+    /**
+     * Lists the available audio/video devices
+     *
+     * Note: It prompts the user for a permission to use devices (if not already granted)
+     *
+     * @returns an Observable that will be updated if a device is connected or disconnected
+     */
+    listDevices() {
+        return this.getDevices();
+    }
+    /**
+     * Starts camera/microphone
+     */
+    enable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.state.status === 'enabled') {
+                return;
+            }
+            yield this.startStream();
+            this.state.setStatus('enabled');
+        });
+    }
+    /**
+     * Stops camera/microphone
+     * @returns
+     */
+    disable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.state.status === 'disabled') {
+                return;
+            }
+            yield this.stopStream();
+            this.state.setStatus('disabled');
+        });
+    }
+    /**
+     * If current device statis is disabled, it will enable the device, else it will disable it.
+     * @returns
+     */
+    toggle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.state.status === 'enabled') {
+                return this.disable();
+            }
+            else {
+                return this.enable();
+            }
+        });
+    }
+    /**
+     * Select device
+     *
+     * Note: this method is not supported in React Native
+     *
+     * @param deviceId
+     */
+    select(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isReactNative()) {
+                throw new Error('This method is not supported in React Native');
+            }
+            if (deviceId === this.state.selectedDevice) {
+                return;
+            }
+            this.state.setDevice(deviceId);
+            yield this.applySettingsToStream();
+        });
+    }
+    applySettingsToStream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.state.status === 'enabled') {
+                yield this.stopStream();
+                yield this.startStream();
+            }
+        });
+    }
+    stopStream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.state.mediaStream) {
+                return;
+            }
+            if (this.call.state.callingState === CallingState.JOINED) {
+                yield this.stopPublishStream();
+            }
+            else if (this.state.mediaStream) {
+                disposeOfMediaStream(this.state.mediaStream);
+            }
+            this.state.setMediaStream(undefined);
+        });
+    }
+    startStream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.state.mediaStream) {
+                return;
+            }
+            const constraints = { deviceId: this.state.selectedDevice };
+            const stream = yield this.getStream(constraints);
+            if (this.call.state.callingState === CallingState.JOINED) {
+                yield this.publishStream(stream);
+            }
+            this.state.setMediaStream(stream);
+        });
+    }
+}
+
+class CameraManager extends InputMediaDeviceManager {
+    constructor(call) {
+        super(call, new CameraManagerState());
+    }
+    /**
+     * Select the camera direaction
+     * @param direction
+     */
+    selectDirection(direction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.state.setDirection(direction);
+            // Providing both device id and direction doesn't work, so we deselect the device
+            this.state.setDevice(undefined);
+            yield this.applySettingsToStream();
+        });
+    }
+    /**
+     * Flips the camera direction: if it's front it will change to back, if it's back, it will change to front.
+     *
+     * Note: if there is no available camera with the desired direction, this method will do nothing.
+     * @returns
+     */
+    flip() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newDirection = this.state.direction === 'front' ? 'back' : 'front';
+            this.selectDirection(newDirection);
+        });
+    }
+    getDevices() {
+        return getVideoDevices();
+    }
+    getStream(constraints) {
+        // We can't set both device id and facing mode
+        // Device id has higher priority
+        if (!constraints.deviceId && this.state.direction) {
+            constraints.facingMode =
+                this.state.direction === 'front' ? 'user' : 'environment';
+        }
+        return getVideoStream(constraints);
+    }
+    publishStream(stream) {
+        return this.call.publishVideoStream(stream);
+    }
+    stopPublishStream() {
+        return this.call.stopPublish(TrackType.VIDEO);
+    }
+    /**
+     * Disables the video tracks of the camera
+     */
+    pause() {
+        var _a;
+        (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getVideoTracks().forEach((track) => {
+            track.enabled = false;
+        });
+    }
+    /**
+     * (Re)enables the video tracks of the camera
+     */
+    resume() {
+        var _a;
+        (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getVideoTracks().forEach((track) => {
+            track.enabled = true;
+        });
+    }
+}
+
+class MicrophoneManagerState extends InputMediaDeviceManagerState {
+    getDeviceIdFromStream(stream) {
+        var _a;
+        return (_a = stream.getAudioTracks()[0]) === null || _a === void 0 ? void 0 : _a.getSettings().deviceId;
+    }
+}
+
+class MicrophoneManager extends InputMediaDeviceManager {
+    constructor(call) {
+        super(call, new MicrophoneManagerState());
+    }
+    getDevices() {
+        return getAudioDevices();
+    }
+    getStream(constraints) {
+        return getAudioStream(constraints);
+    }
+    publishStream(stream) {
+        return this.call.publishAudioStream(stream);
+    }
+    stopPublishStream() {
+        return this.call.stopPublish(TrackType.AUDIO);
+    }
+    /**
+     * Disables the audio tracks of the microphone
+     */
+    pause() {
+        var _a;
+        (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getAudioTracks().forEach((track) => {
+            track.enabled = false;
+        });
+    }
+    /**
+     * (Re)enables the audio tracks of the microphone
+     */
+    resume() {
+        var _a;
+        (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getAudioTracks().forEach((track) => {
+            track.enabled = true;
+        });
+    }
+}
+
+/**
  * An object representation of a `Call`.
  */
 class Call {
@@ -9618,7 +10110,7 @@ class Call {
      * Use the [`StreamVideoClient.call`](./StreamVideoClient.md/#call)
      * method to construct a `Call` instance.
      */
-    constructor({ type, id, streamClient, metadata, members, ownCapabilities, sortParticipantsBy, clientStore, ringing = false, watching = false, }) {
+    constructor({ type, id, streamClient, members, ownCapabilities, sortParticipantsBy, clientStore, ringing = false, watching = false, }) {
         /**
          * ViewportTracker instance
          */
@@ -9697,7 +10189,7 @@ class Call {
             if ((params === null || params === void 0 ? void 0 : params.ring) && !this.ringing) {
                 this.ringingSubject.next(true);
             }
-            this.state.setMetadata(response.call);
+            this.state.updateFromCallResponse(response.call);
             this.state.setMembers(response.members);
             this.state.setOwnCapabilities(response.own_capabilities);
             if (this.streamClient._hasConnectionID()) {
@@ -9716,7 +10208,7 @@ class Call {
             if ((data === null || data === void 0 ? void 0 : data.ring) && !this.ringing) {
                 this.ringingSubject.next(true);
             }
-            this.state.setMetadata(response.call);
+            this.state.updateFromCallResponse(response.call);
             this.state.setMembers(response.members);
             this.state.setOwnCapabilities(response.own_capabilities);
             if (this.streamClient._hasConnectionID()) {
@@ -9773,7 +10265,7 @@ class Call {
          * @returns a promise which resolves once the call join-flow has finished.
          */
         this.join = (data) => __awaiter(this, void 0, void 0, function* () {
-            var _e, _f, _g;
+            var _e, _f, _g, _h;
             const callingState = this.state.callingState;
             if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
                 this.logger('warn', 'Join method called twice, you should only call this once');
@@ -9797,7 +10289,7 @@ class Call {
             let connectionConfig;
             try {
                 const call = yield join(this.streamClient, this.type, this.id, data);
-                this.state.setMetadata(call.metadata);
+                this.state.updateFromCallResponse(call.metadata);
                 this.state.setMembers(call.members);
                 this.state.setOwnCapabilities(call.ownCapabilities);
                 connectionConfig = call.connectionConfig;
@@ -9962,7 +10454,7 @@ class Call {
                     connectionConfig,
                 });
             }
-            const audioSettings = (_f = this.data) === null || _f === void 0 ? void 0 : _f.settings.audio;
+            const audioSettings = (_f = this.state.settings) === null || _f === void 0 ? void 0 : _f.audio;
             const isDtxEnabled = !!(audioSettings === null || audioSettings === void 0 ? void 0 : audioSettings.opus_dtx_enabled);
             const isRedEnabled = !!(audioSettings === null || audioSettings === void 0 ? void 0 : audioSettings.redundant_coding_enabled);
             if (!this.publisher) {
@@ -10042,6 +10534,11 @@ class Call {
                 this.state.setServerSidePins(pins);
                 this.reconnectAttempts = 0; // reset the reconnect attempts counter
                 this.state.setCallingState(CallingState.JOINED);
+                // React uses a different device management for now
+                if (((_h = getSdkInfo()) === null || _h === void 0 ? void 0 : _h.type) !== SdkType.REACT) {
+                    this.initCamera();
+                    this.initMic();
+                }
                 // 3. once we have the "joinResponse", and possibly reconciled the local state
                 // we schedule a fast subscription update for all remote participants
                 // that were visible before we reconnected or migrated to a new SFU.
@@ -10164,9 +10661,9 @@ class Call {
          * @param trackType the track type to stop publishing.
          */
         this.stopPublish = (trackType) => __awaiter(this, void 0, void 0, function* () {
-            var _h;
+            var _j;
             this.logger('info', `stopPublish ${TrackType[trackType]}`);
-            yield ((_h = this.publisher) === null || _h === void 0 ? void 0 : _h.unpublishStream(trackType));
+            yield ((_j = this.publisher) === null || _j === void 0 ? void 0 : _j.unpublishStream(trackType));
         });
         /**
          * Update track subscription configuration for one or more participants.
@@ -10267,6 +10764,8 @@ class Call {
          *
          *
          * @param deviceId the selected device, pass `undefined` to clear the device selection
+         *
+         * @deprecated use call.microphone.select
          */
         this.setAudioDevice = (deviceId) => {
             if (!this.sfuClient)
@@ -10281,6 +10780,8 @@ class Call {
          * This method only stores the selection, if you want to start publishing a media stream call the [`publishVideoStream` method](#publishvideostream) that will set `videoDeviceId` as well.
          *
          * @param deviceId the selected device, pass `undefined` to clear the device selection
+         *
+         * @deprecated use call.camera.select
          */
         this.setVideoDevice = (deviceId) => {
             if (!this.sfuClient)
@@ -10313,8 +10814,8 @@ class Call {
          * @returns
          */
         this.updatePublishQuality = (enabledRids) => __awaiter(this, void 0, void 0, function* () {
-            var _j;
-            return (_j = this.publisher) === null || _j === void 0 ? void 0 : _j.updateVideoPublishQuality(enabledRids);
+            var _k;
+            return (_k = this.publisher) === null || _k === void 0 ? void 0 : _k.updateVideoPublishQuality(enabledRids);
         });
         this.assertCallJoined = () => {
             return new Promise((resolve) => {
@@ -10509,7 +11010,7 @@ class Call {
         this.update = (updates) => __awaiter(this, void 0, void 0, function* () {
             const response = yield this.streamClient.patch(`${this.streamClientBasePath}`, updates);
             const { call, members, own_capabilities } = response;
-            this.state.setMetadata(call);
+            this.state.updateFromCallResponse(call);
             this.state.setMembers(members);
             this.state.setOwnCapabilities(own_capabilities);
             return response;
@@ -10582,19 +11083,20 @@ class Call {
         this.scheduleAutoDrop = () => {
             if (this.dropTimeout)
                 clearTimeout(this.dropTimeout);
-            const subscription = this.state.metadata$
-                .pipe(pairwise(), tap(([prevMeta, currentMeta]) => {
-                if (!(currentMeta && this.clientStore.connectedUser))
+            const subscription = this.state.settings$
+                .pipe(pairwise(), tap(([prevSettings, currentSettings]) => {
+                var _a;
+                if (!currentSettings || !this.clientStore.connectedUser)
                     return;
-                const isOutgoingCall = this.currentUserId === currentMeta.created_by.id;
+                const isOutgoingCall = this.currentUserId === ((_a = this.state.createdBy) === null || _a === void 0 ? void 0 : _a.id);
                 const [prevTimeoutMs, timeoutMs] = isOutgoingCall
                     ? [
-                        prevMeta === null || prevMeta === void 0 ? void 0 : prevMeta.settings.ring.auto_cancel_timeout_ms,
-                        currentMeta.settings.ring.auto_cancel_timeout_ms,
+                        prevSettings === null || prevSettings === void 0 ? void 0 : prevSettings.ring.auto_cancel_timeout_ms,
+                        currentSettings.ring.auto_cancel_timeout_ms,
                     ]
                     : [
-                        prevMeta === null || prevMeta === void 0 ? void 0 : prevMeta.settings.ring.incoming_call_timeout_ms,
-                        currentMeta.settings.ring.incoming_call_timeout_ms,
+                        prevSettings === null || prevSettings === void 0 ? void 0 : prevSettings.ring.incoming_call_timeout_ms,
+                        currentSettings.ring.incoming_call_timeout_ms,
                     ];
                 if (typeof timeoutMs === 'undefined' ||
                     timeoutMs === prevTimeoutMs ||
@@ -10611,7 +11113,6 @@ class Call {
         };
         /**
          * Retrieves the list of recordings for the current call or call session.
-         * Updates the call state with the returned array of CallRecording objects.
          *
          * If `callSessionId` is provided, it will return the recordings for that call session.
          * Otherwise, all recordings for the current call will be returned.
@@ -10623,9 +11124,7 @@ class Call {
             if (callSessionId) {
                 endpoint = `${endpoint}/${callSessionId}`;
             }
-            const response = yield this.streamClient.get(`${endpoint}/recordings`);
-            this.state.setCallRecordingsList(response.recordings);
-            return response;
+            return this.streamClient.get(`${endpoint}/recordings`);
         });
         /**
          * Sends a custom event to all call participants.
@@ -10649,21 +11148,26 @@ class Call {
         if (participantSorter) {
             this.state.setSortParticipantsBy(participantSorter);
         }
-        this.state.setMetadata(metadata);
         this.state.setMembers(members || []);
         this.state.setOwnCapabilities(ownCapabilities || []);
         this.state.setCallingState(ringing ? CallingState.RINGING : CallingState.IDLE);
+        this.on('all', (event) => {
+            // update state with the latest event data
+            this.state.updateFromEvent(event);
+        });
         this.leaveCallHooks.push(registerEventHandlers(this, this.state, this.dispatcher));
         this.registerEffects();
         this.leaveCallHooks.push(createSubscription(this.trackSubscriptionsSubject.pipe(debounce((v) => timer(v.type)), map$2((v) => v.data)), (subscriptions) => { var _a; return (_a = this.sfuClient) === null || _a === void 0 ? void 0 : _a.updateSubscriptions(subscriptions); }));
+        this.camera = new CameraManager(this);
+        this.microphone = new MicrophoneManager(this);
     }
     registerEffects() {
         this.leaveCallHooks.push(
-        // handles updating the permissions context when the metadata changes.
-        createSubscription(this.state.metadata$, (metadata) => {
-            if (!metadata)
+        // handles updating the permissions context when the settings change.
+        createSubscription(this.state.settings$, (settings) => {
+            if (!settings)
                 return;
-            this.permissionsContext.setCallSettings(metadata.settings);
+            this.permissionsContext.setCallSettings(settings);
         }), 
         // handle the case when the user permissions are modified.
         createSubscription(this.state.ownCapabilities$, (ownCapabilities) => {
@@ -10687,12 +11191,11 @@ class Call {
             }
         }), 
         // handles the case when the user is blocked by the call owner.
-        createSubscription(this.state.metadata$, (metadata) => __awaiter(this, void 0, void 0, function* () {
-            if (!metadata)
+        createSubscription(this.state.blockedUserIds$, (blockedUserIds) => __awaiter(this, void 0, void 0, function* () {
+            if (!blockedUserIds)
                 return;
             const currentUserId = this.currentUserId;
-            if (currentUserId &&
-                metadata.blocked_user_ids.includes(currentUserId)) {
+            if (currentUserId && blockedUserIds.includes(currentUserId)) {
                 this.logger('info', 'Leaving call because of being blocked');
                 yield this.leave();
             }
@@ -10744,12 +11247,6 @@ class Call {
             }
         }
     }
-    /**
-     * A getter for the call metadata.
-     */
-    get data() {
-        return this.state.metadata;
-    }
     /**
      * A flag indicating whether the call is "ringing" type of call.
      */
@@ -10768,7 +11265,65 @@ class Call {
      */
     get isCreatedByMe() {
         var _a;
-        return ((_a = this.state.metadata) === null || _a === void 0 ? void 0 : _a.created_by.id) === this.currentUserId;
+        return ((_a = this.state.createdBy) === null || _a === void 0 ? void 0 : _a.id) === this.currentUserId;
+    }
+    initCamera() {
+        var _a, _b, _c;
+        if (((_a = this.state.localParticipant) === null || _a === void 0 ? void 0 : _a.videoStream) ||
+            !this.permissionsContext.hasPermission('send-video')) {
+            return;
+        }
+        // Set camera direction if it's not yet set
+        // This will also start publishing if camera is enabled
+        if (!this.camera.state.direction && !this.camera.state.selectedDevice) {
+            let defaultDirection = 'front';
+            const backendSetting = (_b = this.state.settings) === null || _b === void 0 ? void 0 : _b.video.camera_facing;
+            if (backendSetting) {
+                defaultDirection = backendSetting === 'front' ? 'front' : 'back';
+            }
+            this.camera.selectDirection(defaultDirection);
+        }
+        else if (this.camera.state.status === 'enabled') {
+            // Publish already started media streams (this is the case if there is a lobby screen before join)
+            // Wait for media stream
+            this.camera.state.mediaStream$
+                .pipe(takeWhile((s) => s === undefined, true))
+                .subscribe((stream) => {
+                var _a;
+                if (!((_a = this.state.localParticipant) === null || _a === void 0 ? void 0 : _a.videoStream)) {
+                    this.publishVideoStream(stream);
+                }
+            });
+        }
+        // Apply backend config (this is the case if there is no lobby screen before join)
+        if (this.camera.state.status === undefined &&
+            ((_c = this.state.settings) === null || _c === void 0 ? void 0 : _c.video.camera_default_on)) {
+            void this.camera.enable();
+        }
+    }
+    initMic() {
+        var _a, _b;
+        if (((_a = this.state.localParticipant) === null || _a === void 0 ? void 0 : _a.audioStream) ||
+            !this.permissionsContext.hasPermission('send-audio')) {
+            return;
+        }
+        // Publish already started media streams (this is the case if there is a lobby screen before join)
+        if (this.microphone.state.status === 'enabled') {
+            // Wait for media stream
+            this.microphone.state.mediaStream$
+                .pipe(takeWhile((s) => s === undefined, true))
+                .subscribe((stream) => {
+                var _a;
+                if (!((_a = this.state.localParticipant) === null || _a === void 0 ? void 0 : _a.audioStream)) {
+                    this.publishAudioStream(stream);
+                }
+            });
+        }
+        // Apply backend config (this is the case if there is no lobby screen before join)
+        if (this.microphone.state.status === undefined &&
+            ((_b = this.state.settings) === null || _b === void 0 ? void 0 : _b.audio.mic_default_on)) {
+            void this.microphone.enable();
+        }
     }
 }
 
@@ -11880,7 +12435,7 @@ class WSConnectionFallback {
     }
 }
 
-const version = '0.2.3';
+const version = '0.3.1';
 
 const logger = getLogger(['location']);
 const HINT_URL = `https://hint.stream-io-video.com/`;
@@ -12574,12 +13129,12 @@ class StreamVideoClient {
                     streamClient: this.streamClient,
                     id: c.call.id,
                     type: c.call.type,
-                    metadata: c.call,
                     members: c.members,
                     ownCapabilities: c.own_capabilities,
                     watching: data.watch,
                     clientStore: this.writeableStateStore,
                 });
+                call.state.updateFromCallResponse(c.call);
                 if (data.watch) {
                     this.writeableStateStore.registerCall(call);
                 }
@@ -12587,9 +13142,9 @@ class StreamVideoClient {
             });
             return Object.assign(Object.assign({}, response), { calls: calls });
         });
-        this.queryUsers = () => __awaiter(this, void 0, void 0, function* () {
-            console.log('Querying users is not implemented yet.');
-        });
+        /**
+         * Returns a list of available data centers available for hosting calls.
+         */
         this.edges = () => __awaiter(this, void 0, void 0, function* () {
             return this.streamClient.get(`/edges`);
         });
@@ -12764,14 +13319,15 @@ class StreamVideoClient {
                     return;
                 }
                 this.logger('info', `New call created and registered: ${call.cid}`);
-                this.writeableStateStore.registerCall(new Call({
+                const newCall = new Call({
                     streamClient: this.streamClient,
                     type: call.type,
                     id: call.id,
-                    metadata: call,
                     members,
                     clientStore: this.writeableStateStore,
-                }));
+                });
+                newCall.state.updateFromCallResponse(call);
+                this.writeableStateStore.registerCall(newCall);
             }));
             this.eventHandlersToUnregister.push(this.on('call.ring', (event) => __awaiter(this, void 0, void 0, function* () {
                 if (event.type !== 'call.ring')
@@ -12785,7 +13341,6 @@ class StreamVideoClient {
                 // if `call.created` was received before `call.ring`.
                 // In that case, we cleanup the already tracked call.
                 const prevCall = this.writeableStateStore.findCall(call.type, call.id);
-                const prevMetadata = prevCall === null || prevCall === void 0 ? void 0 : prevCall.state.metadata;
                 yield (prevCall === null || prevCall === void 0 ? void 0 : prevCall.leave());
                 // we create a new call
                 const theCall = new Call({
@@ -12795,8 +13350,8 @@ class StreamVideoClient {
                     members,
                     clientStore: this.writeableStateStore,
                     ringing: true,
-                    metadata: prevMetadata,
                 });
+                theCall.state.updateFromCallResponse(call);
                 // we fetch the latest metadata for the call from the server
                 yield theCall.get();
                 this.writeableStateStore.registerCall(theCall);
@@ -12854,254 +13409,6 @@ class StreamVideoServerClient extends StreamVideoClient {
     }
 }
 
-const getDevices = (constraints) => {
-    return new Observable((subscriber) => {
-        navigator.mediaDevices
-            .getUserMedia(constraints)
-            .then((media) => {
-            // in Firefox, devices can be enumerated after userMedia is requested
-            // and permissions granted. Otherwise, device labels are empty
-            navigator.mediaDevices.enumerateDevices().then((devices) => {
-                subscriber.next(devices);
-                // If we stop the tracks before enumerateDevices -> the labels won't show up in Firefox
-                disposeOfMediaStream(media);
-                subscriber.complete();
-            });
-        })
-            .catch((error) => {
-            getLogger(['devices'])('error', 'Failed to get devices', error);
-            subscriber.error(error);
-        });
-    });
-};
-/**
- * [Tells if the browser supports audio output change on 'audio' elements](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId).
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- */
-const checkIfAudioOutputChangeSupported = () => {
-    if (typeof document === 'undefined')
-        return false;
-    const element = document.createElement('audio');
-    return element.sinkId !== undefined;
-};
-/**
- * The default constraints used to request audio devices.
- */
-const audioDeviceConstraints = {
-    audio: {
-        autoGainControl: true,
-        noiseSuppression: true,
-        echoCancellation: true,
-    },
-};
-/**
- * The default constraints used to request video devices.
- */
-const videoDeviceConstraints = {
-    video: {
-        width: 1280,
-        height: 720,
-    },
-};
-// Audio and video devices are requested in two separate requests: that way users will be presented with two separate prompts -> they can give access to just camera, or just microphone
-const deviceChange$ = new Observable((subscriber) => {
-    var _a, _b;
-    const deviceChangeHandler = () => subscriber.next();
-    (_b = (_a = navigator.mediaDevices).addEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, 'devicechange', deviceChangeHandler);
-    return () => {
-        var _a, _b;
-        return (_b = (_a = navigator.mediaDevices).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, 'devicechange', deviceChangeHandler);
-    };
-}).pipe(debounceTime(500), concatMap(() => from(navigator.mediaDevices.enumerateDevices())), shareReplay(1));
-const audioDevices$ = merge(getDevices(audioDeviceConstraints), deviceChange$).pipe(shareReplay(1));
-const videoDevices$ = merge(getDevices(videoDeviceConstraints), deviceChange$).pipe(shareReplay(1));
-/**
- * Prompts the user for a permission to use audio devices (if not already granted) and lists the available 'audioinput' devices, if devices are added/removed the list is updated.
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- * @returns
- */
-const getAudioDevices = () => audioDevices$.pipe(map$2((values) => values.filter((d) => d.kind === 'audioinput')));
-/**
- * Prompts the user for a permission to use video devices (if not already granted) and lists the available 'videoinput' devices, if devices are added/removed the list is updated.
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- * @returns
- */
-const getVideoDevices = () => videoDevices$.pipe(map$2((values) => values.filter((d) => d.kind === 'videoinput' && d.deviceId.length)));
-/**
- * Prompts the user for a permission to use audio devices (if not already granted) and lists the available 'audiooutput' devices, if devices are added/removed the list is updated. Selecting 'audiooutput' device only makes sense if [the browser has support for changing audio output on 'audio' elements](#checkifaudiooutputchangesupported)
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- * @returns
- */
-const getAudioOutputDevices = () => {
-    return audioDevices$.pipe(map$2((values) => values.filter((d) => d.kind === 'audiooutput')));
-};
-const getStream = (constraints) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        return yield navigator.mediaDevices.getUserMedia(constraints);
-    }
-    catch (e) {
-        getLogger(['devices'])('error', `Failed get user media`, {
-            error: e,
-            constraints: constraints,
-        });
-        throw e;
-    }
-});
-/**
- * Returns an audio media stream that fulfills the given constraints.
- * If no constraints are provided, it uses the browser's default ones.
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- * @param trackConstraints the constraints to use when requesting the stream.
- * @returns the new `MediaStream` fulfilling the given constraints.
- */
-const getAudioStream = (trackConstraints) => __awaiter(void 0, void 0, void 0, function* () {
-    const constraints = {
-        audio: Object.assign(Object.assign({}, audioDeviceConstraints.audio), trackConstraints),
-    };
-    return getStream(constraints);
-});
-/**
- * Returns a video media stream that fulfills the given constraints.
- * If no constraints are provided, it uses the browser's default ones.
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- * @param trackConstraints the constraints to use when requesting the stream.
- * @returns a new `MediaStream` fulfilling the given constraints.
- */
-const getVideoStream = (trackConstraints) => __awaiter(void 0, void 0, void 0, function* () {
-    const constraints = {
-        video: Object.assign(Object.assign({}, videoDeviceConstraints.video), trackConstraints),
-    };
-    return getStream(constraints);
-});
-/**
- * Prompts the user for a permission to share a screen.
- * If the user grants the permission, a screen sharing stream is returned. Throws otherwise.
- *
- * The callers of this API are responsible to handle the possible errors.
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- *
- * @param options any additional options to pass to the [`getDisplayMedia`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getDisplayMedia) API.
- */
-const getScreenShareStream = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        return yield navigator.mediaDevices.getDisplayMedia(Object.assign({ video: true, audio: false }, options));
-    }
-    catch (e) {
-        getLogger(['devices'])('error', 'Failed to get screen share stream', e);
-        throw e;
-    }
-});
-const watchForDisconnectedDevice = (kind, deviceId$) => {
-    let devices$;
-    switch (kind) {
-        case 'audioinput':
-            devices$ = getAudioDevices();
-            break;
-        case 'videoinput':
-            devices$ = getVideoDevices();
-            break;
-        case 'audiooutput':
-            devices$ = getAudioOutputDevices();
-            break;
-    }
-    return combineLatest([devices$, deviceId$]).pipe(filter(([devices, deviceId]) => !!deviceId && !devices.find((d) => d.deviceId === deviceId)), map$2(() => true));
-};
-/**
- * Notifies the subscriber if a given 'audioinput' device is disconnected
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- * @param deviceId$ an Observable that specifies which device to watch for
- * @returns
- */
-const watchForDisconnectedAudioDevice = (deviceId$) => {
-    return watchForDisconnectedDevice('audioinput', deviceId$);
-};
-/**
- * Notifies the subscriber if a given 'videoinput' device is disconnected
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- * @param deviceId$ an Observable that specifies which device to watch for
- * @returns
- */
-const watchForDisconnectedVideoDevice = (deviceId$) => {
-    return watchForDisconnectedDevice('videoinput', deviceId$);
-};
-/**
- * Notifies the subscriber if a given 'audiooutput' device is disconnected
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- * @param deviceId$ an Observable that specifies which device to watch for
- * @returns
- */
-const watchForDisconnectedAudioOutputDevice = (deviceId$) => {
-    return watchForDisconnectedDevice('audiooutput', deviceId$);
-};
-const watchForAddedDefaultDevice = (kind) => {
-    let devices$;
-    switch (kind) {
-        case 'audioinput':
-            devices$ = getAudioDevices();
-            break;
-        case 'videoinput':
-            devices$ = getVideoDevices();
-            break;
-        case 'audiooutput':
-            devices$ = getAudioOutputDevices();
-            break;
-        default:
-            throw new Error('Unknown MediaDeviceKind', kind);
-    }
-    return devices$.pipe(pairwise(), filter(([prev, current]) => {
-        const prevDefault = prev.find((device) => device.deviceId === 'default');
-        const currentDefault = current.find((device) => device.deviceId === 'default');
-        return !!(current.length > prev.length &&
-            prevDefault &&
-            currentDefault &&
-            prevDefault.groupId !== currentDefault.groupId);
-    }), map$2(() => true));
-};
-/**
- * Notifies the subscriber about newly added default audio input device.
- * @returns Observable<boolean>
- */
-const watchForAddedDefaultAudioDevice = () => watchForAddedDefaultDevice('audioinput');
-/**
- * Notifies the subscriber about newly added default audio output device.
- * @returns Observable<boolean>
- */
-const watchForAddedDefaultAudioOutputDevice = () => watchForAddedDefaultDevice('audiooutput');
-/**
- * Notifies the subscriber about newly added default video input device.
- * @returns Observable<boolean>
- */
-const watchForAddedDefaultVideoDevice = () => watchForAddedDefaultDevice('videoinput');
-/**
- * Deactivates MediaStream (stops and removes tracks) to be later garbage collected
- *
- * @param stream MediaStream
- * @returns void
- */
-const disposeOfMediaStream = (stream) => {
-    if (!stream.active)
-        return;
-    stream.getTracks().forEach((track) => {
-        track.stop();
-        stream.removeTrack(track);
-    });
-    // @ts-expect-error release() is present in react-native-webrtc and must be called to dispose the stream
-    if (typeof stream.release === 'function') {
-        // @ts-expect-error
-        stream.release();
-    }
-};
-
 const DETECTION_FREQUENCY_IN_MS = 500;
 const AUDIO_LEVEL_THRESHOLD = 150;
 const FFT_SIZE = 128;
@@ -13182,5 +13489,5 @@ var browsers = /*#__PURE__*/Object.freeze({
     isSafari: isSafari
 });
 
-export { AudioSettingsDefaultDeviceEnum, AudioSettingsRequestDefaultDeviceEnum, browsers as Browsers, Call, CallState, CallType, CallTypes, CallingState, CreateDeviceRequestPushProviderEnum, DebounceType, ErrorFromResponse, OwnCapability, RecordSettingsModeEnum, RecordSettingsQualityEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, events as SfuEvents, models as SfuModels, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoServerClient, StreamVideoWriteableStateStore, TranscriptionSettingsModeEnum, TranscriptionSettingsRequestModeEnum, VideoSettingsCameraFacingEnum, VideoSettingsRequestCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, disposeOfMediaStream, dominantSpeaker, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceInfo, getLogger, getOSInfo, getScreenShareStream, getSdkInfo, getVideoDevices, getVideoStream, isStreamVideoLocalParticipant, livestreamOrAudioRoomSortPreset, logLevels, logToConsole, name, noopComparator, pinned, publishingAudio, publishingVideo, reactionType, role, screenSharing, setDeviceInfo, setLogLevel, setLogger, setOSInfo, setSdkInfo, speakerLayoutSortPreset, speaking, watchForAddedDefaultAudioDevice, watchForAddedDefaultAudioOutputDevice, watchForAddedDefaultVideoDevice, watchForDisconnectedAudioDevice, watchForDisconnectedAudioOutputDevice, watchForDisconnectedVideoDevice };
+export { AudioSettingsDefaultDeviceEnum, AudioSettingsRequestDefaultDeviceEnum, browsers as Browsers, Call, CallState, CallType, CallTypes, CallingState, CameraManager, CreateDeviceRequestPushProviderEnum, DebounceType, ErrorFromResponse, InputMediaDeviceManager, InputMediaDeviceManagerState, MicrophoneManager, OwnCapability, RecordSettingsModeEnum, RecordSettingsQualityEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, events as SfuEvents, models as SfuModels, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoServerClient, StreamVideoWriteableStateStore, TranscriptionSettingsModeEnum, TranscriptionSettingsRequestModeEnum, VideoSettingsCameraFacingEnum, VideoSettingsRequestCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, disposeOfMediaStream, dominantSpeaker, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceInfo, getLogger, getOSInfo, getScreenShareStream, getSdkInfo, getVideoDevices, getVideoStream, isStreamVideoLocalParticipant, livestreamOrAudioRoomSortPreset, logLevels, logToConsole, name, noopComparator, pinned, publishingAudio, publishingVideo, reactionType, role, screenSharing, setDeviceInfo, setLogLevel, setLogger, setOSInfo, setSdkInfo, speakerLayoutSortPreset, speaking, watchForAddedDefaultAudioDevice, watchForAddedDefaultAudioOutputDevice, watchForAddedDefaultVideoDevice, watchForDisconnectedAudioDevice, watchForDisconnectedAudioOutputDevice, watchForDisconnectedVideoDevice };
 //# sourceMappingURL=index.browser.es.js.map