@ovok/core 0.4.49-dev.495 → 0.4.49-dev.496

package/dist/next/resources/auth/registration.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patientRegistrationBody = exports.isClinicianInvite = exports.REGISTER_PATHS = void 0;
+exports.practitionerRegistrationBody = practitionerRegistrationBody;
+const ovok_errors_1 = require("../../errors/ovok-errors");
+exports.REGISTER_PATHS = {
+    patient: "auth/tenant/Patient/register",
+    practitioner: "auth/tenant/Practitioner/register",
+};
+const isClinicianInvite = (response) => "nextStep" in response && response.nextStep === "clinician-invite";
+exports.isClinicianInvite = isClinicianInvite;
+/** The confirmation is checked here and never sent. */
+function practitionerRegistrationBody(details, tenantCode) {
+    if (details.password !== details.passwordConfirm) {
+        throw new ovok_errors_1.OvokValidationError((0, ovok_errors_1.detailsFor)("Password and password confirm do not match."));
+    }
+    const { email, password, name, surname } = details;
+    return { email, password, name, surname, tenantCode };
+}
+const patientRegistrationBody = (details, tenantCode) => ({
+    ...practitionerRegistrationBody(details, tenantCode),
+    continueAsPatientToken: details.continueAsPatientToken,
+});
+exports.patientRegistrationBody = patientRegistrationBody;

package/dist/next/resources/auth/social-login.d.ts

@@ -0,0 +1,8 @@
+import type { AppleLoginBody } from "../../../client/auth/types/AppleLoginBody";
+import type { GoogleLoginBody } from "../../../client/auth/types/GoogleLoginBody";
+export type SocialCredentials = {
+    apple: AppleLoginBody;
+    google: GoogleLoginBody;
+};
+export type SocialProvider = keyof SocialCredentials;
+export declare const socialLoginPath: (provider: SocialProvider, clientId: string, internalId: string) => string;

package/dist/next/resources/auth/social-login.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.socialLoginPath = void 0;
+const query_string_1 = require("../../../client/query-string");
+const url_1 = require("../../http/url");
+const socialLoginPath = (provider, clientId, internalId) => `auth/external/${(0, url_1.pathSegment)(provider)}${(0, query_string_1.toQueryString)({ client: `ClientApplication/${clientId}`, internalId })}`;
+exports.socialLoginPath = socialLoginPath;

package/dist/next/resources/auth-resource.d.ts

