@whereby.com/browser-sdk 2.0.0-alpha8 → 2.0.0-beta1

package/dist/api/models/Account.js

@@ -0,0 +1,24 @@
+import { assertBoolean } from "../parameterAssertUtils";
+import EmbeddedFreeTierStatus from "./account/EmbeddedFreeTierStatus";
+export default 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,
+        });
+    }
+}

package/dist/api/models/Meeting.d.ts

@@ -0,0 +1,12 @@
+import { Json } from "../Response";
+export default class Meeting {
+    meetingId: string;
+    roomName: string;
+    roomUrl: string;
+    startDate: Date;
+    endDate: Date;
+    hostRoomUrl: string | null;
+    viewerRoomUrl: string | null;
+    constructor({ meetingId, roomName, roomUrl, startDate, endDate, hostRoomUrl, viewerRoomUrl }: Meeting);
+    static fromJson(data: Json): Meeting;
+}

package/dist/api/models/Meeting.js

@@ -0,0 +1,29 @@
+import { extractDate, extractNullOrString, extractString } from "../extractUtils";
+import { assertString, assertInstanceOf } from "../parameterAssertUtils";
+export default 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"),
+        });
+    }
+}

package/dist/api/models/Organization.d.ts

@@ -0,0 +1,102 @@
+import { Json } from "../Response";
+import Account from "./Account";
+interface OrganizationPermissionAction {
+    isAllowed: boolean;
+    isSupported: boolean;
+}
+interface FullOrganizationPermissions {
+    images: {
+        logoImageUrl: {
+            set: OrganizationPermissionAction;
+            reset: OrganizationPermissionAction;
+        };
+        roomBackgroundImageUrl: {
+            set: OrganizationPermissionAction;
+            reset: OrganizationPermissionAction;
+        };
+        roomKnockPageBackgroundImageUrl: {
+            set: OrganizationPermissionAction;
+            reset: OrganizationPermissionAction;
+        };
+    };
+    invitations: {
+        add: OrganizationPermissionAction;
+        delete: OrganizationPermissionAction;
+        list: OrganizationPermissionAction;
+    };
+    roles: {
+        set: OrganizationPermissionAction;
+        remove: OrganizationPermissionAction;
+        removeSelf: OrganizationPermissionAction;
+        list: OrganizationPermissionAction;
+    };
+    users: {
+        signUpWithoutInvitation: OrganizationPermissionAction;
+    };
+    rooms: {
+        customize: OrganizationPermissionAction;
+        customizeSelf: OrganizationPermissionAction;
+        list: OrganizationPermissionAction;
+        lock: OrganizationPermissionAction;
+        unclaim: OrganizationPermissionAction;
+        unclaimSelf: OrganizationPermissionAction;
+    };
+    subscriptions: {
+        add: OrganizationPermissionAction;
+        list: OrganizationPermissionAction;
+        payLatestInvoice: OrganizationPermissionAction;
+        updatePlan: OrganizationPermissionAction;
+    };
+    browserExtension: {
+        install: OrganizationPermissionAction;
+    };
+}
+type OrganizationPermissions = Partial<FullOrganizationPermissions>;
+interface OrganizationLimits {
+    maxNumberOfInvitationsAndUsers: number | null;
+    maxNumberOfClaimedRooms: number | null;
+    maxRoomLimitPerOrganization: number | null;
+    trialMinutesLimit: number | null;
+    includedUnits: number | null;
+}
+interface OrganizationOnboardingSurvey {
+    name: string;
+    value: unknown;
+}
+export type OrganizationPreferences = Record<string, boolean | string | null | number>;
+export declare function hasValue(value: unknown): boolean;
+export default class Organization {
+    static GLOBAL_ORGANIZATION_ID: string;
+    organizationId: string;
+    organizationName: string;
+    subdomain: string;
+    permissions: OrganizationPermissions;
+    limits: OrganizationLimits;
+    account: Account | null;
+    logoImageUrl: string | null;
+    roomBackgroundImageUrl: string | null;
+    roomBackgroundThumbnailUrl: string | null;
+    roomKnockPageBackgroundImageUrl: string | null;
+    roomKnockPageBackgroundThumbnailUrl: string | null;
+    preferences: OrganizationPreferences | null;
+    onboardingSurvey: OrganizationOnboardingSurvey | null;
+    type: string | null;
+    constructor(properties: {
+        account: Account | null;
+        organizationId: string;
+        organizationName: string;
+        subdomain: string;
+        permissions: OrganizationPermissions;
+        limits: OrganizationLimits;
+        logoImageUrl: string | null;
+        roomBackgroundImageUrl: string | null;
+        roomBackgroundThumbnailUrl: string | null;
+        roomKnockPageBackgroundImageUrl: string | null;
+        roomKnockPageBackgroundThumbnailUrl: string | null;
+        preferences: OrganizationPreferences | null;
+        onboardingSurvey: OrganizationOnboardingSurvey | null;
+        type: string | null;
+    });
+    static fromJson(data: Json): Organization;
+}
+export {};

