@stream-io/video-client 0.2.3 → 0.3.1

package/dist/index.cjs.js

@@ -6543,8 +6543,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;
@@ -6822,8 +6822,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)
@@ -6916,7 +6916,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;
@@ -7544,17 +7543,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.
@@ -7997,71 +7985,29 @@ class CallState {
      *
      */
     constructor() {
-        /**
-         * The raw call metadata object, as defined on the backend.
-         *
-         * @internal
-         */
-        this.metadataSubject = new rxjs.BehaviorSubject(undefined);
-        /**
-         * The list of members of the current call.
-         *
-         * @internal
-         */
+        this.backstageSubject = new rxjs.BehaviorSubject(false);
+        this.blockedUserIdsSubject = new rxjs.BehaviorSubject([]);
+        this.createdAtSubject = new rxjs.BehaviorSubject(new Date());
+        this.endedAtSubject = new rxjs.BehaviorSubject(undefined);
+        this.startsAtSubject = new rxjs.BehaviorSubject(undefined);
+        this.updatedAtSubject = new rxjs.BehaviorSubject(new Date());
+        this.createdBySubject = new rxjs.BehaviorSubject(undefined);
+        this.customSubject = new rxjs.BehaviorSubject({});
+        this.egressSubject = new rxjs.BehaviorSubject(undefined);
+        this.ingressSubject = new rxjs.BehaviorSubject(undefined);
+        this.recordingSubject = new rxjs.BehaviorSubject(false);
+        this.sessionSubject = new rxjs.BehaviorSubject(undefined);
+        this.settingsSubject = new rxjs.BehaviorSubject(undefined);
+        this.transcribingSubject = new rxjs.BehaviorSubject(false);
+        this.endedBySubject = new rxjs.BehaviorSubject(undefined);
         this.membersSubject = new rxjs.BehaviorSubject([]);
-        /**
-         * The list of capabilities of the current user.
-         *
-         * @private
-         */
         this.ownCapabilitiesSubject = new rxjs.BehaviorSubject([]);
-        /**
-         * The calling state.
-         *
-         * @internal
-         */
         this.callingStateSubject = new rxjs.BehaviorSubject(exports.CallingState.UNKNOWN);
-        /**
-         * The time the call session actually started.
-         *
-         * @internal
-         */
         this.startedAtSubject = new rxjs.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 rxjs.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 rxjs.BehaviorSubject(0);
-        /**
-         * All participants of the current call (including the logged-in user).
-         *
-         * @internal
-         */
         this.participantsSubject = new rxjs.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 rxjs.BehaviorSubject(undefined);
-        /**
-         * Emits a list of details about recordings performed for the current call.
-         */
-        this.callRecordingListSubject = new rxjs.BehaviorSubject([]);
         /**
          * A list of comparators that are used to sort the participants.
          *
@@ -8144,15 +8090,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.
          *
@@ -8162,16 +8099,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.
          *
@@ -8270,6 +8197,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.
          *
@@ -8298,25 +8238,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(operators.map((ps) => ps.sort(this.sortParticipantsBy)));
         this.localParticipant$ = this.participants$.pipe(operators.map((participants) => participants.find(isStreamVideoLocalParticipant)));
         this.remoteParticipants$ = this.participants$.pipe(operators.map((participants) => participants.filter((p) => !p.isLocalParticipant)));
         this.pinnedParticipants$ = this.participants$.pipe(operators.map((participants) => participants.filter((p) => !!p.pin)));
         this.dominantSpeaker$ = this.participants$.pipe(operators.map((participants) => participants.find((p) => p.isDominantSpeaker)));
-        this.hasOngoingScreenShare$ = this.participants$.pipe(operators.map((participants) => {
-            return participants.some((p) => p.publishedTracks.includes(TrackType.SCREEN_SHARE));
-        }), operators.distinctUntilChanged());
+        this.hasOngoingScreenShare$ = this.participants$.pipe(operators.map((participants) => participants.some((p) => p.publishedTracks.includes(TrackType.SCREEN_SHARE))), operators.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.
@@ -8381,24 +8470,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.
      */
@@ -8411,6 +8488,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$);
+    }
 }
 
 /**
@@ -8482,40 +8649,16 @@ const watchCallEnded = (call) => {
         return __awaiter(this, void 0, void 0, function* () {
             if (event.type !== 'call.ended')
                 return;
-            if (call.state.callingState === exports.CallingState.RINGING ||
-                call.state.callingState === exports.CallingState.JOINED ||
-                call.state.callingState === exports.CallingState.JOINING) {
-                call.state.setMetadata(event.call);
+            const { callingState } = call.state;
+            if (callingState === exports.CallingState.RINGING ||
+                callingState === exports.CallingState.JOINED ||
+                callingState === exports.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.
  *
@@ -8629,57 +8772,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.
  */
@@ -8761,74 +8853,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.
  */
@@ -8871,98 +8895,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.
  *
@@ -8971,29 +8903,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),
@@ -9008,10 +8919,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));
@@ -9630,7 +9537,592 @@ const getClientDetails = () => {
     };
 };
 