@@ -0,0 +1,63 @@
+import type { ChangePasswordBody } from "../../client/auth/types/ChangePasswordBody";
+import type { ChangePasswordResponse } from "../../client/auth/types/ChangePasswordResponse";
+import type { CompletePasswordResetBody } from "../../client/auth/types/CompletePasswordResetBody";
+import type { RequestDeleteUserBody } from "../../client/auth/types/RequestDeleteUserBody";
+import type { RequestDeleteUserResponse } from "../../client/auth/types/RequestDeleteUserResponse";
+import type { ResetPasswordBody } from "../../client/auth/types/ResetPasswordBody";
+import type { OvokCurrentPatientProfile } from "../../client/patient/types";
+import type { OperationOutcome } from "@medplum/fhirtypes";
+import { Session } from "../auth/session";
+import { UserSession } from "../auth/user-session";
+import { HttpClient } from "../http/http-client";
+import { RequestOptions } from "../http/transmit";
+import { AuthSessionsResource } from "./auth/auth-sessions-resource";
+import { PatientRegistration, PractitionerRegistration, RegisterResult } from "./auth/registration";
+import { SocialCredentials, SocialProvider } from "./auth/social-login";
+export type ProfileType = "Patient" | "Practitioner" | "RelatedPerson";
+export type LoginCredentials = {
+    profileType: ProfileType;
+    email: string;
+    password: string;
+};
+/** Hand it back to `verifyMfa`: it carries the PKCE verifier the token exchange needs. */
+export type MfaChallenge = {
+    profileType: ProfileType;
+    loginId: string;
+    codeVerifier: string;
+};
+export type LoginResult = {
+    status: "signed-in";
+    session: Session;
+} | {
+    status: "mfa-required";
+    challenge: MfaChallenge;
+};
+export declare const ME_PATH = "auth/me";
+export declare class AuthResource {
+    private readonly http;
+    private readonly tenantCode;
+    private readonly session;
+    private readonly clientId;
+    readonly sessions: AuthSessionsResource;
+    /** `clientId` is the ClientApplication social sign-in and password resets go through. */
+    constructor(http: HttpClient, tenantCode: string, session: UserSession | null, clientId?: string | null);
+    login(credentials: LoginCredentials, options?: RequestOptions): Promise<LoginResult>;
+    verifyMfa(challenge: MfaChallenge, code: string, options?: RequestOptions): Promise<LoginResult>;
+    /** A project that routes the email to a clinician invitation signs no one in. */
+    register(details: PatientRegistration, options?: RequestOptions): Promise<RegisterResult>;
+    registerPractitioner(details: PractitionerRegistration, options?: RequestOptions): Promise<Session>;
+    socialLogin<P extends SocialProvider>(provider: P, credential: SocialCredentials[P], options?: RequestOptions): Promise<Session>;
+    current(): Promise<Session | null>;
+    me(options?: RequestOptions): Promise<OvokCurrentPatientProfile>;
+    /** The confirmation is the app's to check; Ovok Core never receives it. */
+    changePassword(change: ChangePasswordBody, options?: RequestOptions): Promise<ChangePasswordResponse>;
+    resetPassword(request: ResetPasswordBody, options?: RequestOptions): Promise<OperationOutcome>;
+    completePasswordReset(body: CompletePasswordResetBody, options?: RequestOptions): Promise<OperationOutcome>;
+    /** Schedules the deletion; the account stays signed in until then. */
+    deleteAccount(request: RequestDeleteUserBody, options?: RequestOptions): Promise<RequestDeleteUserResponse>;
+    /** Ends the session on the server, and always locally, even when the server cannot be reached. */
+    logout(options?: RequestOptions): Promise<void>;
+    private exchange;
+    private userSession;
+    private socialLoginClientId;
+}