package/dist/api/models/Organization.js

@@ -0,0 +1,81 @@
+import { assertInstanceOf, assertString } from "../parameterAssertUtils";
+import Account from "./Account";
+export 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,
+    };
+}
+export default 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";

package/dist/api/models/Room.d.ts

@@ -0,0 +1,4 @@
+export default class Room {
+    readonly isLocked: boolean;
+    constructor(properties?: {});
+}

package/dist/api/models/Room.js

@@ -0,0 +1,38 @@
+import assert from "assert";
+export default class Room {
+    constructor(properties = {}) {
+        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);
+    }
+}

package/dist/api/models/account/EmbeddedFreeTierStatus.d.ts

@@ -0,0 +1,13 @@
+export default class EmbeddedFreeTierStatus {
+    isExhausted: boolean;
+    renewsAt: Date;
+    totalMinutesLimit: number;
+    totalMinutesUsed: number;
+    constructor({ isExhausted, renewsAt, totalMinutesLimit, totalMinutesUsed, }: {
+        isExhausted: boolean;
+        renewsAt: Date;
+        totalMinutesLimit: number;
+        totalMinutesUsed: number;
+    });
+    static fromJson(data: Record<string, unknown>): EmbeddedFreeTierStatus;
+}

package/dist/api/models/account/EmbeddedFreeTierStatus.js

@@ -0,0 +1,17 @@
+import { assertBoolean, assertNumber, assertString } from "../../parameterAssertUtils";
+export default 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"),
+        });
+    }
+}

package/dist/api/modules/AbstractStore.d.ts

@@ -0,0 +1,5 @@
+import { Json } from "../Response";
+export default interface AbstractStore {
+    loadOrDefault(defaultValue: Json): Promise<Json>;
+    save(value: Json): Promise<void>;
+}

package/dist/api/modules/AbstractStore.js

@@ -0,0 +1 @@
+export {};

package/dist/api/modules/ChromeStorageStore.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="chrome" />
+import { Json } from "../Response";
+import AbstractStore from "./AbstractStore";
+export default class ChromeStorageStore implements AbstractStore {
+    _key: string;
+    _chromeStorage: chrome.storage.StorageArea;
+    constructor(key: string, chromeStorage: chrome.storage.StorageArea);
+    loadOrDefault(defaultValue: Json): Promise<Json>;
+    save(value: Json): Promise<void>;
+}

package/dist/api/modules/ChromeStorageStore.js

@@ -0,0 +1,21 @@
+export default 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();
+            });
+        });
+    }
+}

package/dist/api/modules/LocalStorageStore.d.ts

@@ -0,0 +1,9 @@
+import { Json } from "../Response";
+import AbstractStore from "./AbstractStore";
+export default class LocalStorageStore implements AbstractStore {
+    _key: string;
+    _localStorage: Storage;
+    constructor(key: string, localStorage: Storage);
+    loadOrDefault(defaultValue: Json): Promise<Json>;
+    save(value: Json): Promise<void>;
+}

