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

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;

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

@@ -0,0 +1,26 @@
+import type { OvokDocumentFile, OvokDocumentMetadataUpdate, OvokDocumentReplacement, OvokDocumentSearchQuery, OvokDocumentSearchResponse, OvokDocumentUploadRequest } from "../../../client/experience/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export type DocumentDownloadParams = {
+    width?: string | number;
+    height?: string | number;
+    fit?: string;
+};
+export type DeletedDocument = {
+    message: string;
+};
+export declare class DocumentsResource {
+    private readonly http;
+    private readonly baseUrl;
+    constructor(http: HttpClient, baseUrl: string);
+    list(params?: OvokDocumentSearchQuery, options?: RequestOptions): Promise<OvokDocumentSearchResponse>;
+    createUpload(body: OvokDocumentUploadRequest, options?: RequestOptions): Promise<OvokDocumentFile>;
+    replaceUpload(documentId: string, body: OvokDocumentReplacement, options?: RequestOptions): Promise<OvokDocumentFile>;
+    updateMetadata(documentId: string, body: OvokDocumentMetadataUpdate, options?: RequestOptions): Promise<OvokDocumentFile>;
+    delete(documentId: string, options?: RequestOptions): Promise<DeletedDocument>;
+    /** The signed-in route: fetched with the bearer, it redirects to a signed download URL. */
+    downloadUrl(documentId: string, params?: DocumentDownloadParams): string;
+    /** Needs no bearer, so it fits an image, download or media element. */
+    publicDownloadUrl(publicToken: string, params?: DocumentDownloadParams): string;
+    private urlFor;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentsResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const url_1 = require("../../http/url");
+const DOCUMENT_PATH = "document";
+const PUBLIC_DOCUMENT_PATH = "document/public";
+const documentPath = (documentId) => `${DOCUMENT_PATH}/${(0, url_1.pathSegment)(documentId)}`;
+class DocumentsResource {
+    constructor(http, baseUrl) {
+        this.http = http;
+        this.baseUrl = baseUrl;
+    }
+    list(params = {}, options) {
+        return this.http.get(`${DOCUMENT_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    createUpload(body, options) {
+        return this.http.post(DOCUMENT_PATH, body, options);
+    }
+    replaceUpload(documentId, body, options) {
+        return this.http.post(documentPath(documentId), body, options);
+    }
+    updateMetadata(documentId, body, options) {
+        return this.http.patch(documentPath(documentId), body, options);
+    }
+    delete(documentId, options) {
+        return this.http.delete(documentPath(documentId), options);
+    }
+    /** The signed-in route: fetched with the bearer, it redirects to a signed download URL. */
+    downloadUrl(documentId, params = {}) {
+        return this.urlFor(documentPath(documentId), params);
+    }
+    /** Needs no bearer, so it fits an image, download or media element. */
+    publicDownloadUrl(publicToken, params = {}) {
+        return this.urlFor(`${PUBLIC_DOCUMENT_PATH}/${(0, url_1.pathSegment)(publicToken)}`, params);
+    }
+    urlFor(path, params) {
+        return `${(0, url_1.joinPath)(this.baseUrl, path)}${(0, query_string_1.toQueryString)(params)}`;
+    }
+}
+exports.DocumentsResource = DocumentsResource;

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

@@ -0,0 +1,6 @@
+import { HttpClient } from "../../http/http-client";
+import { EmailTemplatesResource } from "./email-templates-resource";
+export declare class EmailResource {
+    readonly templates: EmailTemplatesResource;
+    constructor(http: HttpClient);
+}

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailResource = void 0;
+const email_templates_resource_1 = require("./email-templates-resource");
+class EmailResource {
+    constructor(http) {
+        this.templates = new email_templates_resource_1.EmailTemplatesResource(http);
+    }
+}
+exports.EmailResource = EmailResource;

package/dist/next/resources/email/email-templates-resource.d.ts

@@ -0,0 +1,8 @@
+import type { OvokEmailTemplates } from "../../../client/email/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class EmailTemplatesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(options?: RequestOptions): Promise<OvokEmailTemplates>;
+}

package/dist/next/resources/email/email-templates-resource.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailTemplatesResource = void 0;
+const EMAIL_TEMPLATES_PATH = "v1/email/templates";
+class EmailTemplatesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(options) {
+        return this.http.get(EMAIL_TEMPLATES_PATH, options);
+    }
+}
+exports.EmailTemplatesResource = EmailTemplatesResource;

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

@@ -0,0 +1,28 @@
+import type { Bundle, ExtractResource, Resource, ResourceType } from "@medplum/fhirtypes";
+import { HttpClient } from "../http/http-client";
+import { RequestOptions } from "../http/transmit";
+import { QueryParams } from "../http/url";
+import { PagePromise } from "../paging/page";
+export type PatchOperation = {
+    op: "add" | "remove" | "replace" | "copy" | "move" | "test";
+    path: string;
+    value?: unknown;
+    from?: string;
+};
+export type CreateOptions = RequestOptions & {
+    ifNoneExist?: string;
+};
+export declare class FhirResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    read<K extends ResourceType>(type: K, id: string, options?: RequestOptions): Promise<ExtractResource<K>>;
+    search<K extends ResourceType>(type: K, params?: QueryParams, options?: RequestOptions): PagePromise<ExtractResource<K>>;
+    searchOne<K extends ResourceType>(type: K, params?: QueryParams, options?: RequestOptions): Promise<ExtractResource<K> | null>;
+    /** With `ifNoneExist`, a retry cannot create a duplicate, so the request is safe to repeat. */
+    create<T extends Resource>(resource: T, options?: CreateOptions): Promise<T>;
+    update<T extends Resource>(resource: T, options?: RequestOptions): Promise<T>;
+    patch<K extends ResourceType>(type: K, id: string, operations: PatchOperation[], options?: RequestOptions): Promise<ExtractResource<K>>;
+    delete(type: ResourceType, id: string, options?: RequestOptions): Promise<void>;
+    batch(bundle: Bundle, options?: RequestOptions): Promise<Bundle>;
+    private searchPage;
+}

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FhirResource = void 0;
+const ovok_errors_1 = require("../errors/ovok-errors");
+const url_1 = require("../http/url");
+const bundle_page_1 = require("../paging/bundle-page");
+const page_1 = require("../paging/page");
+const FHIR_JSON = "application/fhir+json";
+const READ_HEADERS = { Accept: FHIR_JSON };
+const WRITE_HEADERS = { Accept: FHIR_JSON, "Content-Type": FHIR_JSON };
+const PATCH_HEADERS = { Accept: FHIR_JSON, "Content-Type": "application/json-patch+json" };
+class FhirResource {
+    constructor(http) {
+        this.http = http;
+    }
+    read(type, id, options) {
+        return this.http.send({ method: "GET", path: resourcePath(type, id), headers: READ_HEADERS }, options);
+    }
+    search(type, params = {}, options) {
+        return (0, page_1.pagePromise)(() => this.searchPage(type, (0, url_1.toSearchQuery)(params), options));
+    }
+    async searchOne(type, params = {}, options) {
+        var _a;
+        const page = await this.search(type, { ...params, _count: 1 }, options);
+        return (_a = page.data[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    /** With `ifNoneExist`, a retry cannot create a duplicate, so the request is safe to repeat. */
+    create(resource, options = {}) {
+        const { ifNoneExist, ...requestOptions } = options;
+        const condition = ifNoneExist === undefined ? {} : { "If-None-Exist": ifNoneExist };
+        return this.http.send({
+            method: "POST",
+            path: resource.resourceType,
+            body: resource,
+            headers: { ...WRITE_HEADERS, ...condition },
+            idempotent: ifNoneExist !== undefined,
+        }, requestOptions);
+    }
+    update(resource, options) {
+        const path = resourcePath(resource.resourceType, requireId(resource));
+        return this.http.send({ method: "PUT", path, body: resource, headers: WRITE_HEADERS }, options);
+    }
+    patch(type, id, operations, options) {
+        return this.http.send({ method: "PATCH", path: resourcePath(type, id), body: operations, headers: PATCH_HEADERS }, options);
+    }
+    delete(type, id, options) {
+        return this.http.send({ method: "DELETE", path: resourcePath(type, id), headers: READ_HEADERS }, options);
+    }
+    batch(bundle, options) {
+        return this.http.send({ method: "POST", path: "", body: bundle, headers: WRITE_HEADERS }, options);
+    }
+    async searchPage(type, query, options) {
+        const bundle = await this.http.send({ method: "GET", path: `${type}${query}`, headers: READ_HEADERS }, options);
+        return (0, bundle_page_1.bundlePage)(bundle, (nextQuery) => this.searchPage(type, nextQuery, options));
+    }
+}
+exports.FhirResource = FhirResource;
+const resourcePath = (type, id) => `${type}/${(0, url_1.pathSegment)(id)}`;
+const requireId = (resource) => {
+    if (resource.id === undefined) {
+        throw new ovok_errors_1.OvokValidationError((0, ovok_errors_1.detailsFor)(`update needs ${resource.resourceType}.id.`));
+    }
+    return resource.id;
+};

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

@@ -0,0 +1,17 @@
+import { HttpClient } from "../http/http-client";
+import { RequestOptions } from "../http/transmit";
+export type HealthCheck = {
+    ok: boolean;
+    dependencies: Record<string, {
+        ok: boolean;
+    }>;
+    version?: string | null;
+    buildEnv?: string | null;
+    commitHash?: string | null;
+};
+export declare class HealthResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Always answers 200: read `ok`, not the status. */
+    check(options?: RequestOptions): Promise<HealthCheck>;
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthResource = void 0;
+const HEALTHCHECK_PATH = "healthcheck";
+class HealthResource {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Always answers 200: read `ok`, not the status. */
+    check(options) {
+        return this.http.get(HEALTHCHECK_PATH, options);
+    }
+}
+exports.HealthResource = HealthResource;

package/dist/next/resources/invites/invite-flow-resource.d.ts

@@ -0,0 +1,12 @@
+import type { InviteSent } from "../../../client/invites/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+/** One invite kind: `create` sends it to `path`, `accept` redeems it at `path/accept`. */
+export declare class InviteFlowResource<Invite, Acceptance, Accepted> {
+    private readonly http;
+    private readonly path;
+    private readonly acceptPath;
+    constructor(http: HttpClient, path: string);
+    create(body: Invite, options?: RequestOptions): Promise<InviteSent>;
+    accept(body: Acceptance, options?: RequestOptions): Promise<Accepted>;
+}

package/dist/next/resources/invites/invite-flow-resource.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InviteFlowResource = void 0;
+const ACCEPT_SEGMENT = "accept";
+/** One invite kind: `create` sends it to `path`, `accept` redeems it at `path/accept`. */
+class InviteFlowResource {
+    constructor(http, path) {
+        this.http = http;
+        this.path = path;
+        this.acceptPath = `${path}/${ACCEPT_SEGMENT}`;
+    }
+    create(body, options) {
+        return this.http.post(this.path, body, options);
+    }
+    accept(body, options) {
+        return this.http.post(this.acceptPath, body, options);
+    }
+}
+exports.InviteFlowResource = InviteFlowResource;

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

@@ -0,0 +1,22 @@
+import type { AcceptInviteBody, AcceptRecordShareBody, InviteBody, RecordShareAccepted, RecordShareBody } from "../../../client/invites/types";
+import type { PatientSharingPractitionerShare } from "../../../client/patient-sharing/types";
+import type { UserSession } from "../../auth/user-session";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { InviteFlowResource } from "./invite-flow-resource";
+export type RecordShareFlow = InviteFlowResource<RecordShareBody, AcceptRecordShareBody, RecordShareAccepted>;
+export type PersonInviteFlow = InviteFlowResource<InviteBody, AcceptInviteBody, PatientSharingPractitionerShare>;
+export declare class InvitesResource {
+    private readonly session;
+    /** A patient shares their record with a practitioner, or some codes with a carer. */
+    readonly recordShares: RecordShareFlow;
+    /** A practitioner invites a patient into their care. */
+    readonly care: PersonInviteFlow;
+    /** @deprecated Use `recordShares` with `recipient: "practitioner"`; the route sunsets on 2026-12-01. */
+    readonly practitioners: PersonInviteFlow;
+    /** @deprecated Use `care`; the route sunsets on 2026-12-01. */
+    readonly patients: PersonInviteFlow;
+    constructor(http: HttpClient, session?: UserSession | null);
+    /** Accepts a record share as a practitioner or a care invite as a patient. */
+    accept(body: AcceptInviteBody, options?: RequestOptions): Promise<PatientSharingPractitionerShare>;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvitesResource = void 0;
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const invite_flow_resource_1 = require("./invite-flow-resource");
+const INVITES_PATH = "v1/invites";
+class InvitesResource {
+    constructor(http, session = null) {
+        this.session = session;
+        this.recordShares = new invite_flow_resource_1.InviteFlowResource(http, `${INVITES_PATH}/record-share`);
+        this.care = new invite_flow_resource_1.InviteFlowResource(http, `${INVITES_PATH}/care`);
+        this.practitioners = new invite_flow_resource_1.InviteFlowResource(http, `${INVITES_PATH}/practitioner`);
+        this.patients = new invite_flow_resource_1.InviteFlowResource(http, `${INVITES_PATH}/patient`);
+    }
+    /** Accepts a record share as a practitioner or a care invite as a patient. */
+    async accept(body, options) {
+        var _a, _b;
+        const profileReference = (_b = (await ((_a = this.session) === null || _a === void 0 ? void 0 : _a.current()))) === null || _b === void 0 ? void 0 : _b.profile.reference;
+        const profileType = profileReference === null || profileReference === void 0 ? void 0 : profileReference.split("/", 1)[0];
+        if (profileType === "Practitioner") {
+            return this.recordShares.accept(body, options);
+        }
+        if (profileType === "Patient") {
+            return this.care.accept(body, options);
+        }
+        throw new ovok_errors_1.OvokConfigError((0, ovok_errors_1.detailsFor)("Accepting an invite requires a signed-in Patient or Practitioner profile."));
+    }
+}
+exports.InvitesResource = InvitesResource;

package/dist/next/resources/localization/i18next-resource.d.ts

@@ -0,0 +1,10 @@
+import type { OvokI18nDocument, OvokI18nValue } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class I18nextResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    retrieve(language: string, options?: RequestOptions): Promise<OvokI18nDocument>;
+    /** The server queues the write (202), so a read right after may not show it yet. */
+    update(language: string, document: Record<string, OvokI18nValue>, options?: RequestOptions): Promise<void>;
+}

package/dist/next/resources/localization/i18next-resource.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nextResource = void 0;
+const url_1 = require("../../http/url");
+const i18nextPath = (language) => `localization/i18next/${(0, url_1.pathSegment)(language)}`;
+class I18nextResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(language, options) {
+        return this.http.get(i18nextPath(language), options);
+    }
+    /** The server queues the write (202), so a read right after may not show it yet. */
+    update(language, document, options) {
+        return this.http.patch(i18nextPath(language), document, options);
+    }
+}
+exports.I18nextResource = I18nextResource;

package/dist/next/resources/localization/locales-resource.d.ts

@@ -0,0 +1,9 @@
+import type { OvokLocales } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class LocalesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    retrieve(options?: RequestOptions): Promise<OvokLocales>;
+    update(locales: OvokLocales, options?: RequestOptions): Promise<OvokLocales>;
+}