package/dist/next/resources/auth-resource.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthResource = exports.ME_PATH = void 0;
+const generate_code_challenge_and_verifier_1 = require("../../client/auth/generate-code-challenge-and-verifier");
+const ovok_errors_1 = require("../errors/ovok-errors");
+const auth_sessions_resource_1 = require("./auth/auth-sessions-resource");
+const registration_1 = require("./auth/registration");
+const social_login_1 = require("./auth/social-login");
+exports.ME_PATH = "auth/me";
+const LOGOUT_PATH = "auth/session/current";
+const CHANGE_PASSWORD_PATH = "v2/auth/change-password";
+const RESET_PASSWORD_PATH = "v2/auth/reset-password";
+const COMPLETE_PASSWORD_RESET_PATH = "v2/auth/reset-password/process";
+const DELETE_ACCOUNT_PATH = "auth/delete";
+class AuthResource {
+    /** `clientId` is the ClientApplication social sign-in and password resets go through. */
+    constructor(http, tenantCode, session, clientId = null) {
+        this.http = http;
+        this.tenantCode = tenantCode;
+        this.session = session;
+        this.clientId = clientId;
+        this.sessions = new auth_sessions_resource_1.AuthSessionsResource(http, session);
+    }
+    async login(credentials, options) {
+        const session = this.userSession();
+        const { codeVerifier, codeChallenge } = (0, generate_code_challenge_and_verifier_1.generateCodeChallengeAndVerifier)();
+        const { profileType, email, password } = credentials;
+        const step = await this.http
+            .anonymous()
+            .post(loginPath(profileType, "start"), { email, password, codeChallenge }, options);
+        if (step.nextStep === "mfa") {
+            return { status: "mfa-required", challenge: { profileType, loginId: step.loginId, codeVerifier } };
+        }
+        return this.exchange(session, { profileType, sessionCode: step.sessionCode, codeVerifier }, options);
+    }
+    async verifyMfa(challenge, code, options) {
+        const session = this.userSession();
+        const { profileType, loginId, codeVerifier } = challenge;
+        const step = await this.http
+            .anonymous()
+            .post(loginPath(profileType, "mfa"), { loginId, mfaToken: code }, options);
+        return this.exchange(session, { profileType, sessionCode: step.sessionCode, codeVerifier }, options);
+    }
+    /** A project that routes the email to a clinician invitation signs no one in. */
+    async register(details, options) {
+        const session = this.userSession();
+        const body = (0, registration_1.patientRegistrationBody)(details, this.tenantCode);
+        const response = await this.http.anonymous().post(registration_1.REGISTER_PATHS.patient, body, options);
+        if ((0, registration_1.isClinicianInvite)(response)) {
+            return { status: "clinician-invite" };
+        }
+        return { status: "signed-in", session: await session.begin(response) };
+    }
+    async registerPractitioner(details, options) {
+        const session = this.userSession();
+        const body = (0, registration_1.practitionerRegistrationBody)(details, this.tenantCode);
+        return session.begin(await this.http.anonymous().post(registration_1.REGISTER_PATHS.practitioner, body, options));
+    }
+    async socialLogin(provider, credential, options) {
+        const session = this.userSession();
+        const { internalId, ...providerResult } = credential;
+        const path = (0, social_login_1.socialLoginPath)(provider, this.socialLoginClientId(), internalId);
+        return session.begin(await this.http.anonymous().post(path, providerResult, options));
+    }
+    async current() {
+        return this.session === null ? null : this.session.current();
+    }
+    me(options) {
+        return this.http.get(exports.ME_PATH, options);
+    }
+    /** The confirmation is the app's to check; Ovok Core never receives it. */
+    changePassword(change, options) {
+        const { oldPassword, newPassword } = change;
+        return this.http.patch(CHANGE_PASSWORD_PATH, { oldPassword, newPassword }, options);
+    }
+    resetPassword(request, options) {
+        var _a, _b;
+        const body = { ...request, clientId: (_b = (_a = request.clientId) !== null && _a !== void 0 ? _a : this.clientId) !== null && _b !== void 0 ? _b : undefined };
+        return this.http.anonymous().post(RESET_PASSWORD_PATH, body, options);
+    }
+    completePasswordReset(body, options) {
+        return this.http.anonymous().post(COMPLETE_PASSWORD_RESET_PATH, body, options);
+    }
+    /** Schedules the deletion; the account stays signed in until then. */
+    deleteAccount(request, options) {
+        return this.http.send({ method: "DELETE", path: DELETE_ACCOUNT_PATH, body: request }, options);
+    }
+    /** Ends the session on the server, and always locally, even when the server cannot be reached. */
+    async logout(options) {
+        const session = this.userSession();
+        try {
+            await this.http.delete(LOGOUT_PATH, options);
+        }
+        finally {
+            await session.end();
+        }
+    }
+    async exchange(session, exchange, options) {
+        const { profileType, sessionCode, codeVerifier } = exchange;
+        const tokens = await this.http
+            .anonymous()
+            .post(loginPath(profileType, "token"), { sessionCode, codeVerifier, tenantCode: this.tenantCode }, options);
+        return { status: "signed-in", session: await session.begin(tokens) };
+    }
+    userSession() {
+        if (this.session === null) {
+            throw new ovok_errors_1.OvokConfigError((0, ovok_errors_1.detailsFor)("This client signs in with clientSecret; user sign-in needs a client without one."));
+        }
+        return this.session;
+    }
+    socialLoginClientId() {
+        if (this.clientId === null) {
+            throw new ovok_errors_1.OvokConfigError((0, ovok_errors_1.detailsFor)("Social sign-in needs clientId in the Ovok config."));
+        }
+        return this.clientId;
+    }
+}
+exports.AuthResource = AuthResource;
+const loginPath = (profileType, step) => `auth/tenant/${profileType}/login/${step}`;

package/dist/next/resources/bots/bots-resource.d.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export type BotInput = Record<string, unknown>;
+export type BotOutput = Record<string, unknown>;
+export declare class BotsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** `identifier` is the bot's "system|value" identifier. */
+    execute(identifier: string, input: BotInput, options?: RequestOptions): Promise<BotOutput>;
+}

package/dist/next/resources/bots/bots-resource.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotsResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const BOTS_PATH = "bots";
+class BotsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    /** `identifier` is the bot's "system|value" identifier. */
+    execute(identifier, input, options) {
+        return this.http.post(`${BOTS_PATH}${(0, query_string_1.toQueryString)({ identifier })}`, input, options);
+    }
+}
+exports.BotsResource = BotsResource;

package/dist/next/resources/cms/cms-delivery.d.ts