package/dist/api/modules/LocalStorageStore.js

@@ -0,0 +1,35 @@
+import { assertString, assertTruthy } from "../parameterAssertUtils";
+export default 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);
+        }
+    }
+}

package/dist/api/modules/tests/__mocks__/storage.d.ts

@@ -0,0 +1,10 @@
+export default class DummyStore implements Storage {
+    [name: string]: unknown;
+    length: number;
+    constructor();
+    clear(): void;
+    getItem(_key: string): string | null;
+    key(): string | null;
+    removeItem(): void;
+    setItem(): void;
+}

package/dist/api/modules/tests/__mocks__/storage.js

@@ -0,0 +1,19 @@
+export default class DummyStore {
+    constructor() {
+        this.length = 0;
+    }
+    clear() {
+        throw new Error("Method not implemented.");
+    }
+    getItem(_key) {
+        return "{}";
+    }
+    key() {
+        throw new Error("Method not implemented.");
+    }
+    removeItem() {
+        throw new Error("Method not implemented.");
+    }
+    setItem() {
+    }
+}

package/dist/api/organizationService/index.d.ts

@@ -0,0 +1,46 @@
+import Organization, { OrganizationPreferences } from "../models/Organization";
+import ApiClient from "../ApiClient";
+import { ConsentGrantRequest } from "../types";
+export default class OrganizationService {
+    _apiClient: ApiClient;
+    constructor({ apiClient }: {
+        apiClient: ApiClient;
+    });
+    createOrganization({ organizationName, subdomain, owner, }: {
+        organizationName: string;
+        subdomain: string;
+        owner: {
+            email: string;
+            displayName: string;
+            verificationCode: string;
+            consents?: ReadonlyArray<ConsentGrantRequest>;
+        } | {
+            idToken: string;
+            displayName: string;
+            consents?: ReadonlyArray<ConsentGrantRequest>;
+        };
+    }): Promise<string>;
+    getOrganizationBySubdomain(subdomain: string): Promise<Organization | null>;
+    getOrganizationByOrganizationId(organizationId: string): Promise<Organization | null>;
+    getOrganizationsByContactPoint(options: {
+        email: string;
+        code: string;
+    } | {
+        phoneNumber: string;
+        code: string;
+    }): Promise<ReadonlyArray<Organization>>;
+    getOrganizationsByIdToken({ idToken }: {
+        idToken: string;
+    }): Promise<ReadonlyArray<Organization>>;
+    getOrganizationsByLoggedInUser(): Promise<ReadonlyArray<Organization>>;
+    getSubdomainAvailability(subdomain: string): Promise<{
+        status: string;
+    }>;
+    updatePreferences({ organizationId, preferences, }: {
+        organizationId: string;
+        preferences: OrganizationPreferences;
+    }): Promise<undefined>;
+    deleteOrganization({ organizationId }: {
+        organizationId: string;
+    }): Promise<undefined>;
+}

package/dist/api/organizationService/index.js

@@ -0,0 +1,158 @@
+import assert from "assert";
+import Organization from "../models/Organization";
+import { assertInstanceOf, assertTruthy, assertString, assertArray, assertNullOrString, assertRecord, } from "../parameterAssertUtils";
+import Response from "../Response";
+import { extractArray, extractString } from "../extractUtils";
+export default 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");
+        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;
+        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);
+    }
+}

package/dist/api/organizationServiceCache/index.d.ts

@@ -0,0 +1,13 @@
+import OrganizationService from "../organizationService/index";
+import Organization from "../models/Organization";
+export default class OrganizationServiceCache {
+    private _organizationService;
+    private _subdomain;
+    private _organizationPromise;
+    constructor({ organizationService, subdomain }: {
+        organizationService: OrganizationService;
+        subdomain: string;
+    });
+    initOrganization(): Promise<void>;
+    fetchOrganization(): Promise<Organization | null>;
+}