@whereby.com/core 1.1.4 → 1.1.6

package/dist/redux/index.cjs

@@ -2,7 +2,9 @@
 
 var toolkit = require('@reduxjs/toolkit');
 var media = require('@whereby.com/media');
-var events = require('events');
+var events$1 = require('events');
+var nodeBtoa = require('btoa');
+var axios = require('axios');
 
 function createAppAsyncThunk(typePrefix, payloadCreator) {
     return toolkit.createAsyncThunk(typePrefix, payloadCreator);
@@ -73,7 +75,7 @@ const createReactor = (selectors, callback) => {
     });
 };
 
-const coreVersion = "1.1.4";
+const coreVersion = "1.1.6";
 
 const initialState = {
     isNodeSdk: false,
@@ -2305,7 +2307,7 @@ createReactor([selectBreakoutAssignments, selectDeviceId, selectLocalParticipant
     dispatch(setBreakoutGroupAssigned({ breakoutGroupAssigned }));
 });
 
-const emitter = new events.EventEmitter();
+const emitter = new events$1.EventEmitter();
 function createNotificationEvent(payload) {
     const notificationEvent = Object.assign(Object.assign({}, payload), { timestamp: Date.now() });
     return notificationEvent;
@@ -3019,6 +3021,726 @@ const observeStore = (store, select, onChange) => {
     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 assertArray(array, parameterName) {
+    media.assert.ok(Array.isArray(array), `${parameterName}<array> is required`);
+    return array;
+}
+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 = `${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);
+}
+
+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 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 (_a) {
+                }
+            }
+            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 (_a) {
+    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 events$1.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);
+    }
+}
+
+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;
+    }
+}
+
+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.addAppListener = addAppListener;
 exports.addSpotlight = addSpotlight;
 exports.appSlice = appSlice;
@@ -3041,6 +3763,7 @@ exports.createAuthorizedRoomConnectedThunk = createAuthorizedRoomConnectedThunk;
 exports.createReactor = createReactor;
 exports.createRemoteParticipant = createRemoteParticipant;
 exports.createRoomConnectedThunk = createRoomConnectedThunk;
+exports.createServices = createServices;
 exports.createStore = createStore;
 exports.createWebRtcEmitter = createWebRtcEmitter;
 exports.deviceBusy = deviceBusy;