@@ -0,0 +1,22 @@
+import type { OvokCmsPage } from "../../../client/cms/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+/** `locale` takes an app language ("de-DE") or a CMS locale ("de"); omitted, the CMS answers in its default. */
+export type CmsReadParams = {
+    locale?: string;
+};
+/** `limit` is at most 50; `sort` is a top-level field, "-" for descending. */
+export type CmsListParams = CmsReadParams & {
+    page?: number;
+    limit?: number;
+    sort?: string;
+};
+/** Published documents, always read as the client's tenant: signed out, the CMS knows it only from `?tenant=`. */
+export declare class CmsDelivery {
+    private readonly http;
+    private readonly tenantCode;
+    constructor(http: HttpClient, tenantCode: string);
+    listPage<T extends object>(collection: string, params: CmsListParams, options?: RequestOptions): Promise<OvokCmsPage<T>>;
+    retrieve<T extends object>(collection: string, slug: string, params: CmsReadParams, options?: RequestOptions): Promise<T>;
+    private queryFor;
+}

package/dist/next/resources/cms/cms-delivery.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CmsDelivery = void 0;
+const locale_1 = require("../../../client/cms/locale");
+const query_string_1 = require("../../../client/query-string");
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const url_1 = require("../../http/url");
+const COLLECTIONS_PATH = "v1/public/cms/collections";
+const itemsPath = (collection) => `${COLLECTIONS_PATH}/${(0, url_1.pathSegment)(collection)}/items`;
+/** Published documents, always read as the client's tenant: signed out, the CMS knows it only from `?tenant=`. */
+class CmsDelivery {
+    constructor(http, tenantCode) {
+        this.http = http;
+        this.tenantCode = tenantCode;
+    }
+    listPage(collection, params, options) {
+        return this.http.get(`${itemsPath(collection)}${this.queryFor(params)}`, options);
+    }
+    async retrieve(collection, slug, params, options) {
+        if (slug === "") {
+            throw new ovok_errors_1.OvokValidationError((0, ovok_errors_1.detailsFor)("A CMS document read needs a slug."));
+        }
+        return this.http.get(`${itemsPath(collection)}/${(0, url_1.pathSegment)(slug)}${this.queryFor(params)}`, options);
+    }
+    // An empty locale or sort counts as absent.
+    queryFor({ locale, page, limit, sort }) {
+        return (0, query_string_1.toQueryString)({
+            locale: locale ? (0, locale_1.toCmsLocale)(locale) : undefined,
+            tenant: this.tenantCode,
+            page,
+            limit,
+            sort: sort || undefined,
+        });
+    }
+}
+exports.CmsDelivery = CmsDelivery;

package/dist/next/resources/cms/cms-documents-resource.d.ts

@@ -0,0 +1,11 @@
+import type { OvokCmsDocument } from "../../../client/cms/types";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+import { CmsDelivery, CmsListParams, CmsReadParams } from "./cms-delivery";
+/** Published documents of any collection, merged with the shared tenant's. */
+export declare class CmsDocumentsResource {
+    private readonly delivery;
+    constructor(delivery: CmsDelivery);
+    list<T extends object = OvokCmsDocument>(collection: string, params?: CmsListParams, options?: RequestOptions): PagePromise<T>;
+    retrieve<T extends object = OvokCmsDocument>(collection: string, slug: string, params?: CmsReadParams, options?: RequestOptions): Promise<T>;
+}

package/dist/next/resources/cms/cms-documents-resource.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CmsDocumentsResource = void 0;
+const payload_pages_1 = require("./payload-pages");
+/** Published documents of any collection, merged with the shared tenant's. */
+class CmsDocumentsResource {
+    constructor(delivery) {
+        this.delivery = delivery;
+    }
+    list(collection, params = {}, options) {
+        return (0, payload_pages_1.payloadPages)((page) => this.delivery.listPage(collection, { ...params, page }, options), params.page);
+    }
+    retrieve(collection, slug, params = {}, options) {
+        return this.delivery.retrieve(collection, slug, params, options);
+    }
+}
+exports.CmsDocumentsResource = CmsDocumentsResource;

package/dist/next/resources/cms/cms-resource.d.ts