-/**
+class InputMediaDeviceManagerState {
+    constructor() {
+        this.statusSubject = new rxjs.BehaviorSubject(undefined);
+        this.mediaStreamSubject = new rxjs.BehaviorSubject(undefined);
+        this.selectedDeviceSubject = new rxjs.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(rxjs.distinctUntilChanged());
+        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 rxjs.BehaviorSubject(undefined);
+        this.direction$ = this.directionSubject
+            .asObservable()
+            .pipe(rxjs.distinctUntilChanged());
+    }
+    /**
+     * 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 rxjs.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 rxjs.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(rxjs.debounceTime(500), rxjs.concatMap(() => rxjs.from(navigator.mediaDevices.enumerateDevices())), rxjs.shareReplay(1));
+const audioDevices$ = rxjs.merge(getDevices(audioDeviceConstraints), deviceChange$).pipe(rxjs.shareReplay(1));
+const videoDevices$ = rxjs.merge(getDevices(videoDeviceConstraints), deviceChange$).pipe(rxjs.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(rxjs.map((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(rxjs.map((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(rxjs.map((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 rxjs.combineLatest([devices$, deviceId$]).pipe(rxjs.filter(([devices, deviceId]) => !!deviceId && !devices.find((d) => d.deviceId === deviceId)), rxjs.map(() => 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(rxjs.pairwise(), rxjs.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);
+    }), rxjs.map(() => 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 === exports.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 === exports.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 {
@@ -9641,7 +10133,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
          */
@@ -9720,7 +10212,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()) {
@@ -9739,7 +10231,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()) {
@@ -9796,7 +10288,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 ([exports.CallingState.JOINED, exports.CallingState.JOINING].includes(callingState)) {
                 this.logger('warn', 'Join method called twice, you should only call this once');
@@ -9820,7 +10312,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;
@@ -9985,7 +10477,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) {
@@ -10065,6 +10557,11 @@ class Call {
                 this.state.setServerSidePins(pins);
                 this.reconnectAttempts = 0; // reset the reconnect attempts counter
                 this.state.setCallingState(exports.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.
@@ -10187,9 +10684,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.
@@ -10290,6 +10787,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)
@@ -10304,6 +10803,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)
@@ -10336,8 +10837,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) => {
@@ -10532,7 +11033,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;
@@ -10605,19 +11106,20 @@ class Call {
         this.scheduleAutoDrop = () => {
             if (this.dropTimeout)
                 clearTimeout(this.dropTimeout);
-            const subscription = this.state.metadata$
-                .pipe(rxjs.pairwise(), rxjs.tap(([prevMeta, currentMeta]) => {
-                if (!(currentMeta && this.clientStore.connectedUser))
+            const subscription = this.state.settings$
+                .pipe(rxjs.pairwise(), rxjs.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 ||
@@ -10634,7 +11136,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.
@@ -10646,9 +11147,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.
@@ -10672,21 +11171,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 ? exports.CallingState.RINGING : exports.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(rxjs.debounce((v) => rxjs.timer(v.type)), rxjs.map((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) => {
@@ -10710,12 +11214,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();
             }
@@ -10767,12 +11270,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.
      */
@@ -10791,7 +11288,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(rxjs.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(rxjs.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();
+        }
     }
 }
 
@@ -11904,7 +12459,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/`;
@@ -12598,12 +13153,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);
                 }
@@ -12611,9 +13166,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`);
         });
@@ -12788,14 +13343,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')
@@ -12809,7 +13365,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({
@@ -12819,8 +13374,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);
@@ -12878,254 +13433,6 @@ class StreamVideoServerClient extends StreamVideoClient {
     }
 }
 
-const getDevices = (constraints) => {
-    return new rxjs.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 rxjs.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(rxjs.debounceTime(500), rxjs.concatMap(() => rxjs.from(navigator.mediaDevices.enumerateDevices())), rxjs.shareReplay(1));
-const audioDevices$ = rxjs.merge(getDevices(audioDeviceConstraints), deviceChange$).pipe(rxjs.shareReplay(1));
-const videoDevices$ = rxjs.merge(getDevices(videoDeviceConstraints), deviceChange$).pipe(rxjs.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(rxjs.map((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(rxjs.map((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(rxjs.map((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 rxjs.combineLatest([devices$, deviceId$]).pipe(rxjs.filter(([devices, deviceId]) => !!deviceId && !devices.find((d) => d.deviceId === deviceId)), rxjs.map(() => 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(rxjs.pairwise(), rxjs.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);
-    }), rxjs.map(() => 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;
@@ -13217,8 +13524,12 @@ exports.Call = Call;
 exports.CallState = CallState;
 exports.CallType = CallType;
 exports.CallTypes = CallTypes;
+exports.CameraManager = CameraManager;
 exports.CreateDeviceRequestPushProviderEnum = CreateDeviceRequestPushProviderEnum;
 exports.ErrorFromResponse = ErrorFromResponse;
+exports.InputMediaDeviceManager = InputMediaDeviceManager;
+exports.InputMediaDeviceManagerState = InputMediaDeviceManagerState;
+exports.MicrophoneManager = MicrophoneManager;
 exports.OwnCapability = OwnCapability;
 exports.RecordSettingsModeEnum = RecordSettingsModeEnum;
 exports.RecordSettingsQualityEnum = RecordSettingsQualityEnum;