@whereby.com/core 0.6.0 → 0.8.0

package/dist/cjs/index.cjs

@@ -0,0 +1,3188 @@
+'use strict';
+
+var toolkit = require('@reduxjs/toolkit');
+var media = require('@whereby.com/media');
+var Chrome111_js = require('mediasoup-client/lib/handlers/Chrome111.js');
+var nodeBtoa = require('btoa');
+var axios = require('axios');
+var EventEmitter = require('events');
+
+function createAppAsyncThunk(typePrefix, payloadCreator) {
+    return toolkit.createAsyncThunk(typePrefix, payloadCreator);
+}
+function createAppThunk(thunk) {
+    return thunk;
+}
+
+const listenerMiddleware = toolkit.createListenerMiddleware();
+const startAppListening = listenerMiddleware.startListening;
+const addAppListener = toolkit.addListener;
+const createReactor = (selectors, callback) => {
+    return startAppListening({
+        predicate: (_, currentState, previousState) => {
+            const previousValues = selectors.map((selector) => selector(previousState));
+            const currentValues = selectors.map((selector) => selector(currentState));
+            return previousValues.some((previousValue, index) => previousValue !== currentValues[index]);
+        },
+        effect: (action, { dispatch, getState, extra }) => {
+            const selectorResults = selectors.map((selector) => selector(getState()));
+            callback({
+                dispatch,
+                getState,
+                extra,
+            }, ...selectorResults);
+        },
+    });
+};
+
+const initialState$c = {
+    isNodeSdk: false,
+    wantsToJoin: false,
+    roomName: null,
+    roomKey: null,
+    roomUrl: null,
+    displayName: null,
+    sdkVersion: null,
+    externalId: null,
+};
+const appSlice = toolkit.createSlice({
+    name: "app",
+    initialState: initialState$c,
+    reducers: {
+        doAppJoin: (state, action) => {
+            const url = new URL(action.payload.roomUrl);
+            return Object.assign(Object.assign(Object.assign({}, state), action.payload), { roomName: url.pathname, wantsToJoin: true });
+        },
+        appLeft: (state) => {
+            return Object.assign(Object.assign({}, state), { wantsToJoin: false });
+        },
+        setRoomKey: (state, action) => {
+            return Object.assign(Object.assign({}, state), { roomKey: action.payload });
+        },
+    },
+});
+const { doAppJoin, appLeft, setRoomKey } = appSlice.actions;
+const selectAppRaw = (state) => state.app;
+const selectAppWantsToJoin = (state) => state.app.wantsToJoin;
+const selectAppRoomName = (state) => state.app.roomName;
+const selectAppRoomUrl = (state) => state.app.roomUrl;
+const selectAppRoomKey = (state) => state.app.roomKey;
+const selectAppDisplayName = (state) => state.app.displayName;
+const selectAppSdkVersion = (state) => state.app.sdkVersion;
+const selectAppExternalId = (state) => state.app.externalId;
+const selectAppIsNodeSdk = (state) => state.app.isNodeSdk;
+
+function createSignalEventAction(name) {
+    return toolkit.createAction(`signalConnection/event/${name}`);
+}
+const signalEvents = {
+    audioEnabled: createSignalEventAction("audioEnabled"),
+    chatMessage: createSignalEventAction("chatMessage"),
+    clientLeft: createSignalEventAction("clientLeft"),
+    clientKicked: createSignalEventAction("clientKicked"),
+    clientMetadataReceived: createSignalEventAction("clientMetadataReceived"),
+    cloudRecordingStarted: createSignalEventAction("cloudRecordingStarted"),
+    cloudRecordingStopped: createSignalEventAction("cloudRecordingStopped"),
+    disconnect: createSignalEventAction("disconnect"),
+    knockerLeft: createSignalEventAction("knockerLeft"),
+    knockHandled: createSignalEventAction("knockHandled"),
+    newClient: createSignalEventAction("newClient"),
+    roomJoined: createSignalEventAction("roomJoined"),
+    roomKnocked: createSignalEventAction("roomKnocked"),
+    roomSessionEnded: createSignalEventAction("roomSessionEnded"),
+    screenshareStarted: createSignalEventAction("screenshareStarted"),
+    screenshareStopped: createSignalEventAction("screenshareStopped"),
+    streamingStopped: createSignalEventAction("streamingStopped"),
+    videoEnabled: createSignalEventAction("videoEnabled"),
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const initialState$b = {
+    isFetching: false,
+    data: null,
+};
+const deviceCredentialsSlice = toolkit.createSlice({
+    name: "deviceCredentials",
+    initialState: initialState$b,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(doGetDeviceCredentials.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: true });
+        });
+        builder.addCase(doGetDeviceCredentials.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { isFetching: false, data: action.payload });
+        });
+        builder.addCase(doGetDeviceCredentials.rejected, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: true });
+        });
+    },
+});
+const doGetDeviceCredentials = createAppAsyncThunk("deviceCredentials/doGetDeviceCredentials", (payload, { extra }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const deviceCredentials = yield extra.services.credentialsService.getCredentials();
+        return deviceCredentials;
+    }
+    catch (error) {
+        console.error(error);
+    }
+}));
+const selectDeviceCredentialsRaw = (state) => state.deviceCredentials;
+const selectHasFetchedDeviceCredentials = (state) => { var _a; return !!((_a = state.deviceCredentials.data) === null || _a === void 0 ? void 0 : _a.credentials); };
+const selectDeviceId = (state) => { var _a, _b; return (_b = (_a = state.deviceCredentials.data) === null || _a === void 0 ? void 0 : _a.credentials) === null || _b === void 0 ? void 0 : _b.uuid; };
+const selectShouldFetchDeviceCredentials = toolkit.createSelector(selectAppWantsToJoin, selectDeviceCredentialsRaw, (wantsToJoin, deviceCredentials) => {
+    if (wantsToJoin && !deviceCredentials.isFetching && !deviceCredentials.data) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldFetchDeviceCredentials], ({ dispatch }, shouldFetchDeviceCredentials) => {
+    if (shouldFetchDeviceCredentials) {
+        dispatch(doGetDeviceCredentials());
+    }
+});
+
+function forwardSocketEvents(socket, dispatch) {
+    socket.on("room_joined", (payload) => dispatch(signalEvents.roomJoined(payload)));
+    socket.on("new_client", (payload) => dispatch(signalEvents.newClient(payload)));
+    socket.on("client_left", (payload) => dispatch(signalEvents.clientLeft(payload)));
+    socket.on("client_kicked", (payload) => dispatch(signalEvents.clientKicked(payload)));
+    socket.on("audio_enabled", (payload) => dispatch(signalEvents.audioEnabled(payload)));
+    socket.on("video_enabled", (payload) => dispatch(signalEvents.videoEnabled(payload)));
+    socket.on("client_metadata_received", (payload) => dispatch(signalEvents.clientMetadataReceived(payload)));
+    socket.on("chat_message", (payload) => dispatch(signalEvents.chatMessage(payload)));
+    socket.on("disconnect", () => dispatch(signalEvents.disconnect()));
+    socket.on("room_knocked", (payload) => dispatch(signalEvents.roomKnocked(payload)));
+    socket.on("room_session_ended", (payload) => dispatch(signalEvents.roomSessionEnded(payload)));
+    socket.on("knocker_left", (payload) => dispatch(signalEvents.knockerLeft(payload)));
+    socket.on("knock_handled", (payload) => dispatch(signalEvents.knockHandled(payload)));
+    socket.on("screenshare_started", (payload) => dispatch(signalEvents.screenshareStarted(payload)));
+    socket.on("screenshare_stopped", (payload) => dispatch(signalEvents.screenshareStopped(payload)));
+    socket.on("cloud_recording_started", (payload) => dispatch(signalEvents.cloudRecordingStarted(payload)));
+    socket.on("cloud_recording_stopped", () => dispatch(signalEvents.cloudRecordingStopped()));
+    socket.on("streaming_stopped", () => dispatch(signalEvents.streamingStopped()));
+}
+const SIGNAL_BASE_URL = "wss://signal.appearin.net" ;
+function createSocket() {
+    const parsedUrl = new URL(SIGNAL_BASE_URL);
+    const socketHost = parsedUrl.origin;
+    const socketOverrides = {
+        autoConnect: false,
+    };
+    return new media.ServerSocket(socketHost, socketOverrides);
+}
+const initialState$a = {
+    deviceIdentified: false,
+    isIdentifyingDevice: false,
+    status: "",
+    socket: null,
+};
+const signalConnectionSlice = toolkit.createSlice({
+    name: "signalConnection",
+    initialState: initialState$a,
+    reducers: {
+        socketConnecting: (state) => {
+            return Object.assign(Object.assign({}, state), { status: "connecting" });
+        },
+        socketConnected: (state, action) => {
+            return Object.assign(Object.assign({}, state), { socket: action.payload, status: "connected" });
+        },
+        socketDisconnected: (state) => {
+            return Object.assign(Object.assign({}, state), { status: "disconnected" });
+        },
+        socketReconnecting: (state) => {
+            return Object.assign(Object.assign({}, state), { status: "reconnect" });
+        },
+        deviceIdentifying: (state) => {
+            return Object.assign(Object.assign({}, state), { isIdentifyingDevice: true });
+        },
+        deviceIdentified: (state) => {
+            return Object.assign(Object.assign({}, state), { deviceIdentified: true, isIdentifyingDevice: false });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.disconnect, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "disconnected" });
+        });
+    },
+});
+const { deviceIdentifying, deviceIdentified, socketConnected, socketConnecting, socketDisconnected } = signalConnectionSlice.actions;
+const doSignalSocketConnect = createAppThunk(() => {
+    return (dispatch, getState) => {
+        if (selectSignalConnectionSocket(getState())) {
+            return;
+        }
+        dispatch(socketConnecting());
+        const socket = createSocket();
+        socket.on("connect", () => dispatch(socketConnected(socket)));
+        socket.on("device_identified", () => dispatch(deviceIdentified()));
+        socket.getManager().on("reconnect", () => dispatch(doSignalReconnect()));
+        forwardSocketEvents(socket, dispatch);
+        socket.connect();
+    };
+});
+const doSignalIdentifyDevice = createAppThunk(({ deviceCredentials }) => (dispatch, getState) => {
+    const state = getState();
+    const signalSocket = selectSignalConnectionSocket(state);
+    if (!signalSocket) {
+        return;
+    }
+    signalSocket.emit("identify_device", { deviceCredentials });
+    dispatch(deviceIdentifying());
+});
+const doSignalDisconnect = createAppThunk(() => (dispatch, getState) => {
+    const socket = selectSignalConnectionRaw(getState()).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("leave_room");
+    socket === null || socket === void 0 ? void 0 : socket.disconnect();
+    dispatch(socketDisconnected());
+});
+const doSignalReconnect = createAppThunk(() => (dispatch, getState) => {
+    const deviceCredentialsRaw = selectDeviceCredentialsRaw(getState());
+    dispatch(socketReconnecting());
+    if (deviceCredentialsRaw.data) {
+        dispatch(doSignalIdentifyDevice({ deviceCredentials: deviceCredentialsRaw.data }));
+    }
+});
+const { socketReconnecting } = signalConnectionSlice.actions;
+const selectSignalConnectionRaw = (state) => state.signalConnection;
+const selectSignalIsIdentifyingDevice = (state) => state.signalConnection.isIdentifyingDevice;
+const selectSignalConnectionDeviceIdentified = (state) => state.signalConnection.deviceIdentified;
+const selectSignalStatus = (state) => state.signalConnection.status;
+const selectSignalConnectionSocket = (state) => state.signalConnection.socket;
+startAppListening({
+    actionCreator: appLeft,
+    effect: (_, { dispatch }) => {
+        dispatch(doSignalDisconnect());
+    },
+});
+const selectShouldConnectSignal = toolkit.createSelector(selectAppWantsToJoin, selectSignalStatus, (wantsToJoin, signalStatus) => {
+    if (wantsToJoin && ["", "reconnect"].includes(signalStatus)) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldConnectSignal], ({ dispatch }, shouldConnectSignal) => {
+    if (shouldConnectSignal) {
+        dispatch(doSignalSocketConnect());
+    }
+});
+const selectShouldIdentifyDevice = toolkit.createSelector(selectDeviceCredentialsRaw, selectSignalStatus, selectSignalConnectionDeviceIdentified, selectSignalIsIdentifyingDevice, (deviceCredentialsRaw, signalStatus, deviceIdentified, isIdentifyingDevice) => {
+    if (deviceCredentialsRaw.data && signalStatus === "connected" && !deviceIdentified && !isIdentifyingDevice) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldIdentifyDevice, selectDeviceCredentialsRaw], ({ dispatch }, shouldIdentifyDevice, deviceCredentialsRaw) => {
+    if (shouldIdentifyDevice && deviceCredentialsRaw.data) {
+        dispatch(doSignalIdentifyDevice({ deviceCredentials: deviceCredentialsRaw.data }));
+    }
+});
+
+const initialState$9 = {
+    chatMessages: [],
+};
+const chatSlice = toolkit.createSlice({
+    name: "chat",
+    initialState: initialState$9,
+    reducers: {},
+    extraReducers(builder) {
+        builder.addCase(signalEvents.chatMessage, (state, action) => {
+            const message = {
+                senderId: action.payload.senderId,
+                timestamp: action.payload.timestamp,
+                text: action.payload.text,
+            };
+            return Object.assign(Object.assign({}, state), { chatMessages: [...state.chatMessages, message] });
+        });
+    },
+});
+const doSendChatMessage = createAppThunk((payload) => (_, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("chat_message", { text: payload.text });
+});
+const selectChatRaw = (state) => state.chat;
+const selectChatMessages = (state) => state.chat.chatMessages;
+
+const initialCloudRecordingState = {
+    isRecording: false,
+    error: null,
+    startedAt: undefined,
+};
+const cloudRecordingSlice = toolkit.createSlice({
+    name: "cloudRecording",
+    initialState: initialCloudRecordingState,
+    reducers: {
+        recordingRequestStarted: (state) => {
+            return Object.assign(Object.assign({}, state), { status: "requested" });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.cloudRecordingStopped, (state) => {
+            return Object.assign(Object.assign({}, state), { isRecording: false, status: undefined });
+        });
+        builder.addCase(signalEvents.cloudRecordingStarted, (state, action) => {
+            const { payload } = action;
+            if (!payload.error) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { isRecording: false, status: "error", error: payload.error });
+        });
+        builder.addCase(signalEvents.newClient, (state, { payload }) => {
+            var _a;
+            const { client } = payload;
+            if (((_a = client.role) === null || _a === void 0 ? void 0 : _a.roleName) === "recorder") {
+                return Object.assign(Object.assign({}, state), { isRecording: true, status: "recording", startedAt: client.startedCloudRecordingAt
+                        ? new Date(client.startedCloudRecordingAt).getTime()
+                        : new Date().getTime() });
+            }
+            return state;
+        });
+    },
+});
+const { recordingRequestStarted } = cloudRecordingSlice.actions;
+const doStartCloudRecording = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const status = selectCloudRecordingStatus(state);
+    if (status && ["recording", "requested"].includes(status)) {
+        return;
+    }
+    socket === null || socket === void 0 ? void 0 : socket.emit("start_recording", {
+        recording: "cloud",
+    });
+    dispatch(recordingRequestStarted());
+});
+const doStopCloudRecording = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("stop_recording");
+});
+const selectCloudRecordingRaw = (state) => state.cloudRecording;
+const selectCloudRecordingStatus = (state) => state.cloudRecording.status;
+const selectCloudRecordingStartedAt = (state) => state.cloudRecording.startedAt;
+const selectCloudRecordingError = (state) => state.cloudRecording.error;
+const selectIsCloudRecording = (state) => state.cloudRecording.isRecording;
+
+function debounce(fn, { delay = 500, edges } = {}) {
+    let timeout;
+    let nCalls = 0;
+    return (...args) => {
+        nCalls += 1;
+        if (edges && nCalls === 1) {
+            fn(...args);
+        }
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            if (!edges || nCalls > 1) {
+                fn(...args);
+            }
+            timeout = undefined;
+            nCalls = 0;
+        }, delay);
+    };
+}
+
+const initialLocalMediaState = {
+    busyDeviceIds: [],
+    cameraEnabled: false,
+    devices: [],
+    isSettingCameraDevice: false,
+    isSettingMicrophoneDevice: false,
+    isTogglingCamera: false,
+    microphoneEnabled: false,
+    status: "",
+    isSwitchingStream: false,
+};
+const localMediaSlice = toolkit.createSlice({
+    name: "localMedia",
+    initialState: initialLocalMediaState,
+    reducers: {
+        deviceBusy(state, action) {
+            if (state.busyDeviceIds.includes(action.payload.deviceId)) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { busyDeviceIds: [...state.busyDeviceIds, action.payload.deviceId] });
+        },
+        toggleCameraEnabled(state, action) {
+            var _a;
+            return Object.assign(Object.assign({}, state), { cameraEnabled: (_a = action.payload.enabled) !== null && _a !== void 0 ? _a : !state.cameraEnabled });
+        },
+        setCurrentCameraDeviceId(state, action) {
+            return Object.assign(Object.assign({}, state), { currentCameraDeviceId: action.payload.deviceId });
+        },
+        toggleMicrophoneEnabled(state, action) {
+            var _a;
+            return Object.assign(Object.assign({}, state), { microphoneEnabled: (_a = action.payload.enabled) !== null && _a !== void 0 ? _a : !state.microphoneEnabled });
+        },
+        setCurrentMicrophoneDeviceId(state, action) {
+            return Object.assign(Object.assign({}, state), { currentMicrophoneDeviceId: action.payload.deviceId });
+        },
+        setDevices(state, action) {
+            return Object.assign(Object.assign({}, state), { devices: action.payload.devices });
+        },
+        setLocalMediaStream(state, action) {
+            return Object.assign(Object.assign({}, state), { stream: action.payload.stream });
+        },
+        setLocalMediaOptions(state, action) {
+            return Object.assign(Object.assign({}, state), { options: action.payload.options });
+        },
+        localMediaStopped(state) {
+            return Object.assign(Object.assign({}, state), { status: "stopped", stream: undefined });
+        },
+        localStreamMetadataUpdated(state, action) {
+            const { audio, video } = action.payload;
+            return Object.assign(Object.assign({}, state), { currentCameraDeviceId: video.deviceId, currentMicrophoneDeviceId: audio.deviceId, busyDeviceIds: state.busyDeviceIds.filter((id) => id !== audio.deviceId && id !== video.deviceId) });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(doAppJoin, (state, action) => {
+            return Object.assign(Object.assign({}, state), { options: action.payload.localMediaOptions });
+        });
+        builder.addCase(doSetDevice.pending, (state, action) => {
+            const { audio, video } = action.meta.arg;
+            return Object.assign(Object.assign({}, state), { isSettingCameraDevice: video, isSettingMicrophoneDevice: audio });
+        });
+        builder.addCase(doSetDevice.fulfilled, (state, action) => {
+            const { audio, video } = action.meta.arg;
+            return Object.assign(Object.assign({}, state), { isSettingCameraDevice: video ? false : state.isSettingCameraDevice, isSettingMicrophoneDevice: audio ? false : state.isSettingMicrophoneDevice });
+        });
+        builder.addCase(doSetDevice.rejected, (state, action) => {
+            const { audio, video } = action.meta.arg;
+            return Object.assign(Object.assign({}, state), { isSettingCameraDevice: video ? false : state.isSettingCameraDevice, isSettingMicrophoneDevice: audio ? false : state.isSettingMicrophoneDevice, cameraDeviceError: video ? action.error : state.cameraDeviceError, microphoneDeviceError: audio ? action.error : state.microphoneDeviceError });
+        });
+        builder.addCase(doToggleCamera.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isTogglingCamera: true });
+        });
+        builder.addCase(doToggleCamera.fulfilled, (state) => {
+            return Object.assign(Object.assign({}, state), { isTogglingCamera: false });
+        });
+        builder.addCase(doUpdateDeviceList.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { devices: action.payload.devices });
+        });
+        builder.addCase(doStartLocalMedia.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "starting" });
+        });
+        builder.addCase(doStartLocalMedia.fulfilled, (state, { payload: { stream, onDeviceChange } }) => {
+            let cameraDeviceId = undefined;
+            let cameraEnabled = false;
+            let microphoneDeviceId = undefined;
+            let microphoneEnabled = false;
+            const audioTrack = stream.getAudioTracks()[0];
+            const videoTrack = stream.getVideoTracks()[0];
+            if (audioTrack) {
+                microphoneDeviceId = audioTrack.getSettings().deviceId;
+                microphoneEnabled = audioTrack.enabled;
+            }
+            if (videoTrack) {
+                cameraEnabled = videoTrack.enabled;
+                cameraDeviceId = videoTrack.getSettings().deviceId;
+            }
+            return Object.assign(Object.assign({}, state), { stream, status: "started", currentCameraDeviceId: cameraDeviceId, currentMicrophoneDeviceId: microphoneDeviceId, cameraEnabled,
+                microphoneEnabled,
+                onDeviceChange });
+        });
+        builder.addCase(doStartLocalMedia.rejected, (state, action) => {
+            return Object.assign(Object.assign({}, state), { status: "error", startError: action.error });
+        });
+        builder.addCase(doSwitchLocalStream.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isSwitchingStream: true });
+        });
+        builder.addCase(doSwitchLocalStream.fulfilled, (state) => {
+            return Object.assign(Object.assign({}, state), { isSwitchingStream: false });
+        });
+        builder.addCase(doSwitchLocalStream.rejected, (state) => {
+            return Object.assign(Object.assign({}, state), { isSwitchingStream: false });
+        });
+    },
+});
+const { deviceBusy, setCurrentCameraDeviceId, setCurrentMicrophoneDeviceId, toggleCameraEnabled, toggleMicrophoneEnabled, setLocalMediaOptions, setLocalMediaStream, localMediaStopped, localStreamMetadataUpdated, } = localMediaSlice.actions;
+const doToggleCamera = createAppAsyncThunk("localMedia/doToggleCamera", (_, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const state = getState();
+    const stream = selectLocalMediaStream(state);
+    if (!stream) {
+        return;
+    }
+    let track = stream.getVideoTracks()[0];
+    const enabled = selectIsCameraEnabled(state);
+    try {
+        if (enabled) {
+            if (track) {
+                track.enabled = true;
+            }
+            else {
+                const constraintsOptions = selectLocalMediaConstraintsOptions(state);
+                const cameraDeviceId = selectCurrentCameraDeviceId(state);
+                yield media.getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId: false, videoId: cameraDeviceId, type: "exact" }), { replaceStream: stream });
+                track = stream.getVideoTracks()[0];
+            }
+        }
+        else {
+            if (!track) {
+                return;
+            }
+            track.enabled = false;
+            track.stop();
+            stream.removeTrack(track);
+        }
+        stream.dispatchEvent(new CustomEvent("stopresumevideo", { detail: { track, enable: enabled } }));
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doToggleMicrophone = createAppAsyncThunk("localMedia/doToggleMicrophone", (_, { getState }) => {
+    var _a;
+    const state = getState();
+    const stream = selectLocalMediaStream(state);
+    if (!stream) {
+        return;
+    }
+    const enabled = selectIsMicrophoneEnabled(state);
+    const audioTrack = (_a = stream.getAudioTracks()) === null || _a === void 0 ? void 0 : _a[0];
+    if (!audioTrack) {
+        return;
+    }
+    audioTrack.enabled = enabled;
+});
+const doSetDevice = createAppAsyncThunk("localMedia/reactSetDevice", ({ audio, video }, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const state = getState();
+        const stream = selectLocalMediaStream(state);
+        if (!stream) {
+            throw new Error("No stream");
+        }
+        const audioId = audio ? selectCurrentMicrophoneDeviceId(state) : false;
+        const videoId = video ? selectCurrentCameraDeviceId(state) : false;
+        const constraintsOptions = selectLocalMediaConstraintsOptions(state);
+        const { replacedTracks } = yield media.getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId,
+            videoId, type: "exact" }), { replaceStream: stream });
+        const isAudioEnabled = selectIsMicrophoneEnabled(state);
+        stream.getAudioTracks().forEach((track) => (track.enabled = isAudioEnabled));
+        const isVideoEnabled = selectIsCameraEnabled(state);
+        stream.getVideoTracks().forEach((track) => (track.enabled = isVideoEnabled));
+        return { replacedTracks };
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doUpdateDeviceList = createAppAsyncThunk("localMedia/doUpdateDeviceList", (_, { getState, dispatch, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const state = getState();
+    let newDevices = [];
+    let oldDevices = [];
+    const stream = selectLocalMediaStream(state);
+    const busy = selectBusyDeviceIds(state);
+    try {
+        newDevices = yield navigator.mediaDevices.enumerateDevices();
+        oldDevices = selectLocalMediaDevices(state);
+        const shouldHandleDeviceUpdate = stream &&
+            !selectLocalMediaIsSwitchingStream(state) &&
+            newDevices &&
+            oldDevices &&
+            oldDevices.find((d) => d.deviceId);
+        if (!shouldHandleDeviceUpdate) {
+            return { devices: newDevices };
+        }
+        const { changedDevices } = media.getUpdatedDevices({
+            oldDevices,
+            newDevices,
+            currentAudioId: selectCurrentMicrophoneDeviceId(state),
+            currentVideoId: selectCurrentCameraDeviceId(state),
+        });
+        let autoSwitchAudioId = (_a = changedDevices.audioinput) === null || _a === void 0 ? void 0 : _a.deviceId;
+        let autoSwitchVideoId = (_b = changedDevices.videoinput) === null || _b === void 0 ? void 0 : _b.deviceId;
+        function nextId(devices, id) {
+            const curIdx = id ? devices.findIndex((d) => d.deviceId === id) : 0;
+            return (devices[(curIdx + 1) % devices.length] || {}).deviceId;
+        }
+        if (autoSwitchVideoId !== undefined) {
+            const videoDevices = selectLocalMediaDevices(state).filter((d) => d.kind === "videoinput");
+            const videoId = selectCurrentCameraDeviceId(state);
+            let nextVideoId = nextId(videoDevices.filter((d) => !busy.includes(d.deviceId)), videoId);
+            if (!nextVideoId || videoId === nextVideoId) {
+                nextVideoId = nextId(videoDevices, videoId);
+            }
+            if (videoId !== nextVideoId) {
+                autoSwitchVideoId = nextVideoId;
+            }
+        }
+        if (autoSwitchAudioId !== undefined) {
+            const audioDevices = selectLocalMediaDevices(state).filter((d) => d.kind === "audioinput");
+            const audioId = selectCurrentMicrophoneDeviceId(state);
+            let nextAudioId = nextId(audioDevices.filter((d) => !busy.includes(d.deviceId)), audioId);
+            if (!nextAudioId || audioId === nextAudioId) {
+                nextAudioId = nextId(audioDevices, audioId);
+            }
+            if (audioId !== nextAudioId) {
+                autoSwitchAudioId = nextAudioId;
+            }
+        }
+        if (autoSwitchAudioId !== undefined || autoSwitchVideoId !== undefined) {
+            dispatch(doSwitchLocalStream({ audioId: autoSwitchAudioId, videoId: autoSwitchVideoId }));
+        }
+        return { devices: newDevices };
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doSwitchLocalStream = createAppAsyncThunk("localMedia/doSwitchLocalStream", ({ audioId, videoId }, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const state = getState();
+    const replaceStream = selectLocalMediaStream(state);
+    const constraintsOptions = selectLocalMediaConstraintsOptions(state);
+    const onlySwitchingOne = !!(videoId && !audioId) || !!(!videoId && audioId);
+    if (!replaceStream) {
+        return;
+    }
+    try {
+        const { replacedTracks } = yield media.getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId: audioId === undefined ? false : audioId, videoId: videoId === undefined ? false : videoId, type: "exact" }), { replaceStream });
+        const deviceId = audioId || videoId;
+        if (onlySwitchingOne && deviceId) {
+            dispatch(deviceBusy({
+                deviceId,
+            }));
+        }
+        return { replacedTracks };
+    }
+    catch (error) {
+        console.error(error);
+        const deviceId = audioId || videoId;
+        if (onlySwitchingOne && deviceId) {
+            dispatch(deviceBusy({
+                deviceId,
+            }));
+        }
+        return rejectWithValue(error);
+    }
+}));
+const doStartLocalMedia = createAppAsyncThunk("localMedia/doStartLocalMedia", (payload, { getState, dispatch, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const onDeviceChange = debounce(() => {
+        dispatch(doUpdateDeviceList());
+    }, { delay: 500 });
+    if (navigator.mediaDevices) {
+        navigator.mediaDevices.addEventListener("devicechange", onDeviceChange);
+    }
+    if ("getTracks" in payload) {
+        return Promise.resolve({ stream: payload, onDeviceChange });
+    }
+    if (!(payload.audio || payload.video)) {
+        return { stream: new MediaStream(), onDeviceChange };
+    }
+    else {
+        dispatch(setLocalMediaOptions({ options: payload }));
+    }
+    try {
+        yield dispatch(doUpdateDeviceList());
+        const state = getState();
+        const constraintsOptions = selectLocalMediaConstraintsOptions(state);
+        const { stream } = yield media.getStream(Object.assign(Object.assign({}, constraintsOptions), { audioId: payload.audio, videoId: payload.video }));
+        return { stream, onDeviceChange };
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doStopLocalMedia = createAppThunk(() => (dispatch, getState) => {
+    const stream = selectLocalMediaStream(getState());
+    const onDeviceChange = selectLocalMediaRaw(getState()).onDeviceChange;
+    stream === null || stream === void 0 ? void 0 : stream.getTracks().forEach((track) => {
+        track.stop();
+    });
+    if (navigator.mediaDevices && onDeviceChange) {
+        navigator.mediaDevices.removeEventListener("devicechange", onDeviceChange);
+    }
+    dispatch(localMediaStopped());
+});
+const selectBusyDeviceIds = (state) => state.localMedia.busyDeviceIds;
+const selectCameraDeviceError = (state) => state.localMedia.cameraDeviceError;
+const selectCurrentCameraDeviceId = (state) => state.localMedia.currentCameraDeviceId;
+const selectCurrentMicrophoneDeviceId = (state) => state.localMedia.currentMicrophoneDeviceId;
+const selectIsCameraEnabled = (state) => state.localMedia.cameraEnabled;
+const selectIsMicrophoneEnabled = (state) => state.localMedia.microphoneEnabled;
+const selectIsSettingCameraDevice = (state) => state.localMedia.isSettingCameraDevice;
+const selectIsSettingMicrophoneDevice = (state) => state.localMedia.isSettingMicrophoneDevice;
+const selectIsToggleCamera = (state) => state.localMedia.isTogglingCamera;
+const selectLocalMediaDevices = (state) => state.localMedia.devices;
+const selectLocalMediaOptions = (state) => state.localMedia.options;
+const selectLocalMediaOwnsStream = toolkit.createSelector(selectLocalMediaOptions, (options) => !!options);
+const selectLocalMediaRaw = (state) => state.localMedia;
+const selectLocalMediaStatus = (state) => state.localMedia.status;
+const selectLocalMediaStream = (state) => state.localMedia.stream;
+const selectMicrophoneDeviceError = (state) => state.localMedia.microphoneDeviceError;
+const selectLocalMediaStartError = (state) => state.localMedia.startError;
+const selectLocalMediaIsSwitchingStream = (state) => state.localMedia.isSwitchingStream;
+const selectLocalMediaConstraintsOptions = toolkit.createSelector(selectLocalMediaDevices, (devices) => ({
+    devices,
+    options: {
+        disableAEC: false,
+        disableAGC: false,
+        hd: true,
+        lax: false,
+        lowDataMode: false,
+        simulcast: true,
+        widescreen: true,
+    },
+}));
+const selectIsLocalMediaStarting = toolkit.createSelector(selectLocalMediaStatus, (status) => status === "starting");
+const selectCameraDevices = toolkit.createSelector(selectLocalMediaDevices, selectBusyDeviceIds, (devices, busyDeviceIds) => devices.filter((d) => d.kind === "videoinput").filter((d) => !busyDeviceIds.includes(d.deviceId)));
+const selectMicrophoneDevices = toolkit.createSelector(selectLocalMediaDevices, selectBusyDeviceIds, (devices, busyDeviceIds) => devices.filter((d) => d.kind === "audioinput").filter((d) => !busyDeviceIds.includes(d.deviceId)));
+const selectSpeakerDevices = toolkit.createSelector(selectLocalMediaDevices, (devices) => devices.filter((d) => d.kind === "audiooutput"));
+const selectLocalMediaShouldStartWithOptions = toolkit.createSelector(selectAppWantsToJoin, selectLocalMediaStatus, selectLocalMediaOptions, selectAppIsNodeSdk, (appWantsToJoin, localMediaStatus, localMediaOptions, isNodeSdk) => {
+    if (appWantsToJoin && localMediaStatus === "" && !isNodeSdk && localMediaOptions) {
+        return localMediaOptions;
+    }
+});
+createReactor([selectLocalMediaShouldStartWithOptions], ({ dispatch }, options) => {
+    if (options) {
+        dispatch(doStartLocalMedia(options));
+    }
+});
+const selectLocalMediaShouldStop = toolkit.createSelector(selectAppWantsToJoin, selectLocalMediaStatus, selectLocalMediaOptions, (appWantsToJoin, localMediaStatus, localMediaOptions) => {
+    return !appWantsToJoin && localMediaStatus !== "" && !!localMediaOptions;
+});
+createReactor([selectLocalMediaShouldStop], ({ dispatch }, localMediaShouldStop) => {
+    if (localMediaShouldStop) {
+        dispatch(doStopLocalMedia());
+    }
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const oldValue = selectIsMicrophoneEnabled(previousState);
+        const newValue = selectIsMicrophoneEnabled(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_, { dispatch }) => {
+        dispatch(doToggleMicrophone());
+    },
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const isToggling = selectIsToggleCamera(currentState);
+        if (isToggling) {
+            return false;
+        }
+        const oldValue = selectIsCameraEnabled(previousState);
+        const newValue = selectIsCameraEnabled(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_action, { dispatch }) => {
+        dispatch(doToggleCamera());
+    },
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const oldValue = selectCurrentCameraDeviceId(previousState);
+        const newValue = selectCurrentCameraDeviceId(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_action, { dispatch }) => {
+        dispatch(doSetDevice({ audio: false, video: true }));
+    },
+});
+startAppListening({
+    predicate: (_action, currentState, previousState) => {
+        const oldValue = selectCurrentMicrophoneDeviceId(previousState);
+        const newValue = selectCurrentMicrophoneDeviceId(currentState);
+        const isReady = selectLocalMediaStatus(previousState) === "started";
+        return isReady && oldValue !== newValue;
+    },
+    effect: (_action, { dispatch }) => {
+        dispatch(doSetDevice({ audio: true, video: false }));
+    },
+});
+startAppListening({
+    matcher: toolkit.isAnyOf(doStartLocalMedia.fulfilled, doUpdateDeviceList.fulfilled, doSwitchLocalStream.fulfilled, doSwitchLocalStream.rejected),
+    effect: (_action, { dispatch, getState }) => {
+        const state = getState();
+        const stream = selectLocalMediaStream(state);
+        const devices = selectLocalMediaDevices(state);
+        if (!stream)
+            return;
+        const deviceData = media.getDeviceData({
+            audioTrack: stream.getAudioTracks()[0],
+            videoTrack: stream.getVideoTracks()[0],
+            devices,
+        });
+        dispatch(localStreamMetadataUpdated(deviceData));
+    },
+});
+
+const initialState$8 = {
+    displayName: "",
+    id: "",
+    isAudioEnabled: true,
+    isVideoEnabled: true,
+    isLocalParticipant: true,
+    stream: undefined,
+    isScreenSharing: false,
+    roleName: "",
+    clientClaim: undefined,
+};
+const doEnableAudio = createAppAsyncThunk("localParticipant/doEnableAudio", (payload, { getState }) => __awaiter(void 0, void 0, void 0, function* () {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("enable_audio", { enabled: payload.enabled });
+    return payload.enabled;
+}));
+const doEnableVideo = createAppAsyncThunk("localParticipant/doEnableVideo", (payload, { getState }) => __awaiter(void 0, void 0, void 0, function* () {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("enable_video", { enabled: payload.enabled });
+    return payload.enabled;
+}));
+const doSetDisplayName = createAppAsyncThunk("localParticipant/doSetDisplayName", (payload, { getState }) => __awaiter(void 0, void 0, void 0, function* () {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    socket === null || socket === void 0 ? void 0 : socket.emit("send_client_metadata", {
+        type: "UserData",
+        payload,
+    });
+    return payload.displayName;
+}));
+const localParticipantSlice = toolkit.createSlice({
+    name: "localParticipant",
+    initialState: initialState$8,
+    reducers: {
+        doSetLocalParticipant: (state, action) => {
+            return Object.assign(Object.assign({}, state), action.payload);
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(doAppJoin, (state, action) => {
+            return Object.assign(Object.assign({}, state), { displayName: action.payload.displayName });
+        });
+        builder.addCase(doEnableAudio.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { isAudioEnabled: action.payload });
+        });
+        builder.addCase(doEnableVideo.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { isVideoEnabled: action.payload });
+        });
+        builder.addCase(doSetDisplayName.fulfilled, (state, action) => {
+            return Object.assign(Object.assign({}, state), { displayName: action.payload });
+        });
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            var _a, _b;
+            const client = (_b = (_a = action.payload) === null || _a === void 0 ? void 0 : _a.room) === null || _b === void 0 ? void 0 : _b.clients.find((c) => { var _a; return c.id === ((_a = action.payload) === null || _a === void 0 ? void 0 : _a.selfId); });
+            return Object.assign(Object.assign({}, state), { id: action.payload.selfId, clientClaim: action.payload.clientClaim, roleName: (client === null || client === void 0 ? void 0 : client.role.roleName) || "" });
+        });
+    },
+});
+const { doSetLocalParticipant } = localParticipantSlice.actions;
+const selectLocalParticipantRaw = (state) => state.localParticipant;
+const selectSelfId = (state) => state.localParticipant.id;
+const selectLocalParticipantClientClaim = (state) => state.localParticipant.clientClaim;
+const selectLocalParticipantRole = (state) => state.localParticipant.roleName;
+const selectLocalParticipantIsScreenSharing = (state) => state.localParticipant.isScreenSharing;
+startAppListening({
+    actionCreator: toggleCameraEnabled,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { enabled } = payload;
+        const { isVideoEnabled } = selectLocalParticipantRaw(getState());
+        dispatch(doEnableVideo({ enabled: enabled || !isVideoEnabled }));
+    },
+});
+startAppListening({
+    actionCreator: toggleMicrophoneEnabled,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { enabled } = payload;
+        const { isAudioEnabled } = selectLocalParticipantRaw(getState());
+        dispatch(doEnableAudio({ enabled: enabled || !isAudioEnabled }));
+    },
+});
+
+const initialState$7 = {
+    status: "",
+    stream: null,
+    error: null,
+};
+const localScreenshareSlice = toolkit.createSlice({
+    name: "localScreenshare",
+    initialState: initialState$7,
+    reducers: {
+        stopScreenshare(state, action) {
+            return Object.assign(Object.assign({}, state), { status: "", stream: null });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(doStartScreenshare.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "starting" });
+        });
+        builder.addCase(doStartScreenshare.fulfilled, (state, { payload: { stream } }) => {
+            return Object.assign(Object.assign({}, state), { status: "active", stream });
+        });
+        builder.addCase(doStartScreenshare.rejected, (state, { payload }) => {
+            return Object.assign(Object.assign({}, state), { error: payload, status: "", stream: null });
+        });
+    },
+});
+const { stopScreenshare } = localScreenshareSlice.actions;
+const doStartScreenshare = createAppAsyncThunk("localScreenshare/doStartScreenshare", (_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        const state = getState();
+        const screenshareStream = selectLocalScreenshareStream(state);
+        if (screenshareStream) {
+            return { stream: screenshareStream };
+        }
+        const stream = yield navigator.mediaDevices.getDisplayMedia();
+        const onEnded = () => {
+            dispatch(doStopScreenshare());
+        };
+        if ("oninactive" in stream) {
+            stream.addEventListener("inactive", onEnded);
+        }
+        else {
+            (_a = stream.getVideoTracks()[0]) === null || _a === void 0 ? void 0 : _a.addEventListener("ended", onEnded);
+        }
+        return { stream };
+    }
+    catch (error) {
+        return rejectWithValue(error);
+    }
+}));
+const doStopScreenshare = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const screenshareStream = selectLocalScreenshareStream(state);
+    if (!screenshareStream) {
+        return;
+    }
+    screenshareStream.getTracks().forEach((track) => track.stop());
+    dispatch(stopScreenshare({ stream: screenshareStream }));
+});
+const selectLocalScreenshareRaw = (state) => state.localScreenshare;
+const selectLocalScreenshareStatus = (state) => state.localScreenshare.status;
+const selectLocalScreenshareStream = (state) => state.localScreenshare.stream;
+startAppListening({
+    actionCreator: localMediaStopped,
+    effect: (_, { getState }) => {
+        const state = getState();
+        const screenshareStream = selectLocalScreenshareStream(state);
+        if (!screenshareStream) {
+            return;
+        }
+        screenshareStream === null || screenshareStream === void 0 ? void 0 : screenshareStream.getTracks().forEach((track) => {
+            track.stop();
+        });
+    },
+});
+
+const initialState$6 = {
+    data: null,
+    isFetching: false,
+    error: null,
+};
+const organizationSlice = toolkit.createSlice({
+    initialState: initialState$6,
+    name: "organization",
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(doOrganizationFetch.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: true });
+        });
+        builder.addCase(doOrganizationFetch.fulfilled, (state, action) => {
+            if (!action.payload)
+                return Object.assign(Object.assign({}, state), { isFetching: true });
+            return Object.assign(Object.assign({}, state), { isFetching: false, data: action.payload });
+        });
+        builder.addCase(doOrganizationFetch.rejected, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: false, error: true });
+        });
+    },
+});
+const doOrganizationFetch = createAppAsyncThunk("organization/doOrganizationFetch", (_, { extra, getState }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const roomUrl = selectAppRoomUrl(getState());
+        const organization = yield extra.services.fetchOrganizationFromRoomUrl(roomUrl || "");
+        if (!organization) {
+            throw new Error("Invalid room url");
+        }
+        return organization;
+    }
+    catch (error) {
+        console.error(error);
+    }
+}));
+const selectOrganizationRaw = (state) => state.organization;
+const selectOrganizationId = (state) => { var _a; return (_a = state.organization.data) === null || _a === void 0 ? void 0 : _a.organizationId; };
+const selectShouldFetchOrganization = toolkit.createSelector(selectAppWantsToJoin, selectOrganizationRaw, selectDeviceCredentialsRaw, (wantsToJoin, organization, deviceCredentials) => {
+    if (wantsToJoin &&
+        !organization.data &&
+        !organization.isFetching &&
+        !organization.error &&
+        !deviceCredentials.isFetching) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldFetchOrganization], ({ dispatch }, shouldFetchOrganization) => {
+    if (shouldFetchOrganization) {
+        dispatch(doOrganizationFetch());
+    }
+});
+
+function createRtcEventAction(name) {
+    return toolkit.createAction(`rtcConnection/event/${name}`);
+}
+const rtcEvents = {
+    rtcManagerCreated: createRtcEventAction("rtcManagerCreated"),
+    rtcManagerDestroyed: createRtcEventAction("rtcManagerDestroyed"),
+    streamAdded: createRtcEventAction("streamAdded"),
+};
+
+const NON_PERSON_ROLES = ["recorder", "streamer"];
+function createParticipant(client, newJoiner = false) {
+    const { streams } = client, rest = __rest(client, ["streams"]);
+    return Object.assign(Object.assign({}, rest), { stream: null, streams: streams.map((streamId) => ({ id: streamId, state: newJoiner ? "new_accept" : "to_accept" })), isLocalParticipant: false, presentationStream: null, newJoiner });
+}
+function findParticipant(state, participantId) {
+    const index = state.remoteParticipants.findIndex((c) => c.id === participantId);
+    return { index, participant: state.remoteParticipants[index] };
+}
+function updateParticipant(state, participantId, updates) {
+    const { participant, index } = findParticipant(state, participantId);
+    if (!participant) {
+        console.error(`Did not find client for update ${participantId}`);
+        return state;
+    }
+    return Object.assign(Object.assign({}, state), { remoteParticipants: [
+            ...state.remoteParticipants.slice(0, index),
+            Object.assign(Object.assign({}, participant), updates),
+            ...state.remoteParticipants.slice(index + 1),
+        ] });
+}
+function addParticipant(state, participant) {
+    const { participant: foundParticipant } = findParticipant(state, participant.id);
+    if (foundParticipant) {
+        console.warn(`Client already existing ${participant.id}. Ignoring`);
+        return state;
+    }
+    return Object.assign(Object.assign({}, state), { remoteParticipants: [...state.remoteParticipants, participant] });
+}
+function updateStreamState(state, participantId, streamId, state_) {
+    const { participant } = findParticipant(state, participantId);
+    if (!participant) {
+        console.error(`No client ${participantId} found to update stream ${streamId} ${state_}`);
+        return state;
+    }
+    const idIdx = participant.streams.findIndex((s) => s.id === streamId);
+    const streams = [...participant.streams];
+    streams[idIdx] = Object.assign(Object.assign({}, streams[idIdx]), { state: state_ });
+    return updateParticipant(state, participantId, { streams });
+}
+function removeClient(state, participantId) {
+    return Object.assign(Object.assign({}, state), { remoteParticipants: state.remoteParticipants.filter((c) => c.id !== participantId) });
+}
+function addStreamId(state, participantId, streamId) {
+    const { participant } = findParticipant(state, participantId);
+    if (!participant || participant.streams.find((s) => s.id === streamId)) {
+        console.warn(`No participant ${participantId} or stream ${streamId} already exists`);
+        return state;
+    }
+    return updateParticipant(state, participantId, {
+        streams: [...participant.streams, { id: streamId, state: "to_accept" }],
+    });
+}
+function removeStreamId(state, participantId, streamId) {
+    var _a, _b;
+    const { participant } = findParticipant(state, participantId);
+    if (!participant) {
+        console.error(`No participant ${participantId} found to remove stream ${streamId}`);
+        return state;
+    }
+    const currentStreamId = participant.stream && participant.stream.id;
+    const presentationId = ((_a = participant.presentationStream) === null || _a === void 0 ? void 0 : _a.inboundId) || ((_b = participant.presentationStream) === null || _b === void 0 ? void 0 : _b.id);
+    const idIdx = participant.streams.findIndex((s) => s.id === streamId);
+    return updateParticipant(state, participantId, Object.assign(Object.assign({ streams: participant.streams.filter((_, i) => i !== idIdx) }, (currentStreamId === streamId && { stream: null })), (presentationId === streamId && { presentationStream: null })));
+}
+function addStream(state, payload) {
+    const { clientId, stream, streamType } = payload;
+    let { streamId } = payload;
+    const { participant } = findParticipant(state, clientId);
+    if (!participant) {
+        console.error(`Did not find client ${clientId} for adding stream`);
+        return state;
+    }
+    const remoteParticipants = state.remoteParticipants;
+    if (!streamId) {
+        streamId = stream.id;
+    }
+    const remoteParticipant = remoteParticipants.find((p) => p.id === clientId);
+    if (!remoteParticipant) {
+        return state;
+    }
+    const remoteParticipantStream = remoteParticipant.streams.find((s) => s.id === streamId);
+    if ((remoteParticipant.stream &&
+        (remoteParticipant.stream.id === streamId || remoteParticipant.stream.inboundId === streamId)) ||
+        (!remoteParticipant.stream && streamType === "webcam") ||
+        (!remoteParticipant.stream && !streamType && !remoteParticipantStream)) {
+        return updateParticipant(state, clientId, { stream });
+    }
+    return updateParticipant(state, clientId, {
+        presentationStream: stream,
+    });
+}
+const initialState$5 = {
+    remoteParticipants: [],
+};
+const remoteParticipantsSlice = toolkit.createSlice({
+    name: "remoteParticipants",
+    initialState: initialState$5,
+    reducers: {
+        streamStatusUpdated: (state, action) => {
+            let newState = state;
+            for (const { clientId, streamId, state } of action.payload) {
+                newState = updateStreamState(newState, clientId, streamId, state);
+            }
+            return newState;
+        },
+        participantStreamAdded: (state, action) => {
+            const { clientId, stream } = action.payload;
+            return updateParticipant(state, clientId, {
+                stream,
+            });
+        },
+        participantStreamIdAdded: (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return addStreamId(state, clientId, streamId);
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            var _a;
+            if (!((_a = action.payload) === null || _a === void 0 ? void 0 : _a.room))
+                return state;
+            const selfId = action.payload.selfId;
+            const { clients } = action.payload.room;
+            return Object.assign(Object.assign({}, state), { remoteParticipants: clients
+                    .filter((c) => c.id !== selfId)
+                    .filter((c) => !NON_PERSON_ROLES.includes(c.role.roleName))
+                    .map((c) => createParticipant(c)) });
+        });
+        builder.addCase(rtcEvents.streamAdded, (state, action) => {
+            return addStream(state, action.payload);
+        });
+        builder.addCase(signalEvents.newClient, (state, action) => {
+            const { client } = action.payload;
+            if (NON_PERSON_ROLES.includes(client.role.roleName)) {
+                return state;
+            }
+            return addParticipant(state, createParticipant(client, true));
+        });
+        builder.addCase(signalEvents.clientLeft, (state, action) => {
+            const { clientId } = action.payload;
+            return removeClient(state, clientId);
+        });
+        builder.addCase(signalEvents.audioEnabled, (state, action) => {
+            const { clientId, isAudioEnabled } = action.payload;
+            return updateParticipant(state, clientId, {
+                isAudioEnabled,
+            });
+        });
+        builder.addCase(signalEvents.videoEnabled, (state, action) => {
+            const { clientId, isVideoEnabled } = action.payload;
+            return updateParticipant(state, clientId, {
+                isVideoEnabled,
+            });
+        });
+        builder.addCase(signalEvents.clientMetadataReceived, (state, action) => {
+            const { clientId, displayName } = action.payload.payload;
+            return updateParticipant(state, clientId, {
+                displayName,
+            });
+        });
+        builder.addCase(signalEvents.screenshareStarted, (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return addStreamId(state, clientId, streamId);
+        });
+        builder.addCase(signalEvents.screenshareStopped, (state, action) => {
+            const { clientId, streamId } = action.payload;
+            return removeStreamId(state, clientId, streamId);
+        });
+    },
+});
+const { participantStreamAdded, participantStreamIdAdded, streamStatusUpdated } = remoteParticipantsSlice.actions;
+const selectRemoteParticipantsRaw = (state) => state.remoteParticipants;
+const selectRemoteParticipants = (state) => state.remoteParticipants.remoteParticipants;
+const selectScreenshares = toolkit.createSelector(selectLocalScreenshareStream, selectRemoteParticipants, (localScreenshareStream, remoteParticipants) => {
+    const screenshares = [];
+    if (localScreenshareStream) {
+        screenshares.push({
+            id: localScreenshareStream.id,
+            participantId: "local",
+            hasAudioTrack: localScreenshareStream.getAudioTracks().length > 0,
+            stream: localScreenshareStream,
+            isLocal: true,
+        });
+    }
+    for (const participant of remoteParticipants) {
+        if (participant.presentationStream) {
+            screenshares.push({
+                id: participant.presentationStream.id,
+                participantId: participant.id,
+                hasAudioTrack: participant.presentationStream.getAudioTracks().length > 0,
+                stream: participant.presentationStream,
+                isLocal: false,
+            });
+        }
+    }
+    return screenshares;
+});
+
+const initialState$4 = {
+    session: null,
+    status: "initializing",
+    error: null,
+};
+const roomConnectionSlice = toolkit.createSlice({
+    initialState: initialState$4,
+    name: "roomConnection",
+    reducers: {
+        connectionStatusChanged: (state, action) => {
+            return Object.assign(Object.assign({}, state), { status: action.payload });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            var _a, _b;
+            const { error, isLocked } = action.payload;
+            if (error === "room_locked" && isLocked) {
+                return Object.assign(Object.assign({}, state), { status: "room_locked" });
+            }
+            if (error) {
+                return Object.assign(Object.assign({}, state), { status: "disconnected", error });
+            }
+            return Object.assign(Object.assign({}, state), { status: "connected", session: (_b = (_a = action.payload.room) === null || _a === void 0 ? void 0 : _a.session) !== null && _b !== void 0 ? _b : null });
+        });
+        builder.addCase(signalEvents.disconnect, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "disconnected" });
+        });
+        builder.addCase(signalEvents.newClient, (state, action) => {
+            var _a, _b;
+            return Object.assign(Object.assign({}, state), { session: (_b = (_a = action.payload.room) === null || _a === void 0 ? void 0 : _a.session) !== null && _b !== void 0 ? _b : null });
+        });
+        builder.addCase(signalEvents.roomSessionEnded, (state, action) => {
+            var _a;
+            if (((_a = state.session) === null || _a === void 0 ? void 0 : _a.id) !== action.payload.roomSessionId) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { session: null });
+        });
+        builder.addCase(signalEvents.clientKicked, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "kicked" });
+        });
+        builder.addCase(socketReconnecting, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "reconnect" });
+        });
+    },
+});
+const { connectionStatusChanged } = roomConnectionSlice.actions;
+const doKnockRoom = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const roomName = selectAppRoomName(state);
+    const roomKey = selectAppRoomKey(state);
+    const displayName = selectAppDisplayName(state);
+    const sdkVersion = selectAppSdkVersion(state);
+    const externalId = selectAppExternalId(state);
+    const organizationId = selectOrganizationId(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("knock_room", {
+        avatarUrl: null,
+        config: {
+            isAudioEnabled: true,
+            isVideoEnabled: true,
+        },
+        deviceCapabilities: { canScreenshare: true },
+        displayName,
+        isCoLocated: false,
+        isDevicePermissionDenied: false,
+        kickFromOtherRooms: false,
+        organizationId,
+        roomKey,
+        roomName,
+        selfId: "",
+        userAgent: `browser-sdk:${sdkVersion || "unknown"}`,
+        externalId,
+    });
+    dispatch(connectionStatusChanged("knocking"));
+});
+const doConnectRoom = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const roomName = selectAppRoomName(state);
+    const roomKey = selectAppRoomKey(state);
+    const displayName = selectAppDisplayName(state);
+    const sdkVersion = selectAppSdkVersion(state);
+    const externalId = selectAppExternalId(state);
+    const organizationId = selectOrganizationId(state);
+    const isCameraEnabled = selectIsCameraEnabled(getState());
+    const isMicrophoneEnabled = selectIsMicrophoneEnabled(getState());
+    const selfId = selectSelfId(getState());
+    const clientClaim = selectLocalParticipantClientClaim(getState());
+    socket === null || socket === void 0 ? void 0 : socket.emit("join_room", Object.assign(Object.assign({ avatarUrl: null, config: {
+            isAudioEnabled: isMicrophoneEnabled,
+            isVideoEnabled: isCameraEnabled,
+        }, deviceCapabilities: { canScreenshare: true }, displayName, isCoLocated: false, isDevicePermissionDenied: false, kickFromOtherRooms: false, organizationId,
+        roomKey,
+        roomName,
+        selfId }, (!!clientClaim && { clientClaim })), { userAgent: `browser-sdk:${sdkVersion || "unknown"}`, externalId }));
+    dispatch(connectionStatusChanged("connecting"));
+});
+const selectRoomConnectionRaw = (state) => state.roomConnection;
+const selectRoomConnectionSession = (state) => state.roomConnection.session;
+const selectRoomConnectionSessionId = (state) => { var _a; return (_a = state.roomConnection.session) === null || _a === void 0 ? void 0 : _a.id; };
+const selectRoomConnectionStatus = (state) => state.roomConnection.status;
+const selectRoomConnectionError = (state) => state.roomConnection.error;
+const selectShouldConnectRoom = toolkit.createSelector([
+    selectOrganizationId,
+    selectRoomConnectionStatus,
+    selectSignalConnectionDeviceIdentified,
+    selectLocalMediaStatus,
+    selectAppIsNodeSdk,
+], (hasOrganizationIdFetched, roomConnectionStatus, signalConnectionDeviceIdentified, localMediaStatus, isNodeSdk) => {
+    if ((localMediaStatus === "started" || isNodeSdk) &&
+        signalConnectionDeviceIdentified &&
+        !!hasOrganizationIdFetched &&
+        ["initializing", "reconnect"].includes(roomConnectionStatus)) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldConnectRoom], ({ dispatch }, shouldConnectRoom) => {
+    if (shouldConnectRoom) {
+        dispatch(doConnectRoom());
+    }
+});
+startAppListening({
+    actionCreator: signalEvents.knockHandled,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { clientId, resolution } = payload;
+        const state = getState();
+        const selfId = selectSelfId(state);
+        if (clientId !== selfId) {
+            return;
+        }
+        if (resolution === "accepted") {
+            dispatch(setRoomKey(payload.metadata.roomKey));
+            dispatch(doConnectRoom());
+        }
+        else if (resolution === "rejected") {
+            dispatch(connectionStatusChanged("knock_rejected"));
+        }
+    },
+});
+
+const createWebRtcEmitter = (dispatch) => {
+    return {
+        emit: (eventName, data) => {
+            if (eventName === "rtc_manager_created") {
+                dispatch(doRtcManagerCreated(data));
+            }
+            else if (eventName === "stream_added") {
+                dispatch(rtcEvents.streamAdded(data));
+            }
+            else if (eventName === "rtc_manager_destroyed") {
+                dispatch(rtcManagerDestroyed());
+            }
+            else ;
+        },
+    };
+};
+const initialState$3 = {
+    dispatcherCreated: false,
+    error: null,
+    isCreatingDispatcher: false,
+    reportedStreamResolutions: {},
+    rtcManager: null,
+    rtcManagerDispatcher: null,
+    rtcManagerInitialized: false,
+    status: "",
+    isAcceptingStreams: false,
+};
+const rtcConnectionSlice = toolkit.createSlice({
+    name: "rtcConnection",
+    initialState: initialState$3,
+    reducers: {
+        isAcceptingStreams: (state, action) => {
+            return Object.assign(Object.assign({}, state), { isAcceptingStreams: action.payload });
+        },
+        resolutionReported: (state, action) => {
+            const { streamId, width, height } = action.payload;
+            return Object.assign(Object.assign({}, state), { reportedStreamResolutions: Object.assign(Object.assign({}, state.reportedStreamResolutions), { [streamId]: { width, height } }) });
+        },
+        rtcDisconnected: () => {
+            return Object.assign({}, initialState$3);
+        },
+        rtcDispatcherCreated: (state, action) => {
+            return Object.assign(Object.assign({}, state), { dispatcherCreated: true, rtcManagerDispatcher: action.payload });
+        },
+        rtcManagerCreated: (state, action) => {
+            return Object.assign(Object.assign({}, state), { rtcManager: action.payload, status: "ready" });
+        },
+        rtcManagerDestroyed: (state) => {
+            return Object.assign(Object.assign({}, state), { rtcManager: null });
+        },
+        rtcManagerInitialized: (state) => {
+            return Object.assign(Object.assign({}, state), { rtcManagerInitialized: true });
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(socketReconnecting, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "reconnect" });
+        });
+        builder.addCase(signalEvents.roomJoined, (state) => {
+            return Object.assign(Object.assign({}, state), { status: state.status === "reconnect" ? "ready" : state.status });
+        });
+    },
+});
+const { resolutionReported, rtcDispatcherCreated, rtcDisconnected, rtcManagerCreated, rtcManagerDestroyed, rtcManagerInitialized, isAcceptingStreams, } = rtcConnectionSlice.actions;
+const doConnectRtc = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const dispatcher = selectRtcConnectionRaw(state).rtcManagerDispatcher;
+    const isCameraEnabled = selectIsCameraEnabled(state);
+    const isMicrophoneEnabled = selectIsMicrophoneEnabled(state);
+    const isNodeSdk = selectAppIsNodeSdk(state);
+    if (dispatcher || !socket) {
+        return;
+    }
+    const webrtcProvider = {
+        getMediaConstraints: () => ({
+            audio: isMicrophoneEnabled,
+            video: isCameraEnabled,
+        }),
+        deferrable(clientId) {
+            return !clientId;
+        },
+    };
+    const rtcManagerDispatcher = new media.RtcManagerDispatcher({
+        emitter: createWebRtcEmitter(dispatch),
+        serverSocket: socket,
+        webrtcProvider,
+        features: {
+            lowDataModeEnabled: false,
+            sfuServerOverrideHost: undefined,
+            turnServerOverrideHost: undefined,
+            useOnlyTURN: undefined,
+            vp9On: false,
+            h264On: false,
+            simulcastScreenshareOn: false,
+            deviceHandlerFactory: isNodeSdk ? Chrome111_js.Chrome111.createFactory() : undefined,
+        },
+    });
+    dispatch(rtcDispatcherCreated(rtcManagerDispatcher));
+});
+const doDisconnectRtc = createAppThunk(() => (dispatch, getState) => {
+    const { rtcManager } = selectRtcConnectionRaw(getState());
+    if (rtcManager) {
+        rtcManager.disconnectAll();
+    }
+    dispatch(rtcDisconnected());
+});
+const doHandleAcceptStreams = createAppThunk((payload) => (dispatch, getState) => {
+    var _a;
+    dispatch(isAcceptingStreams(true));
+    const state = getState();
+    const rtcManager = selectRtcConnectionRaw(state).rtcManager;
+    const remoteParticipants = selectRemoteParticipants(state);
+    if (!rtcManager) {
+        throw new Error("No rtc manager");
+    }
+    const activeBreakout = false;
+    const shouldAcceptNewClients = (_a = rtcManager.shouldAcceptStreamsFromBothSides) === null || _a === void 0 ? void 0 : _a.call(rtcManager);
+    const updates = [];
+    for (const { clientId, streamId, state } of payload) {
+        const participant = remoteParticipants.find((p) => p.id === clientId);
+        if (!participant)
+            continue;
+        if (state === "to_accept" ||
+            (state === "new_accept" && shouldAcceptNewClients) ||
+            (state === "old_accept" && !shouldAcceptNewClients)) {
+            rtcManager.acceptNewStream({
+                streamId: streamId === "0" ? clientId : streamId,
+                clientId,
+                shouldAddLocalVideo: streamId === "0",
+                activeBreakout,
+            });
+        }
+        else if (state === "new_accept" || state === "old_accept") ;
+        else if (state === "to_unaccept") {
+            rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.disconnect(streamId === "0" ? clientId : streamId, activeBreakout);
+        }
+        else if (state !== "done_accept") {
+            continue;
+        }
+        else ;
+        updates.push({ clientId, streamId, state: state.replace(/to_|new_|old_/, "done_") });
+    }
+    dispatch(streamStatusUpdated(updates));
+    dispatch(isAcceptingStreams(false));
+});
+const doRtcReportStreamResolution = createAppThunk(({ streamId, width, height }) => (dispatch, getState) => {
+    const { reportedStreamResolutions, rtcManager } = selectRtcConnectionRaw(getState());
+    const localStream = selectLocalMediaStream(getState());
+    if (!rtcManager || (localStream === null || localStream === void 0 ? void 0 : localStream.id) === streamId) {
+        return;
+    }
+    const old = reportedStreamResolutions[streamId];
+    if (!old || old.width !== width || old.height !== height) {
+        rtcManager.updateStreamResolution(streamId, null, { width: width || 1, height: height || 1 });
+    }
+    dispatch(resolutionReported({ streamId, width, height }));
+});
+const doRtcManagerCreated = createAppThunk((payload) => (dispatch) => {
+    const { rtcManager } = payload;
+    dispatch(rtcManagerCreated(rtcManager));
+});
+const doRtcManagerInitialize = createAppThunk(() => (dispatch, getState) => {
+    const localMediaStream = selectLocalMediaStream(getState());
+    const rtcManager = selectRtcConnectionRaw(getState()).rtcManager;
+    const isCameraEnabled = selectIsCameraEnabled(getState());
+    const isMicrophoneEnabled = selectIsMicrophoneEnabled(getState());
+    if (localMediaStream && rtcManager) {
+        rtcManager.addNewStream("0", localMediaStream, !isMicrophoneEnabled, !isCameraEnabled);
+    }
+    dispatch(rtcManagerInitialized());
+});
+const selectRtcConnectionRaw = (state) => state.rtcConnection;
+const selectRtcManagerInitialized = (state) => state.rtcConnection.rtcManagerInitialized;
+const selectRtcManager = (state) => state.rtcConnection.rtcManager;
+const selectRtcDispatcherCreated = (state) => state.rtcConnection.dispatcherCreated;
+const selectRtcIsCreatingDispatcher = (state) => state.rtcConnection.isCreatingDispatcher;
+const selectRtcStatus = (state) => state.rtcConnection.status;
+const selectIsAcceptingStreams = (state) => state.rtcConnection.isAcceptingStreams;
+startAppListening({
+    actionCreator: doSetDevice.fulfilled,
+    effect: ({ payload }, { getState }) => {
+        const { replacedTracks } = payload;
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        const stream = selectLocalMediaStream(getState());
+        const replace = (kind, oldTrack) => {
+            const track = stream === null || stream === void 0 ? void 0 : stream.getTracks().find((t) => t.kind === kind);
+            return track && (rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.replaceTrack(oldTrack, track));
+        };
+        replacedTracks === null || replacedTracks === void 0 ? void 0 : replacedTracks.forEach((t) => {
+            replace(t.kind, t);
+        });
+    },
+});
+startAppListening({
+    actionCreator: doStartScreenshare.fulfilled,
+    effect: ({ payload }, { getState }) => {
+        const { stream } = payload;
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.addNewStream(stream.id, stream, false, true);
+    },
+});
+startAppListening({
+    actionCreator: stopScreenshare,
+    effect: ({ payload }, { getState }) => {
+        const { stream } = payload;
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.removeStream(stream.id, stream, null);
+    },
+});
+const selectShouldConnectRtc = toolkit.createSelector(selectRtcDispatcherCreated, selectRtcIsCreatingDispatcher, selectSignalConnectionSocket, (dispatcherCreated, isCreatingDispatcher, signalSocket) => {
+    if (!dispatcherCreated && !isCreatingDispatcher && signalSocket) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldConnectRtc], ({ dispatch }, shouldConnectRtc) => {
+    if (shouldConnectRtc) {
+        dispatch(doConnectRtc());
+    }
+});
+const selectShouldInitializeRtc = toolkit.createSelector(selectRtcManager, selectRtcManagerInitialized, selectLocalMediaStatus, (rtcManager, rtcManagerInitialized, localMediaStatus) => {
+    if (localMediaStatus === "started" && rtcManager && !rtcManagerInitialized) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldInitializeRtc], ({ dispatch }, shouldInitializeRtc) => {
+    if (shouldInitializeRtc) {
+        dispatch(doRtcManagerInitialize());
+    }
+});
+const selectShouldDisconnectRtc = toolkit.createSelector(selectRtcStatus, selectAppWantsToJoin, (status, wantsToJoin) => {
+    if (!wantsToJoin && !["", "disconnected"].includes(status)) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldDisconnectRtc], ({ dispatch }, shouldDisconnectRtc) => {
+    if (shouldDisconnectRtc) {
+        dispatch(doDisconnectRtc());
+    }
+});
+const selectStreamsToAccept = toolkit.createSelector(selectRtcStatus, selectRemoteParticipants, (rtcStatus, remoteParticipants) => {
+    if (rtcStatus !== "ready") {
+        return [];
+    }
+    const upd = [];
+    for (const client of remoteParticipants) {
+        const { streams, id: clientId, newJoiner } = client;
+        for (let i = 0; i < streams.length; i++) {
+            let streamId = streams[i].id;
+            let state = streams[i].state;
+            if ((streams === null || streams === void 0 ? void 0 : streams.length) > 1 && streams[1].id === "0") {
+                if (i === 0) {
+                    streamId = streams[1].id;
+                    state = streams[1].state;
+                }
+                else if (i === 1) {
+                    streamId = streams[0].id;
+                    state = streams[0].state;
+                }
+            }
+            {
+                if (state === "done_accept")
+                    continue;
+                upd.push({
+                    clientId,
+                    streamId,
+                    state: `${newJoiner && streamId === "0" ? "new" : "to"}_accept`,
+                });
+            }
+        }
+    }
+    return upd;
+});
+createReactor([selectStreamsToAccept, selectIsAcceptingStreams], ({ dispatch }, streamsToAccept, isAcceptingStreams) => {
+    if (0 < streamsToAccept.length && !isAcceptingStreams) {
+        dispatch(doHandleAcceptStreams(streamsToAccept));
+    }
+});
+
+const rtcAnalyticsCustomEvents = {
+    audioEnabled: {
+        actions: [doEnableAudio.fulfilled],
+        rtcEventName: "audioEnabled",
+        getValue: (state) => selectIsMicrophoneEnabled(state),
+        getOutput: (value) => ({ enabled: value }),
+    },
+    videoEnabled: {
+        actions: [doEnableVideo.fulfilled],
+        rtcEventName: "videoEnabled",
+        getValue: (state) => selectIsCameraEnabled(state),
+        getOutput: (value) => ({ enabled: value }),
+    },
+    localStream: {
+        actions: [doSetDevice.fulfilled],
+        rtcEventName: "localStream",
+        getValue: (state) => {
+            var _a;
+            return (_a = selectLocalMediaStream(state)) === null || _a === void 0 ? void 0 : _a.getTracks().map((track) => ({ id: track.id, kind: track.kind, label: track.label }));
+        },
+        getOutput: (value) => ({ stream: value }),
+    },
+    localScreenshareStream: {
+        actions: [doStartScreenshare.fulfilled],
+        rtcEventName: "localScreenshareStream",
+        getValue: (state) => {
+            var _a;
+            return (_a = selectLocalScreenshareStream(state)) === null || _a === void 0 ? void 0 : _a.getTracks().map((track) => ({ id: track.id, kind: track.kind, label: track.label }));
+        },
+        getOutput: (value) => ({ tracks: value }),
+    },
+    localScreenshareStreamStopped: {
+        actions: [stopScreenshare],
+        rtcEventName: "localScreenshareStream",
+        getValue: () => () => null,
+        getOutput: () => ({}),
+    },
+    displayName: {
+        actions: [doSetDisplayName.fulfilled],
+        rtcEventName: "displayName",
+        getValue: (state) => selectAppDisplayName(state),
+        getOutput: (value) => ({ displayName: value }),
+    },
+    clientId: {
+        actions: null,
+        rtcEventName: "clientId",
+        getValue: (state) => selectSelfId(state),
+        getOutput: (value) => ({ clientId: value }),
+    },
+    deviceId: {
+        actions: null,
+        rtcEventName: "deviceId",
+        getValue: (state) => selectDeviceId(state),
+        getOutput: (value) => ({ deviceId: value }),
+    },
+    externalId: {
+        actions: null,
+        rtcEventName: "externalId",
+        getValue: (state) => selectAppExternalId(state),
+        getOutput: (value) => ({ externalId: value }),
+    },
+    organizationId: {
+        actions: null,
+        rtcEventName: "organizationId",
+        getValue: (state) => selectOrganizationId(state),
+        getOutput: (value) => ({ organizationId: value }),
+    },
+    signalConnectionStatus: {
+        actions: null,
+        rtcEventName: "signalConnectionStatus",
+        getValue: (state) => selectSignalStatus(state),
+        getOutput: (value) => ({ status: value }),
+    },
+    roomSessionId: {
+        actions: [
+            signalEvents.newClient,
+            signalEvents.roomJoined,
+            signalEvents.roomSessionEnded,
+            signalEvents.clientLeft,
+        ],
+        rtcEventName: "roomSessionId",
+        getValue: (state) => selectRoomConnectionSessionId(state),
+        getOutput: (value) => ({ roomSessionId: value }),
+    },
+    rtcConnectionStatus: {
+        actions: null,
+        rtcEventName: "rtcConnectionStatus",
+        getValue: (state) => selectRtcStatus(state),
+        getOutput: (value) => ({ status: value }),
+    },
+    userRole: {
+        actions: null,
+        rtcEventName: "userRole",
+        getValue: (state) => selectLocalParticipantRole(state),
+        getOutput: (value) => ({ userRole: value }),
+    },
+};
+const rtcCustomEventActions = Object.values(rtcAnalyticsCustomEvents)
+    .flatMap(({ actions }) => { var _a; return (_a = actions === null || actions === void 0 ? void 0 : actions.map((action) => action)) !== null && _a !== void 0 ? _a : null; })
+    .filter((action) => action !== null);
+const makeComparable = (value) => {
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return value;
+};
+const initialState$2 = {
+    reportedValues: {},
+};
+const rtcAnalyticsSlice = toolkit.createSlice({
+    initialState: initialState$2,
+    name: "rtcAnalytics",
+    reducers: {
+        updateReportedValues(state, action) {
+            return Object.assign(Object.assign({}, state), { reportedValues: Object.assign(Object.assign({}, state.reportedValues), { [action.payload.rtcEventName]: action.payload.value }) });
+        },
+    },
+});
+const doRtcAnalyticsCustomEventsInitialize = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const rtcManager = selectRtcConnectionRaw(state).rtcManager;
+    if (!rtcManager)
+        return;
+    rtcManager.sendStatsCustomEvent("insightsStats", {
+        _time: Date.now(),
+        ls: 0,
+        lr: 0,
+        bs: 0,
+        br: 0,
+        cpu: 0,
+    });
+    Object.values(rtcAnalyticsCustomEvents).forEach(({ rtcEventName, getValue, getOutput }) => {
+        var _a;
+        const value = getValue(state);
+        const output = Object.assign(Object.assign({}, getOutput(value)), { _time: Date.now() });
+        const comparableValue = makeComparable(value);
+        if (((_a = state.rtcAnalytics.reportedValues) === null || _a === void 0 ? void 0 : _a[rtcEventName]) !== comparableValue) {
+            rtcManager.sendStatsCustomEvent(rtcEventName, output);
+            dispatch(updateReportedValues({ rtcEventName, value }));
+        }
+    });
+});
+const { updateReportedValues } = rtcAnalyticsSlice.actions;
+startAppListening({
+    matcher: toolkit.isAnyOf(...rtcCustomEventActions),
+    effect: ({ type }, { getState, dispatch }) => {
+        var _a;
+        const state = getState();
+        const rtcManager = selectRtcConnectionRaw(state).rtcManager;
+        if (!rtcManager)
+            return;
+        const rtcCustomEvent = Object.values(rtcAnalyticsCustomEvents).find(({ actions }) => actions === null || actions === void 0 ? void 0 : actions.map((a) => a.type).includes(type));
+        if (!rtcCustomEvent)
+            return;
+        const { getValue, getOutput, rtcEventName } = rtcCustomEvent;
+        const value = getValue(state);
+        const comparableValue = makeComparable(value);
+        const output = Object.assign(Object.assign({}, getOutput(value)), { _time: Date.now() });
+        if (((_a = state.rtcAnalytics.reportedValues) === null || _a === void 0 ? void 0 : _a[rtcEventName]) !== comparableValue) {
+            rtcManager.sendStatsCustomEvent(rtcEventName, output);
+            dispatch(updateReportedValues({ rtcEventName, value }));
+        }
+    },
+});
+createReactor([selectRtcManagerInitialized], ({ dispatch }, selectRtcManagerInitialized) => {
+    if (selectRtcManagerInitialized) {
+        dispatch(doRtcAnalyticsCustomEventsInitialize());
+    }
+});
+
+const initialState$1 = {
+    isStreaming: false,
+    error: null,
+    startedAt: undefined,
+};
+const streamingSlice = toolkit.createSlice({
+    name: "streaming",
+    initialState: initialState$1,
+    reducers: {
+        doHandleStreamingStarted: (state) => {
+            return Object.assign(Object.assign({}, state), { isStreaming: true, error: null, startedAt: new Date().getTime() });
+        },
+        doHandleStreamingStopped: (state) => {
+            return Object.assign(Object.assign({}, state), { isStreaming: false });
+        },
+    },
+});
+const { doHandleStreamingStarted, doHandleStreamingStopped } = streamingSlice.actions;
+const selectStreamingRaw = (state) => state.streaming;
+
+const initialState = {
+    waitingParticipants: [],
+};
+const waitingParticipantsSlice = toolkit.createSlice({
+    name: "waitingParticipants",
+    initialState,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(signalEvents.roomJoined, (state, { payload }) => {
+            var _a;
+            if ((_a = payload.room) === null || _a === void 0 ? void 0 : _a.knockers.length) {
+                return Object.assign(Object.assign({}, state), { waitingParticipants: payload.room.knockers.map((knocker) => ({
+                        id: knocker.clientId,
+                        displayName: knocker.displayName,
+                    })) });
+            }
+            else {
+                return state;
+            }
+        });
+        builder.addCase(signalEvents.roomKnocked, (state, action) => {
+            const { clientId, displayName } = action.payload;
+            return Object.assign(Object.assign({}, state), { waitingParticipants: [...state.waitingParticipants, { id: clientId, displayName }] });
+        });
+        builder.addCase(signalEvents.knockerLeft, (state, action) => {
+            const { clientId } = action.payload;
+            return Object.assign(Object.assign({}, state), { waitingParticipants: state.waitingParticipants.filter((p) => p.id !== clientId) });
+        });
+    },
+});
+const doAcceptWaitingParticipant = createAppThunk((payload) => (dispatch, getState) => {
+    const { participantId } = payload;
+    const state = getState();
+    const socket = selectSignalConnectionSocket(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("handle_knock", {
+        action: "accept",
+        clientId: participantId,
+        response: {},
+    });
+});
+const doRejectWaitingParticipant = createAppThunk((payload) => (dispatch, getState) => {
+    const { participantId } = payload;
+    const state = getState();
+    const socket = selectSignalConnectionSocket(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("handle_knock", {
+        action: "reject",
+        clientId: participantId,
+        response: {},
+    });
+});
+const selectWaitingParticipantsRaw = (state) => state.waitingParticipants;
+const selectWaitingParticipants = (state) => state.waitingParticipants.waitingParticipants;
+
+var _a;
+const IS_DEV = (_a = undefined === "true") !== null && _a !== void 0 ? _a : false;
+const rootReducer = toolkit.combineReducers({
+    app: appSlice.reducer,
+    chat: chatSlice.reducer,
+    cloudRecording: cloudRecordingSlice.reducer,
+    deviceCredentials: deviceCredentialsSlice.reducer,
+    localMedia: localMediaSlice.reducer,
+    localParticipant: localParticipantSlice.reducer,
+    localScreenshare: localScreenshareSlice.reducer,
+    organization: organizationSlice.reducer,
+    remoteParticipants: remoteParticipantsSlice.reducer,
+    roomConnection: roomConnectionSlice.reducer,
+    rtcAnalytics: rtcAnalyticsSlice.reducer,
+    rtcConnection: rtcConnectionSlice.reducer,
+    signalConnection: signalConnectionSlice.reducer,
+    streaming: streamingSlice.reducer,
+    waitingParticipants: waitingParticipantsSlice.reducer,
+});
+const createStore = ({ preloadedState, injectServices, }) => {
+    return toolkit.configureStore({
+        devTools: IS_DEV,
+        reducer: rootReducer,
+        middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+            thunk: {
+                extraArgument: { services: injectServices },
+            },
+            serializableCheck: false,
+        }).prepend(listenerMiddleware.middleware),
+        preloadedState,
+    });
+};
+const observeStore = (store, select, onChange) => {
+    let currentState;
+    function handleChange() {
+        const nextState = select(store.getState());
+        if (nextState !== currentState) {
+            currentState = nextState;
+            onChange(currentState);
+        }
+    }
+    const unsubscribe = store.subscribe(handleChange);
+    handleChange();
+    return unsubscribe;
+};
+
+class Response {
+    constructor(initialValues = {}) {
+        this.data = initialValues.data === undefined ? {} : initialValues.data;
+        this.headers = initialValues.headers || {};
+        this.status = initialValues.status || 200;
+        this.statusText = initialValues.statusText || "OK";
+        this.url = initialValues.url || null;
+    }
+}
+
+function assertTruthy(value, parameterName) {
+    media.assert.ok(value, `${parameterName} is required`);
+    return value;
+}
+function assertBoolean(value, parameterName) {
+    media.assert.ok(typeof value === "boolean", `${parameterName}<boolean> is required`);
+    return value;
+}
+function assertNumber(value, parameterName) {
+    media.assert.ok(typeof value === "number", `${parameterName}<number> is required`);
+    return value;
+}
+function assertString(value, parameterName) {
+    media.assert.ok(typeof value === "string", `${parameterName}<string> is required`);
+    return value;
+}
+function assertInstanceOf(value, type, parameterName) {
+    const resolvedParameterName = parameterName || type.name[0].toLowerCase() + type.name.substring(1);
+    media.assert.ok(value instanceof type, `${resolvedParameterName}<${type.name}> is required`);
+    return value;
+}
+function assertRoomName(roomName, parameterName = "roomName") {
+    assertString(roomName, parameterName);
+    media.assert.ok(typeof roomName === "string" && roomName[0] === "/", `${parameterName} must begin with a '/'`);
+    return roomName;
+}
+function assertArray(array, parameterName) {
+    media.assert.ok(Array.isArray(array), `${parameterName}<array> is required`);
+    return array;
+}
+function assertOneOf(value, allowedValues, parameterName) {
+    assertTruthy(value, "value");
+    assertArray(allowedValues, "allowedValues");
+    const isAllowed = allowedValues.includes(value);
+    if (!isAllowed) {
+        throw new Error(`${parameterName}<string> must be one of the following: ${allowedValues.join(", ")}`);
+    }
+    return value;
+}
+function assertRecord(ref, name) {
+    if (ref === null || ref === undefined || typeof ref !== "object" || Array.isArray(ref)) {
+        throw new Error(`${name} must be a record. ${JSON.stringify(ref)}`);
+    }
+    return ref;
+}
+function assertNullOrType(ref, type, name, message) {
+    assertString(name, "name");
+    const errorMessage = message || `${name} must be null or of type ${type}`;
+    media.assert.ok(ref === null || typeof ref === type, errorMessage);
+}
+function assertNullOrString(ref, name, message) {
+    assertString(name, "name");
+    assertNullOrType(ref, "string", name, message);
+}
+
+function _getAbsoluteUrl({ baseUrl, url }) {
+    return baseUrl ? baseUrl + url : url;
+}
+class HttpClient {
+    constructor({ baseUrl }) {
+        assertString(baseUrl, "baseUrl");
+        this._baseUrl = baseUrl;
+    }
+    _requestAxios(url, options) {
+        const axiosOptions = Object.assign({}, options, {
+            url,
+            baseURL: this._baseUrl,
+        });
+        return axios.request(axiosOptions);
+    }
+    request(url, options) {
+        assertString(url, "url");
+        media.assert.ok(url[0] === "/", 'url<String> only accepts relative URLs beginning with "/".');
+        media.assert.ok(options, "options are required");
+        return this._requestAxios(url, options)
+            .then((response) => {
+            const { data, headers, status, statusText, config } = response;
+            const requestUrl = config && config.url ? _getAbsoluteUrl({ baseUrl: config.baseURL, url: config.url }) : null;
+            return new Response({
+                data,
+                headers,
+                status,
+                statusText,
+                url: requestUrl,
+            });
+        })
+            .catch((error) => {
+            const responseObject = error.response;
+            if (!responseObject) {
+                throw new Error("Could not make the request.");
+            }
+            const { data, headers, status, statusText, config } = responseObject;
+            const requestUrl = config && config.url ? _getAbsoluteUrl({ baseUrl: config.baseURL, url: config.url }) : null;
+            return Promise.reject(new Response({
+                data,
+                headers,
+                status,
+                statusText,
+                url: requestUrl,
+            }));
+        });
+    }
+}
+
+class MultipartHttpClient {
+    constructor({ httpClient }) {
+        media.assert.ok(httpClient, "httpClient is required");
+        this._httpClient = httpClient;
+    }
+    static dataToFormData(data) {
+        media.assert.ok(data, "data is required");
+        const fd = new FormData();
+        Object.keys(data).forEach((key) => {
+            const value = data[key];
+            fd.append(key, value);
+        });
+        return fd;
+    }
+    request(url, options = {}) {
+        const headers = Object.assign(options.headers || {}, {
+            "Content-Type": undefined,
+        });
+        return this._httpClient.request(url, Object.assign(options, {
+            headers,
+            transformRequest: MultipartHttpClient.dataToFormData,
+        }));
+    }
+}
+
+let btoa;
+if (typeof window === "object") {
+    btoa = window.btoa || nodeBtoa;
+}
+else if (typeof global === "object") {
+    btoa = global.btoa || nodeBtoa;
+}
+else {
+    btoa = nodeBtoa;
+}
+function _getAuthHeader(credentials) {
+    if (credentials && credentials.credentials) {
+        const btoaStr = `${credentials.credentials.uuid}:${credentials.hmac}`;
+        return { Authorization: `Basic ${btoa(btoaStr)}` };
+    }
+    return {};
+}
+const noCredentials = () => Promise.resolve(null);
+class AuthenticatedHttpClient {
+    constructor({ httpClient, fetchDeviceCredentials }) {
+        this._httpClient = httpClient;
+        this._fetchDeviceCredentials = fetchDeviceCredentials;
+    }
+    request(url, options) {
+        return this._fetchDeviceCredentials().then((credentials) => {
+            const headers = Object.assign({}, options.headers, _getAuthHeader(credentials), {
+                "X-Appearin-Device-Platform": "web",
+            });
+            const httpClientOptions = Object.assign({}, options, { headers });
+            return this._httpClient.request(url, httpClientOptions);
+        });
+    }
+}
+class ApiClient {
+    constructor({ baseUrl = "https://api.appearin.net", fetchDeviceCredentials = noCredentials, } = {}) {
+        this.authenticatedHttpClient = new AuthenticatedHttpClient({
+            httpClient: new HttpClient({
+                baseUrl,
+            }),
+            fetchDeviceCredentials,
+        });
+        this.authenticatedFormDataHttpClient = new MultipartHttpClient({ httpClient: this.authenticatedHttpClient });
+    }
+    request(url, options) {
+        assertString(url, "url");
+        media.assert.ok(url[0] === "/", 'url<String> only accepts relative URLs beginning with "/".');
+        media.assert.ok(options, "options are required");
+        return this.authenticatedHttpClient.request(url, options);
+    }
+    requestMultipart(url, options) {
+        assertString(url, "url");
+        media.assert.ok(url[0] === "/", 'url<String> only accepts relative URLs beginning with "/".');
+        media.assert.ok(options, "options are required");
+        return this.authenticatedFormDataHttpClient.request(url, options);
+    }
+}
+
+function nullOrExtract(extract) {
+    return (data, propertyName) => {
+        const record = assertRecord(data, "data");
+        const value = record[propertyName];
+        return value === null || value === undefined ? null : extract(data, propertyName);
+    };
+}
+function extractString(data, propertyName) {
+    const record = assertRecord(data, "data");
+    return assertString(record[propertyName], propertyName);
+}
+const extractNullOrString = nullOrExtract(extractString);
+function extractDate(data, propertyName) {
+    const dateString = extractString(data, propertyName);
+    const d = new Date(dateString);
+    if (isNaN(d.getTime())) {
+        throw new Error(`Invalid date for ${dateString}`);
+    }
+    return d;
+}
+function extractArrayOfJson(data, propertyName) {
+    const record = assertRecord(data, "data");
+    return assertArray(record[propertyName], propertyName);
+}
+function extractArray(data, propertyName, transformer) {
+    return extractArrayOfJson(data, propertyName).map((value) => transformer(value));
+}
+function extractJson(data, propertyName) {
+    const record = assertRecord(data, "data");
+    const value = record[propertyName];
+    return value === undefined ? null : value;
+}
+
+class Credentials {
+    constructor(uuid, hmac, userId = undefined) {
+        this.credentials = {
+            uuid,
+        };
+        this.hmac = hmac;
+        this.userId = userId;
+    }
+    toJson() {
+        return Object.assign({ credentials: this.credentials, hmac: this.hmac }, (this.userId && { userId: this.userId }));
+    }
+    static fromJson(json) {
+        return new Credentials(extractString(extractJson(json, "credentials"), "uuid"), extractString(json, "hmac"), extractNullOrString(json, "userId") || undefined);
+    }
+}
+
+class DeviceService {
+    constructor({ apiClient }) {
+        this._apiClient = apiClient;
+    }
+    getCredentials() {
+        return this._apiClient
+            .request("/devices", {
+            method: "post",
+        })
+            .then(({ data }) => {
+            return Credentials.fromJson(data);
+        })
+            .catch((error) => {
+            if (error.response) {
+                if (error.response.status === 404) {
+                    return null;
+                }
+            }
+            throw error;
+        });
+    }
+}
+
+class ChromeStorageStore {
+    constructor(key, chromeStorage) {
+        this._key = key;
+        this._chromeStorage = chromeStorage;
+    }
+    loadOrDefault(defaultValue) {
+        return new Promise((resolve) => {
+            this._chromeStorage.get(this._key, (result) => {
+                const unknownResult = result;
+                resolve(unknownResult[this._key] || defaultValue);
+            });
+        });
+    }
+    save(value) {
+        return new Promise((resolve) => {
+            this._chromeStorage.set({ [this._key]: value }, () => {
+                resolve();
+            });
+        });
+    }
+}
+
+class LocalStorageStore {
+    constructor(key, localStorage) {
+        assertTruthy(localStorage, "localStorage");
+        this._key = assertString(key, "key");
+        this._localStorage = localStorage;
+    }
+    loadOrDefault(defaultValue) {
+        try {
+            const value = this._localStorage.getItem(this._key);
+            if (value) {
+                try {
+                    return Promise.resolve(JSON.parse(value));
+                }
+                catch (e) {
+                }
+            }
+            return Promise.resolve(defaultValue);
+        }
+        catch (e) {
+            console.warn("Error getting access to storage. Are cookies blocked?", e);
+            return Promise.resolve(defaultValue);
+        }
+    }
+    save(value) {
+        try {
+            this._localStorage.setItem(this._key, JSON.stringify(value));
+            return Promise.resolve();
+        }
+        catch (e) {
+            console.warn("Error getting access to storage. Are cookies blocked?", e);
+            return Promise.reject(e);
+        }
+    }
+}
+
+let localStorage;
+try {
+    localStorage = self.localStorage;
+}
+catch (e) {
+    localStorage = {
+        getItem: () => undefined,
+        key: () => undefined,
+        setItem: () => undefined,
+        removeItem: () => undefined,
+        hasOwnProperty: () => undefined,
+        length: 0,
+    };
+}
+var localStorage$1 = localStorage;
+
+const events = {
+    CREDENTIALS_SAVED: "credentials_saved",
+};
+class CredentialsService extends EventEmitter {
+    constructor({ deviceService, credentialsStore, }) {
+        super();
+        this._deviceService = deviceService;
+        this._credentialsStore = credentialsStore;
+    }
+    static create({ baseUrl, storeName = "CredentialsStorage", storeType = "localStorage", }) {
+        const deviceService = new DeviceService({
+            apiClient: new ApiClient({ baseUrl }),
+        });
+        let credentialsStore = null;
+        if (storeType === "localStorage") {
+            credentialsStore = new LocalStorageStore(storeName, localStorage$1);
+        }
+        else if (storeType === "chromeStorage") {
+            credentialsStore = new ChromeStorageStore(storeName, window["chrome"].storage.local);
+        }
+        else {
+            throw new Error(`Unknown store type: ${storeType}`);
+        }
+        return new CredentialsService({
+            deviceService,
+            credentialsStore,
+        });
+    }
+    _fetchNewCredentialsFromApi() {
+        const credentialsStore = this._credentialsStore;
+        return new Promise((resolve) => {
+            const fetchCredentials = () => {
+                this._deviceService
+                    .getCredentials()
+                    .then((credentials) => {
+                    return credentialsStore
+                        .save(credentials ? credentials.toJson() : null)
+                        .then(() => resolve(credentials));
+                })
+                    .catch(() => {
+                    setTimeout(fetchCredentials, 2000);
+                });
+            };
+            fetchCredentials();
+        });
+    }
+    getCurrentCredentials() {
+        return this._credentialsStore.loadOrDefault(null).then((json) => (json ? Credentials.fromJson(json) : null));
+    }
+    getCredentials() {
+        if (!this.credentialsPromise) {
+            this.credentialsPromise = this.getCurrentCredentials().then((storedCredentials) => {
+                if (storedCredentials) {
+                    return storedCredentials;
+                }
+                return this._fetchNewCredentialsFromApi();
+            });
+        }
+        return this.credentialsPromise;
+    }
+    saveCredentials(credentials) {
+        this.credentialsPromise = undefined;
+        return this._credentialsStore.save(credentials.toJson()).then(() => {
+            this.emit(events.CREDENTIALS_SAVED, credentials);
+            return credentials;
+        });
+    }
+    setUserId(userId) {
+        return this.getCurrentCredentials()
+            .then((storedCredentials) => {
+            if (!storedCredentials) {
+                console.error("Illegal state: no credentials to set user id for.");
+            }
+            const userIdChangedFromLocalStorage = storedCredentials === null || storedCredentials.userId !== userId;
+            if (!userIdChangedFromLocalStorage) {
+                return undefined;
+            }
+            return this._credentialsStore.save(Object.assign({}, storedCredentials === null || storedCredentials === void 0 ? void 0 : storedCredentials.toJson(), { userId }));
+        })
+            .then(() => undefined);
+    }
+}
+
+const noOrganization = () => Promise.resolve(undefined);
+class OrganizationApiClient {
+    constructor({ apiClient, fetchOrganization = noOrganization, }) {
+        this._apiClient = apiClient;
+        this._fetchOrganization = fetchOrganization;
+        this._apiClient = apiClient;
+    }
+    _callRequestMethod(method, url, options) {
+        assertString(url, "url");
+        media.assert.ok(url[0] === "/", 'url<String> only accepts relative URLs beginning with "/".');
+        media.assert.ok(options, "options are required");
+        return this._fetchOrganization().then((organization) => {
+            if (!organization) {
+                return this._apiClient[method](url, options);
+            }
+            const { organizationId } = organization;
+            return this._apiClient[method](`/organizations/${encodeURIComponent(organizationId)}${url}`, options);
+        });
+    }
+    request(url, options) {
+        return this._callRequestMethod("request", url, options);
+    }
+    requestMultipart(url, options) {
+        return this._callRequestMethod("requestMultipart", url, options);
+    }
+}
+
+class EmbeddedFreeTierStatus {
+    constructor({ isExhausted, renewsAt, totalMinutesLimit, totalMinutesUsed, }) {
+        this.isExhausted = isExhausted;
+        this.renewsAt = renewsAt;
+        this.totalMinutesLimit = totalMinutesLimit;
+        this.totalMinutesUsed = totalMinutesUsed;
+    }
+    static fromJson(data) {
+        return new EmbeddedFreeTierStatus({
+            isExhausted: assertBoolean(data.isExhausted, "isExhausted"),
+            renewsAt: new Date(assertString(data.renewsAt, "renewsAt")),
+            totalMinutesLimit: assertNumber(data.totalMinutesLimit, "totalMinutesLimit"),
+            totalMinutesUsed: assertNumber(data.totalMinutesUsed, "totalMinutesUsed"),
+        });
+    }
+}
+
+class Account {
+    constructor({ basePlanId, embeddedFreeTierStatus, isDeactivated, isOnTrial, onTrialUntil, trialStatus, }) {
+        this.basePlanId = basePlanId;
+        this.isDeactivated = isDeactivated;
+        this.isOnTrial = isOnTrial;
+        this.onTrialUntil = onTrialUntil || null;
+        this.trialStatus = trialStatus || null;
+        this.embeddedFreeTierStatus = embeddedFreeTierStatus || null;
+    }
+    static fromJson(data) {
+        return new Account({
+            basePlanId: typeof data.basePlanId === "string" ? data.basePlanId : null,
+            isDeactivated: assertBoolean(data.isDeactivated, "isDeactivated"),
+            isOnTrial: assertBoolean(data.isOnTrial, "isOnTrial"),
+            onTrialUntil: typeof data.onTrialUntil === "string" ? new Date(data.onTrialUntil) : null,
+            trialStatus: typeof data.trialStatus === "string" ? data.trialStatus : null,
+            embeddedFreeTierStatus: data.embeddedFreeTierStatus
+                ? EmbeddedFreeTierStatus.fromJson(data.embeddedFreeTierStatus)
+                : null,
+        });
+    }
+}
+
+function hasValue(value) {
+    return value !== null && value !== undefined;
+}
+function createOrganizationLimits(limits = {}) {
+    return {
+        maxNumberOfInvitationsAndUsers: hasValue(limits === null || limits === void 0 ? void 0 : limits.maxNumberOfInvitationsAndUsers)
+            ? Number(limits === null || limits === void 0 ? void 0 : limits.maxNumberOfInvitationsAndUsers)
+            : null,
+        maxNumberOfClaimedRooms: hasValue(limits === null || limits === void 0 ? void 0 : limits.maxNumberOfClaimedRooms)
+            ? Number(limits === null || limits === void 0 ? void 0 : limits.maxNumberOfClaimedRooms)
+            : null,
+        maxRoomLimitPerOrganization: hasValue(limits === null || limits === void 0 ? void 0 : limits.maxRoomLimitPerOrganization)
+            ? Number(limits === null || limits === void 0 ? void 0 : limits.maxRoomLimitPerOrganization)
+            : null,
+        trialMinutesLimit: hasValue(limits === null || limits === void 0 ? void 0 : limits.trialMinutesLimit) ? Number(limits === null || limits === void 0 ? void 0 : limits.trialMinutesLimit) : null,
+        includedUnits: hasValue(limits === null || limits === void 0 ? void 0 : limits.includedUnits) ? Number(limits === null || limits === void 0 ? void 0 : limits.includedUnits) : null,
+    };
+}
+class Organization {
+    constructor(properties) {
+        this.logoImageUrl = null;
+        this.roomBackgroundImageUrl = null;
+        this.roomBackgroundThumbnailUrl = null;
+        this.roomKnockPageBackgroundImageUrl = null;
+        this.roomKnockPageBackgroundThumbnailUrl = null;
+        this.preferences = null;
+        this.onboardingSurvey = null;
+        this.type = null;
+        assertInstanceOf(properties, Object, "properties");
+        assertString(properties.organizationId, "organizationId");
+        assertString(properties.organizationName, "organizationName");
+        assertString(properties.subdomain, "subdomain");
+        assertInstanceOf(properties.permissions, Object, "permissions");
+        assertInstanceOf(properties.limits, Object, "limits");
+        this.organizationId = properties.organizationId;
+        this.organizationName = properties.organizationName;
+        this.subdomain = properties.subdomain;
+        this.permissions = properties.permissions;
+        this.limits = properties.limits;
+        this.account = properties.account ? new Account(properties.account) : null;
+        this.logoImageUrl = properties.logoImageUrl;
+        this.roomBackgroundImageUrl = properties.roomBackgroundImageUrl;
+        this.roomBackgroundThumbnailUrl = properties.roomBackgroundThumbnailUrl;
+        this.roomKnockPageBackgroundImageUrl = properties.roomKnockPageBackgroundImageUrl;
+        this.roomKnockPageBackgroundThumbnailUrl = properties.roomKnockPageBackgroundThumbnailUrl;
+        this.preferences = properties.preferences;
+        this.onboardingSurvey = properties.onboardingSurvey;
+        this.type = properties.type;
+    }
+    static fromJson(data) {
+        const parsedData = assertInstanceOf(data, Object, "data");
+        const preferences = ((parsedData === null || parsedData === void 0 ? void 0 : parsedData.preferences) || {});
+        const onboardingSurvey = ((parsedData === null || parsedData === void 0 ? void 0 : parsedData.onboardingSurvey) || null);
+        const permissions = assertInstanceOf(parsedData.permissions, Object, "permissions");
+        return new Organization({
+            organizationId: assertString(parsedData.organizationId, "organizationId"),
+            organizationName: assertString(parsedData.organizationName, "organizationName"),
+            subdomain: assertString(parsedData.subdomain, "subdomain"),
+            permissions,
+            limits: createOrganizationLimits(assertInstanceOf(parsedData.limits, Object, "limits")),
+            account: parsedData.account ? Account.fromJson(parsedData.account) : null,
+            logoImageUrl: typeof parsedData.logoImageUrl === "string" ? parsedData.logoImageUrl : null,
+            roomBackgroundImageUrl: typeof parsedData.roomBackgroundImageUrl === "string" ? parsedData.roomBackgroundImageUrl : null,
+            roomBackgroundThumbnailUrl: typeof parsedData.roomBackgroundThumbnailUrl === "string"
+                ? parsedData.roomBackgroundThumbnailUrl
+                : null,
+            roomKnockPageBackgroundImageUrl: typeof parsedData.roomKnockPageBackgroundImageUrl === "string"
+                ? parsedData.roomKnockPageBackgroundImageUrl
+                : null,
+            roomKnockPageBackgroundThumbnailUrl: typeof parsedData.roomKnockPageBackgroundThumbnailUrl === "string"
+                ? parsedData.roomKnockPageBackgroundThumbnailUrl
+                : null,
+            preferences,
+            onboardingSurvey,
+            type: typeof parsedData.type === "string" ? parsedData.type : null,
+        });
+    }
+}
+Organization.GLOBAL_ORGANIZATION_ID = "1";
+
+class OrganizationService {
+    constructor({ apiClient }) {
+        this._apiClient = apiClient;
+    }
+    createOrganization({ organizationName, subdomain, owner, }) {
+        const { displayName, consents } = owner || {};
+        const email = "email" in owner
+            ? {
+                value: owner.email,
+                verificationCode: assertString(owner.verificationCode, "owner.verificationCode"),
+            }
+            : null;
+        const idToken = "idToken" in owner ? owner.idToken : null;
+        assertString(subdomain, "subdomain");
+        assertString(organizationName, "organizationName");
+        assertString(displayName, "owner.displayName");
+        media.assert.ok(email || idToken, "owner.email or owner.idToken is required");
+        if (consents) {
+            assertArray(consents, "consents");
+            for (const { consentRevisionId, action } of consents) {
+                assertString(consentRevisionId, "consentRevisionId");
+                assertNullOrString(action, "action");
+            }
+        }
+        return this._apiClient
+            .request(`/organizations`, {
+            method: "POST",
+            data: {
+                organizationName,
+                type: "private",
+                subdomain,
+                owner: Object.assign(Object.assign(Object.assign(Object.assign({}, (email && { email })), (idToken && { idToken })), (consents && { consents })), { displayName }),
+            },
+        })
+            .then(({ data }) => {
+            return extractString(data, "organizationId");
+        });
+    }
+    getOrganizationBySubdomain(subdomain) {
+        assertString(subdomain, "subdomain");
+        return this._apiClient
+            .request(`/organization-subdomains/${encodeURIComponent(subdomain)}/?fields=permissions,account,onboardingSurvey`, {
+            method: "GET",
+        })
+            .then(({ data }) => {
+            return Organization.fromJson(data);
+        })
+            .catch((res) => {
+            if (res instanceof Response) {
+                if (res.status === 404) {
+                    return null;
+                }
+                throw new Error(res.statusText);
+            }
+            throw res;
+        });
+    }
+    getOrganizationByOrganizationId(organizationId) {
+        assertString(organizationId, "organizationId");
+        return this._apiClient
+            .request(`/organizations/${encodeURIComponent(organizationId)}?fields=permissions,account`, {
+            method: "GET",
+        })
+            .then(({ data }) => {
+            return Organization.fromJson(data);
+        })
+            .catch((res) => {
+            if (res instanceof Response) {
+                if (res.status === 404) {
+                    return null;
+                }
+                throw new Error(res.statusText);
+            }
+            throw res;
+        });
+    }
+    getOrganizationsByContactPoint(options) {
+        const { code } = options;
+        const email = "email" in options ? options.email : null;
+        const phoneNumber = "phoneNumber" in options ? options.phoneNumber : null;
+        media.assert.ok((email || phoneNumber) && !(email && phoneNumber), "either email or phoneNumber is required");
+        assertString(code, "code");
+        const contactPoint = email ? { type: "email", value: email } : { type: "phoneNumber", value: phoneNumber };
+        return this._apiClient
+            .request("/organization-queries", {
+            method: "POST",
+            data: {
+                contactPoint,
+                code,
+            },
+        })
+            .then(({ data }) => {
+            return extractArray(data, "organizations", (organization) => Organization.fromJson(organization));
+        });
+    }
+    getOrganizationsByIdToken({ idToken }) {
+        assertString(idToken, "idToken");
+        return this._apiClient
+            .request("/organization-queries", {
+            method: "POST",
+            data: {
+                idToken,
+            },
+        })
+            .then(({ data }) => {
+            return extractArray(data, "organizations", (organization) => {
+                return Organization.fromJson(Object.assign({ permissions: {}, limits: {} }, assertRecord(organization, "organization")));
+            });
+        });
+    }
+    getOrganizationsByLoggedInUser() {
+        return this._apiClient
+            .request("/user/organizations", {
+            method: "GET",
+        })
+            .then(({ data }) => {
+            return extractArray(data, "organizations", (o) => {
+                return Organization.fromJson(Object.assign({ permissions: {}, limits: {} }, assertRecord(o, "organization")));
+            });
+        });
+    }
+    getSubdomainAvailability(subdomain) {
+        assertString(subdomain, "subdomain");
+        return this._apiClient
+            .request(`/organization-subdomains/${encodeURIComponent(subdomain)}/availability`, {
+            method: "GET",
+        })
+            .then(({ data }) => {
+            assertInstanceOf(data, Object, "data");
+            return {
+                status: extractString(data, "status"),
+            };
+        });
+    }
+    updatePreferences({ organizationId, preferences, }) {
+        assertTruthy(organizationId, "organizationId");
+        assertTruthy(preferences, "preferences");
+        return this._apiClient
+            .request(`/organizations/${encodeURIComponent(organizationId)}/preferences`, {
+            method: "PATCH",
+            data: preferences,
+        })
+            .then(() => undefined);
+    }
+    deleteOrganization({ organizationId }) {
+        assertTruthy(organizationId, "organizationId");
+        return this._apiClient
+            .request(`/organizations/${encodeURIComponent(organizationId)}`, {
+            method: "DELETE",
+        })
+            .then(() => undefined);
+    }
+}
+
+class OrganizationServiceCache {
+    constructor({ organizationService, subdomain }) {
+        this._organizationService = organizationService;
+        this._subdomain = subdomain;
+        this._organizationPromise = null;
+    }
+    initOrganization() {
+        return this.fetchOrganization().then(() => undefined);
+    }
+    fetchOrganization() {
+        if (!this._organizationPromise) {
+            this._organizationPromise = this._organizationService.getOrganizationBySubdomain(this._subdomain);
+        }
+        return this._organizationPromise;
+    }
+}
+
+class Room {
+    constructor(properties = {}) {
+        media.assert.ok(properties instanceof Object, "properties<object> must be empty or an object");
+        this.isClaimed = false;
+        this.isBanned = false;
+        this.isLocked = false;
+        this.knockPage = {
+            backgroundImageUrl: null,
+            backgroundThumbnailUrl: null,
+        };
+        this.logoUrl = null;
+        this.backgroundImageUrl = null;
+        this.backgroundThumbnailUrl = null;
+        this.type = null;
+        this.legacyRoomType = null;
+        this.mode = null;
+        this.product = null;
+        this.roomName = null;
+        this.theme = null;
+        this.preferences = {};
+        this.protectedPreferences = {};
+        this.publicProfile = null;
+        const validProperties = {};
+        Object.getOwnPropertyNames(properties).forEach((prop) => {
+            if (Object.getOwnPropertyNames(this).indexOf(prop) !== -1) {
+                validProperties[prop] = properties[prop];
+            }
+        });
+        if (properties.ownerId !== undefined) {
+            this.ownerId = properties.ownerId;
+        }
+        if (properties.meeting !== undefined) {
+            this.meeting = properties.meeting;
+        }
+        Object.assign(this, validProperties);
+    }
+}
+
+class Meeting {
+    constructor({ meetingId, roomName, roomUrl, startDate, endDate, hostRoomUrl, viewerRoomUrl }) {
+        assertString(meetingId, "meetingId");
+        assertString(roomName, "roomName");
+        assertString(roomUrl, "roomUrl");
+        assertInstanceOf(startDate, Date, "startDate");
+        assertInstanceOf(endDate, Date, "endDate");
+        this.meetingId = meetingId;
+        this.roomName = roomName;
+        this.roomUrl = roomUrl;
+        this.startDate = startDate;
+        this.endDate = endDate;
+        this.hostRoomUrl = hostRoomUrl;
+        this.viewerRoomUrl = viewerRoomUrl;
+    }
+    static fromJson(data) {
+        return new Meeting({
+            meetingId: extractString(data, "meetingId"),
+            roomName: extractString(data, "roomName"),
+            roomUrl: extractString(data, "roomUrl"),
+            startDate: extractDate(data, "startDate"),
+            endDate: extractDate(data, "endDate"),
+            hostRoomUrl: extractNullOrString(data, "hostRoomUrl"),
+            viewerRoomUrl: extractNullOrString(data, "viewerRoomUrl"),
+        });
+    }
+}
+
+function createRoomUrl(roomName, path = "") {
+    const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+    return `/room/${encodedDisplayName}${path}`;
+}
+class RoomService {
+    constructor({ organizationApiClient }) {
+        this._organizationApiClient = assertInstanceOf(organizationApiClient, OrganizationApiClient);
+    }
+    getRooms({ types, fields = [] } = {}) {
+        assertArray(types, "types");
+        assertArray(fields, "fields");
+        return this._organizationApiClient
+            .request("/room", {
+            method: "GET",
+            params: { types: types.join(","), fields: fields.join(","), includeOnlyLegacyRoomType: "false" },
+        })
+            .then(({ data }) => data.rooms.map((room) => new Room(room)));
+    }
+    getRoom({ roomName, fields }) {
+        assertRoomName(roomName);
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/rooms/${encodedDisplayName}`, {
+            method: "GET",
+            params: Object.assign({ includeOnlyLegacyRoomType: "false" }, (fields && { fields: fields.join(",") })),
+        })
+            .then(({ data }) => new Room(Object.assign({}, data, Object.assign({ roomName }, (data.meeting && { meeting: Meeting.fromJson(data.meeting) })))))
+            .catch((response) => {
+            if (response.status === 404) {
+                return new Room({
+                    roomName,
+                    isClaimed: false,
+                    mode: "normal",
+                    product: {
+                        categoryName: "personal_free",
+                    },
+                    type: "personal",
+                    legacyRoomType: "free",
+                });
+            }
+            if (response.status === 400 && response.data.error === "Banned room") {
+                return new Room({ roomName, isBanned: true });
+            }
+            throw new Error(response.data ? response.data.error : "Could not fetch room information");
+        });
+    }
+    claimRoom({ roomName, type, mode, isLocked }) {
+        assertRoomName(roomName);
+        assertString(type, "type");
+        return this._organizationApiClient
+            .request("/room/claim", {
+            method: "POST",
+            data: Object.assign(Object.assign({ roomName,
+                type }, (typeof mode === "string" && { mode })), (typeof isLocked === "boolean" && { isLocked })),
+        })
+            .then(() => undefined)
+            .catch((response) => {
+            throw new Error(response.data.error || "Failed to claim room");
+        });
+    }
+    unclaimRoom(roomName) {
+        assertRoomName(roomName);
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}`, {
+            method: "DELETE",
+        })
+            .then(() => undefined);
+    }
+    renameRoom({ roomName, newRoomName }) {
+        assertRoomName(roomName);
+        assertString(newRoomName, "newRoomName");
+        const encodedRoomName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedRoomName}/roomName`, {
+            method: "PUT",
+            data: { newRoomName },
+        })
+            .then(() => undefined);
+    }
+    changeMode({ roomName, mode }) {
+        assertRoomName(roomName);
+        assertString(mode, "mode");
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}/mode`, {
+            method: "PUT",
+            data: { mode },
+        })
+            .then(() => undefined);
+    }
+    updatePreferences({ roomName, preferences }) {
+        assertRoomName(roomName);
+        assertInstanceOf(preferences, Object, "preferences");
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}/preferences`, {
+            method: "PATCH",
+            data: preferences,
+        })
+            .then(() => undefined);
+    }
+    updateProtectedPreferences({ roomName, preferences }) {
+        assertRoomName(roomName);
+        assertInstanceOf(preferences, Object, "preferences");
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}/protected-preferences`, {
+            method: "PATCH",
+            data: preferences,
+        })
+            .then(() => undefined);
+    }
+    getRoomPermissions(roomName, { roomKey } = {}) {
+        assertRoomName(roomName);
+        return this._organizationApiClient
+            .request(createRoomUrl(roomName, "/permissions"), Object.assign({ method: "GET" }, (roomKey && { headers: { "X-Whereby-Room-Key": roomKey } })))
+            .then((response) => {
+            const { permissions, limits } = response.data;
+            return {
+                permissions,
+                limits,
+            };
+        });
+    }
+    getRoomMetrics({ roomName, metrics, from, to }) {
+        assertRoomName(roomName);
+        assertString(metrics, "metrics");
+        return this._organizationApiClient
+            .request(createRoomUrl(roomName, "/metrics"), {
+            method: "GET",
+            params: { metrics, from, to },
+        })
+            .then((response) => response.data);
+    }
+    changeType({ roomName, type }) {
+        assertRoomName(roomName);
+        assertOneOf(type, ["personal", "personal_xl"], "type");
+        const encodedDisplayName = encodeURIComponent(roomName.substring(1));
+        return this._organizationApiClient
+            .request(`/room/${encodedDisplayName}/type`, {
+            method: "PUT",
+            data: { type },
+        })
+            .then(() => undefined);
+    }
+    getForestSocialImage({ roomName, count }) {
+        assertRoomName(roomName);
+        assertNumber(count, "count");
+        return this._organizationApiClient
+            .request(createRoomUrl(roomName, `/forest-social-image/${count}`), {
+            method: "GET",
+        })
+            .then((response) => response.data.imageUrl);
+    }
+}
+
+class RoomParticipant {
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled }) {
+        this.isLocalParticipant = false;
+        this.displayName = displayName;
+        this.id = id;
+        this.stream = stream;
+        this.isAudioEnabled = isAudioEnabled;
+        this.isVideoEnabled = isVideoEnabled;
+    }
+}
+class LocalParticipant extends RoomParticipant {
+    constructor({ displayName, id, stream, isAudioEnabled, isVideoEnabled }) {
+        super({ displayName, id, stream, isAudioEnabled, isVideoEnabled });
+        this.isLocalParticipant = true;
+    }
+}
+
+const sdkVersion = "0.8.0";
+
+const API_BASE_URL = "https://api.whereby.dev" ;
+function createServices() {
+    const credentialsService = CredentialsService.create({ baseUrl: API_BASE_URL });
+    const apiClient = new ApiClient({
+        fetchDeviceCredentials: credentialsService.getCredentials.bind(credentialsService),
+        baseUrl: API_BASE_URL,
+    });
+    const organizationService = new OrganizationService({ apiClient });
+    const fetchOrganizationFromRoomUrl = (roomUrl) => {
+        const roomUrlObj = new URL(roomUrl);
+        const urls = media.fromLocation({ host: roomUrlObj.host });
+        const organizationServiceCache = new OrganizationServiceCache({
+            organizationService,
+            subdomain: urls.subdomain,
+        });
+        return organizationServiceCache.fetchOrganization();
+    };
+    return {
+        credentialsService,
+        apiClient,
+        organizationService,
+        fetchOrganizationFromRoomUrl,
+    };
+}
+
+exports.ApiClient = ApiClient;
+exports.Credentials = Credentials;
+exports.CredentialsService = CredentialsService;
+exports.LocalParticipant = LocalParticipant;
+exports.OrganizationApiClient = OrganizationApiClient;
+exports.OrganizationService = OrganizationService;
+exports.OrganizationServiceCache = OrganizationServiceCache;
+exports.RoomService = RoomService;
+exports.addAppListener = addAppListener;
+exports.appLeft = appLeft;
+exports.appSlice = appSlice;
+exports.chatSlice = chatSlice;
+exports.cloudRecordingSlice = cloudRecordingSlice;
+exports.createAppAsyncThunk = createAppAsyncThunk;
+exports.createAppThunk = createAppThunk;
+exports.createReactor = createReactor;
+exports.createServices = createServices;
+exports.createStore = createStore;
+exports.createWebRtcEmitter = createWebRtcEmitter;
+exports.deviceBusy = deviceBusy;
+exports.deviceCredentialsSlice = deviceCredentialsSlice;
+exports.deviceIdentified = deviceIdentified;
+exports.deviceIdentifying = deviceIdentifying;
+exports.doAcceptWaitingParticipant = doAcceptWaitingParticipant;
+exports.doAppJoin = doAppJoin;
+exports.doConnectRoom = doConnectRoom;
+exports.doConnectRtc = doConnectRtc;
+exports.doDisconnectRtc = doDisconnectRtc;
+exports.doEnableAudio = doEnableAudio;
+exports.doEnableVideo = doEnableVideo;
+exports.doGetDeviceCredentials = doGetDeviceCredentials;
+exports.doHandleAcceptStreams = doHandleAcceptStreams;
+exports.doHandleStreamingStarted = doHandleStreamingStarted;
+exports.doHandleStreamingStopped = doHandleStreamingStopped;
+exports.doKnockRoom = doKnockRoom;
+exports.doOrganizationFetch = doOrganizationFetch;
+exports.doRejectWaitingParticipant = doRejectWaitingParticipant;
+exports.doRtcAnalyticsCustomEventsInitialize = doRtcAnalyticsCustomEventsInitialize;
+exports.doRtcManagerCreated = doRtcManagerCreated;
+exports.doRtcManagerInitialize = doRtcManagerInitialize;
+exports.doRtcReportStreamResolution = doRtcReportStreamResolution;
+exports.doSendChatMessage = doSendChatMessage;
+exports.doSetDevice = doSetDevice;
+exports.doSetDisplayName = doSetDisplayName;
+exports.doSetLocalParticipant = doSetLocalParticipant;
+exports.doSignalDisconnect = doSignalDisconnect;
+exports.doSignalIdentifyDevice = doSignalIdentifyDevice;
+exports.doSignalReconnect = doSignalReconnect;
+exports.doSignalSocketConnect = doSignalSocketConnect;
+exports.doStartCloudRecording = doStartCloudRecording;
+exports.doStartLocalMedia = doStartLocalMedia;
+exports.doStartScreenshare = doStartScreenshare;
+exports.doStopCloudRecording = doStopCloudRecording;
+exports.doStopLocalMedia = doStopLocalMedia;
+exports.doStopScreenshare = doStopScreenshare;
+exports.doSwitchLocalStream = doSwitchLocalStream;
+exports.doToggleCamera = doToggleCamera;
+exports.doUpdateDeviceList = doUpdateDeviceList;
+exports.initialCloudRecordingState = initialCloudRecordingState;
+exports.initialLocalMediaState = initialLocalMediaState;
+exports.isAcceptingStreams = isAcceptingStreams;
+exports.listenerMiddleware = listenerMiddleware;
+exports.localMediaSlice = localMediaSlice;
+exports.localMediaStopped = localMediaStopped;
+exports.localParticipantSlice = localParticipantSlice;
+exports.localScreenshareSlice = localScreenshareSlice;
+exports.localStreamMetadataUpdated = localStreamMetadataUpdated;
+exports.observeStore = observeStore;
+exports.organizationSlice = organizationSlice;
+exports.participantStreamAdded = participantStreamAdded;
+exports.participantStreamIdAdded = participantStreamIdAdded;
+exports.recordingRequestStarted = recordingRequestStarted;
+exports.remoteParticipantsSlice = remoteParticipantsSlice;
+exports.resolutionReported = resolutionReported;
+exports.roomConnectionSlice = roomConnectionSlice;
+exports.rootReducer = rootReducer;
+exports.rtcAnalyticsCustomEvents = rtcAnalyticsCustomEvents;
+exports.rtcAnalyticsSlice = rtcAnalyticsSlice;
+exports.rtcConnectionSlice = rtcConnectionSlice;
+exports.rtcDisconnected = rtcDisconnected;
+exports.rtcDispatcherCreated = rtcDispatcherCreated;
+exports.rtcManagerCreated = rtcManagerCreated;
+exports.rtcManagerDestroyed = rtcManagerDestroyed;
+exports.rtcManagerInitialized = rtcManagerInitialized;
+exports.sdkVersion = sdkVersion;
+exports.selectAppDisplayName = selectAppDisplayName;
+exports.selectAppExternalId = selectAppExternalId;
+exports.selectAppIsNodeSdk = selectAppIsNodeSdk;
+exports.selectAppRaw = selectAppRaw;
+exports.selectAppRoomKey = selectAppRoomKey;
+exports.selectAppRoomName = selectAppRoomName;
+exports.selectAppRoomUrl = selectAppRoomUrl;
+exports.selectAppSdkVersion = selectAppSdkVersion;
+exports.selectAppWantsToJoin = selectAppWantsToJoin;
+exports.selectBusyDeviceIds = selectBusyDeviceIds;
+exports.selectCameraDeviceError = selectCameraDeviceError;
+exports.selectCameraDevices = selectCameraDevices;
+exports.selectChatMessages = selectChatMessages;
+exports.selectChatRaw = selectChatRaw;
+exports.selectCloudRecordingError = selectCloudRecordingError;
+exports.selectCloudRecordingRaw = selectCloudRecordingRaw;
+exports.selectCloudRecordingStartedAt = selectCloudRecordingStartedAt;
+exports.selectCloudRecordingStatus = selectCloudRecordingStatus;
+exports.selectCurrentCameraDeviceId = selectCurrentCameraDeviceId;
+exports.selectCurrentMicrophoneDeviceId = selectCurrentMicrophoneDeviceId;
+exports.selectDeviceCredentialsRaw = selectDeviceCredentialsRaw;
+exports.selectDeviceId = selectDeviceId;
+exports.selectHasFetchedDeviceCredentials = selectHasFetchedDeviceCredentials;
+exports.selectIsAcceptingStreams = selectIsAcceptingStreams;
+exports.selectIsCameraEnabled = selectIsCameraEnabled;
+exports.selectIsCloudRecording = selectIsCloudRecording;
+exports.selectIsLocalMediaStarting = selectIsLocalMediaStarting;
+exports.selectIsMicrophoneEnabled = selectIsMicrophoneEnabled;
+exports.selectIsSettingCameraDevice = selectIsSettingCameraDevice;
+exports.selectIsSettingMicrophoneDevice = selectIsSettingMicrophoneDevice;
+exports.selectIsToggleCamera = selectIsToggleCamera;
+exports.selectLocalMediaConstraintsOptions = selectLocalMediaConstraintsOptions;
+exports.selectLocalMediaDevices = selectLocalMediaDevices;
+exports.selectLocalMediaIsSwitchingStream = selectLocalMediaIsSwitchingStream;
+exports.selectLocalMediaOptions = selectLocalMediaOptions;
+exports.selectLocalMediaOwnsStream = selectLocalMediaOwnsStream;
+exports.selectLocalMediaRaw = selectLocalMediaRaw;
+exports.selectLocalMediaShouldStartWithOptions = selectLocalMediaShouldStartWithOptions;
+exports.selectLocalMediaShouldStop = selectLocalMediaShouldStop;
+exports.selectLocalMediaStartError = selectLocalMediaStartError;
+exports.selectLocalMediaStatus = selectLocalMediaStatus;
+exports.selectLocalMediaStream = selectLocalMediaStream;
+exports.selectLocalParticipantClientClaim = selectLocalParticipantClientClaim;
+exports.selectLocalParticipantIsScreenSharing = selectLocalParticipantIsScreenSharing;
+exports.selectLocalParticipantRaw = selectLocalParticipantRaw;
+exports.selectLocalParticipantRole = selectLocalParticipantRole;
+exports.selectLocalScreenshareRaw = selectLocalScreenshareRaw;
+exports.selectLocalScreenshareStatus = selectLocalScreenshareStatus;
+exports.selectLocalScreenshareStream = selectLocalScreenshareStream;
+exports.selectMicrophoneDeviceError = selectMicrophoneDeviceError;
+exports.selectMicrophoneDevices = selectMicrophoneDevices;
+exports.selectOrganizationId = selectOrganizationId;
+exports.selectOrganizationRaw = selectOrganizationRaw;
+exports.selectRemoteParticipants = selectRemoteParticipants;
+exports.selectRemoteParticipantsRaw = selectRemoteParticipantsRaw;
+exports.selectRoomConnectionError = selectRoomConnectionError;
+exports.selectRoomConnectionRaw = selectRoomConnectionRaw;
+exports.selectRoomConnectionSession = selectRoomConnectionSession;
+exports.selectRoomConnectionSessionId = selectRoomConnectionSessionId;
+exports.selectRoomConnectionStatus = selectRoomConnectionStatus;
+exports.selectRtcConnectionRaw = selectRtcConnectionRaw;
+exports.selectRtcDispatcherCreated = selectRtcDispatcherCreated;
+exports.selectRtcIsCreatingDispatcher = selectRtcIsCreatingDispatcher;
+exports.selectRtcManager = selectRtcManager;
+exports.selectRtcManagerInitialized = selectRtcManagerInitialized;
+exports.selectRtcStatus = selectRtcStatus;
+exports.selectScreenshares = selectScreenshares;
+exports.selectSelfId = selectSelfId;
+exports.selectShouldConnectRoom = selectShouldConnectRoom;
+exports.selectShouldConnectRtc = selectShouldConnectRtc;
+exports.selectShouldConnectSignal = selectShouldConnectSignal;
+exports.selectShouldDisconnectRtc = selectShouldDisconnectRtc;
+exports.selectShouldFetchDeviceCredentials = selectShouldFetchDeviceCredentials;
+exports.selectShouldFetchOrganization = selectShouldFetchOrganization;
+exports.selectShouldIdentifyDevice = selectShouldIdentifyDevice;
+exports.selectShouldInitializeRtc = selectShouldInitializeRtc;
+exports.selectSignalConnectionDeviceIdentified = selectSignalConnectionDeviceIdentified;
+exports.selectSignalConnectionRaw = selectSignalConnectionRaw;
+exports.selectSignalConnectionSocket = selectSignalConnectionSocket;
+exports.selectSignalIsIdentifyingDevice = selectSignalIsIdentifyingDevice;
+exports.selectSignalStatus = selectSignalStatus;
+exports.selectSpeakerDevices = selectSpeakerDevices;
+exports.selectStreamingRaw = selectStreamingRaw;
+exports.selectStreamsToAccept = selectStreamsToAccept;
+exports.selectWaitingParticipants = selectWaitingParticipants;
+exports.selectWaitingParticipantsRaw = selectWaitingParticipantsRaw;
+exports.setCurrentCameraDeviceId = setCurrentCameraDeviceId;
+exports.setCurrentMicrophoneDeviceId = setCurrentMicrophoneDeviceId;
+exports.setLocalMediaOptions = setLocalMediaOptions;
+exports.setLocalMediaStream = setLocalMediaStream;
+exports.setRoomKey = setRoomKey;
+exports.signalConnectionSlice = signalConnectionSlice;
+exports.socketConnected = socketConnected;
+exports.socketConnecting = socketConnecting;
+exports.socketDisconnected = socketDisconnected;
+exports.socketReconnecting = socketReconnecting;
+exports.startAppListening = startAppListening;
+exports.stopScreenshare = stopScreenshare;
+exports.streamStatusUpdated = streamStatusUpdated;
+exports.streamingSlice = streamingSlice;
+exports.toggleCameraEnabled = toggleCameraEnabled;
+exports.toggleMicrophoneEnabled = toggleMicrophoneEnabled;
+exports.updateReportedValues = updateReportedValues;
+exports.waitingParticipantsSlice = waitingParticipantsSlice;