@@ -0,0 +1,17 @@
+import type { OvokCmsDocument, OvokTranslations } from "../../../client/cms/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { CmsReadParams } from "./cms-delivery";
+import { CmsDocumentsResource } from "./cms-documents-resource";
+import { ReleaseNotesResource } from "./release-notes-resource";
+export declare class CmsResource {
+    readonly documents: CmsDocumentsResource;
+    readonly releaseNotes: ReleaseNotesResource;
+    private readonly delivery;
+    constructor(http: HttpClient, tenantCode: string);
+    /** "terms-and-conditions", "data-privacy", …: readable before sign-in. */
+    legalPage(slug: string, params?: CmsReadParams, options?: RequestOptions): Promise<OvokCmsDocument>;
+    /** The `translations` collection as one tree, readable before sign-in; nothing is kept on the device. */
+    translations(locale?: string, options?: RequestOptions): Promise<OvokTranslations>;
+    private translationDocuments;
+}

package/dist/next/resources/cms/cms-resource.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CmsResource = void 0;
+const cms_delivery_1 = require("./cms-delivery");
+const cms_documents_resource_1 = require("./cms-documents-resource");
+const release_notes_resource_1 = require("./release-notes-resource");
+const translation_tree_1 = require("./translation-tree");
+const LEGAL_PAGES = "legal-pages";
+const TRANSLATIONS = "translations";
+const FIRST_PAGE = 1;
+const LARGEST_PAGE_SIZE = 50;
+const MAX_TRANSLATION_PAGES = 20;
+class CmsResource {
+    constructor(http, tenantCode) {
+        this.delivery = new cms_delivery_1.CmsDelivery(http, tenantCode);
+        this.documents = new cms_documents_resource_1.CmsDocumentsResource(this.delivery);
+        this.releaseNotes = new release_notes_resource_1.ReleaseNotesResource(this.documents);
+    }
+    /** "terms-and-conditions", "data-privacy", …: readable before sign-in. */
+    legalPage(slug, params = {}, options) {
+        return this.documents.retrieve(LEGAL_PAGES, slug, params, options);
+    }
+    /** The `translations` collection as one tree, readable before sign-in; nothing is kept on the device. */
+    async translations(locale, options) {
+        return (0, translation_tree_1.translationTree)(await this.translationDocuments(locale, options));
+    }
+    async translationDocuments(locale, options) {
+        const documents = [];
+        for (let page = FIRST_PAGE, hasNextPage = true; hasNextPage && page <= MAX_TRANSLATION_PAGES; page++) {
+            const params = { locale, page, limit: LARGEST_PAGE_SIZE };
+            const result = await this.delivery.listPage(TRANSLATIONS, params, options);
+            documents.push(...result.docs);
+            hasNextPage = result.hasNextPage;
+        }
+        return documents;
+    }
+}
+exports.CmsResource = CmsResource;

package/dist/next/resources/cms/payload-pages.d.ts

@@ -0,0 +1,6 @@
+import type { OvokCmsPage } from "../../../client/cms/types";
+import { PagePromise } from "../../paging/page";
+type LoadPayloadPage<T> = (page: number | undefined) => Promise<OvokCmsPage<T>>;
+/** Payload CMS's list envelope: 1-based pages, with `nextPage` null on the last. */
+export declare function payloadPages<T>(load: LoadPayloadPage<T>, firstPage: number | undefined): PagePromise<T>;
+export {};

package/dist/next/resources/cms/payload-pages.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.payloadPages = payloadPages;
+const page_1 = require("../../paging/page");
+/** Payload CMS's list envelope: 1-based pages, with `nextPage` null on the last. */
+function payloadPages(load, firstPage) {
+    return (0, page_1.pagePromise)(() => loadPayloadPage(load, firstPage));
+}
+async function loadPayloadPage(load, page) {
+    const { docs, totalDocs, nextPage } = await load(page);
+    return {
+        page: { data: docs, hasMore: nextPage !== null, total: totalDocs },
+        next: nextPage === null ? null : () => loadPayloadPage(load, nextPage),
+    };
+}

package/dist/next/resources/cms/release-notes-resource.d.ts

@@ -0,0 +1,10 @@
+import type { OvokCmsDocument } from "../../../client/cms/types";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+import { CmsListParams } from "./cms-delivery";
+import { CmsDocumentsResource } from "./cms-documents-resource";
+export declare class ReleaseNotesResource {
+    private readonly documents;
+    constructor(documents: CmsDocumentsResource);
+    list(params?: CmsListParams, options?: RequestOptions): PagePromise<OvokCmsDocument>;
+}

package/dist/next/resources/cms/release-notes-resource.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleaseNotesResource = void 0;
+const RELEASE_NOTES = "release-notes";
+const NEWEST_FIRST = "-publishedAt";
+class ReleaseNotesResource {
+    constructor(documents) {
+        this.documents = documents;
+    }
+    list(params = {}, options) {
+        var _a;
+        return this.documents.list(RELEASE_NOTES, { ...params, sort: (_a = params.sort) !== null && _a !== void 0 ? _a : NEWEST_FIRST }, options);
+    }
+}
+exports.ReleaseNotesResource = ReleaseNotesResource;

package/dist/next/resources/cms/translation-tree.d.ts

@@ -0,0 +1,3 @@
+import type { OvokCmsDocument, OvokTranslations } from "../../../client/cms/types";
+/** A group per document slug, holding each row's `value` at its `key`, nested at the dots; the first row wins. */
+export declare function translationTree(documents: OvokCmsDocument[]): OvokTranslations;

package/dist/next/resources/cms/translation-tree.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translationTree = translationTree;
+const KEY_SEPARATOR = ".";
+/** Keys that would reach a prototype instead of the tree; keys are CMS input. */
+const UNSAFE_KEYS = ["__proto__", "constructor", "prototype"];
+const isText = (value) => typeof value === "string" && value !== "";
+const hasOwn = (tree, key) => Object.prototype.hasOwnProperty.call(tree, key);
+/** A group per document slug, holding each row's `value` at its `key`, nested at the dots; the first row wins. */
+function translationTree(documents) {
+    const translations = {};
+    for (const { slug, strings } of documents) {
+        const rows = Array.isArray(strings) ? strings : [];
+        if (isText(slug)) {
+            rows.forEach((row) => addRow(translations, slug, row));
+        }
+    }
+    return translations;
+}
+const addRow = (translations, slug, row) => {
+    const { key, value } = row !== null && row !== void 0 ? row : {};
+    if (isText(key) && isText(value)) {
+        setText(translations, [slug, ...key.split(KEY_SEPARATOR)], value);
+    }
+};
+const setText = (tree, path, text) => {
+    const reachesPrototype = path.some((key) => UNSAFE_KEYS.includes(key));
+    const group = reachesPrototype ? null : groupAt(tree, path.slice(0, -1));
+    const leaf = path[path.length - 1];
+    if (group !== null && !hasOwn(group, leaf)) {
+        group[leaf] = text;
+    }
+};
+/** The group at `keys`, made where missing; null when a text is in the way. */
+const groupAt = (tree, keys) => {
+    let group = tree;
+    for (const key of keys) {
+        const next = hasOwn(group, key) ? group[key] : (group[key] = {});
+        if (typeof next === "string") {
+            return null;
+        }
+        group = next;
+    }
+    return group;
+};

package/dist/next/resources/consent/consent-resource.d.ts

@@ -0,0 +1,23 @@
+import type { LegalConsentResponse, MedicalConsentResponse } from "../../../client/consent/types";
+import type { OvokConsentSignatureResponse } from "../../../client/experience/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class LegalConsentResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    retrieve(options?: RequestOptions): Promise<LegalConsentResponse>;
+    set(accepted: boolean, options?: RequestOptions): Promise<LegalConsentResponse>;
+}
+export declare class MedicalConsentResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    retrieve(options?: RequestOptions): Promise<MedicalConsentResponse>;
+    set(accepted: boolean, options?: RequestOptions): Promise<MedicalConsentResponse>;
+}
+export declare class ConsentResource {
+    private readonly http;
+    readonly legal: LegalConsentResource;
+    readonly medical: MedicalConsentResource;
+    constructor(http: HttpClient);
+    requestSignature(consentId: string, options?: RequestOptions): Promise<OvokConsentSignatureResponse>;
+}

package/dist/next/resources/consent/consent-resource.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsentResource = exports.MedicalConsentResource = exports.LegalConsentResource = void 0;
+const url_1 = require("../../http/url");
+const LEGAL_CONSENT_PATH = "v1/me/consent/legal";
+const MEDICAL_CONSENT_PATH = "v1/me/consent/medical";
+class LegalConsentResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(options) {
+        return this.http.get(LEGAL_CONSENT_PATH, options);
+    }
+    set(accepted, options) {
+        const body = { termsAndConditionsConsent: accepted };
+        return this.http.post(LEGAL_CONSENT_PATH, body, options);
+    }
+}
+exports.LegalConsentResource = LegalConsentResource;
+class MedicalConsentResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(options) {
+        return this.http.get(MEDICAL_CONSENT_PATH, options);
+    }
+    set(accepted, options) {
+        const body = { medicalSettingsNotificationsConsent: accepted };
+        return this.http.post(MEDICAL_CONSENT_PATH, body, options);
+    }
+}
+exports.MedicalConsentResource = MedicalConsentResource;
+class ConsentResource {
+    constructor(http) {
+        this.http = http;
+        this.legal = new LegalConsentResource(http);
+        this.medical = new MedicalConsentResource(http);
+    }
+    requestSignature(consentId, options) {
+        return this.http.post(`consent/signature/${(0, url_1.pathSegment)(consentId)}`, undefined, options);
+    }
+}
+exports.ConsentResource = ConsentResource;

package/dist/next/resources/content/content-resource.d.ts

@@ -0,0 +1,19 @@
+import type { OvokContent, OvokContentBody, OvokContentQuery, OvokContentSearchResponse, OvokMappedContentSearchResponse } from "../../../client/experience/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export type CopyFromParentResult = {
+    success: boolean;
+};
+export declare class ContentResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    search(type: string, language: string, params?: OvokContentQuery, options?: RequestOptions): Promise<OvokContentSearchResponse>;
+    retrieve(type: string, language: string, key: string, options?: RequestOptions): Promise<OvokContent>;
+    create(type: string, language: string, body: OvokContentBody, options?: RequestOptions): Promise<OvokContent>;
+    update(type: string, language: string, key: string, body: OvokContentBody, options?: RequestOptions): Promise<OvokContent>;
+    delete(type: string, language: string, key: string, options?: RequestOptions): Promise<void>;
+    /** Pairs each default-language item with its `language` translation. */
+    map(type: string, language: string, params?: OvokContentQuery, options?: RequestOptions): Promise<OvokMappedContentSearchResponse>;
+    copyFromParent(type: string, language: string, key: string, options?: RequestOptions): Promise<CopyFromParentResult>;
+    copyAllFromParent(type: string, language: string, options?: RequestOptions): Promise<CopyFromParentResult>;
+}

package/dist/next/resources/content/content-resource.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const url_1 = require("../../http/url");
+const CONTENT_PATH = "cms";
+const COPY_FROM_PARENT = "copy-from-parent-project";
+const typePath = (type) => `${CONTENT_PATH}/${(0, url_1.pathSegment)(type)}`;
+const languagePath = (type, language) => `${typePath(type)}/${(0, url_1.pathSegment)(language)}`;
+const keyPath = (type, language, key) => `${languagePath(type, language)}/${(0, url_1.pathSegment)(key)}`;
+class ContentResource {
+    constructor(http) {
+        this.http = http;
+    }
+    search(type, language, params = {}, options) {
+        return this.http.get(`${languagePath(type, language)}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    retrieve(type, language, key, options) {
+        return this.http.get(keyPath(type, language, key), options);
+    }
+    create(type, language, body, options) {
+        return this.http.post(languagePath(type, language), body, options);
+    }
+    update(type, language, key, body, options) {
+        return this.http.put(keyPath(type, language, key), body, options);
+    }
+    delete(type, language, key, options) {
+        return this.http.delete(keyPath(type, language, key), options);
+    }
+    /** Pairs each default-language item with its `language` translation. */
+    map(type, language, params = {}, options) {
+        return this.http.get(`${typePath(type)}/map/${(0, url_1.pathSegment)(language)}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    copyFromParent(type, language, key, options) {
+        return this.http.post(`${keyPath(type, language, key)}/${COPY_FROM_PARENT}`, undefined, options);
+    }
+    copyAllFromParent(type, language, options) {
+        return this.http.post(`${languagePath(type, language)}/${COPY_FROM_PARENT}`, undefined, options);
+    }
+}
+exports.ContentResource = ContentResource;