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

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,17 @@
+import type { AcceptInviteBody, AcceptRecordShareBody, InviteBody, RecordShareAccepted, RecordShareBody } from "../../../client/invites/types";
+import type { PatientSharingPractitionerShare } from "../../../client/patient-sharing/types";
+import { HttpClient } from "../../http/http-client";
+import { InviteFlowResource } from "./invite-flow-resource";
+export type RecordShareFlow = InviteFlowResource<RecordShareBody, AcceptRecordShareBody, RecordShareAccepted>;
+export type PersonInviteFlow = InviteFlowResource<InviteBody, AcceptInviteBody, PatientSharingPractitionerShare>;
+export declare class InvitesResource {
+    /** 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);
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvitesResource = void 0;
+const invite_flow_resource_1 = require("./invite-flow-resource");
+const INVITES_PATH = "v1/invites";
+class InvitesResource {
+    constructor(http) {
+        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`);
+    }
+}
+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>;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalesResource = void 0;
+const LOCALES_PATH = "locales";
+class LocalesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(options) {
+        return this.http.get(LOCALES_PATH, options);
+    }
+    update(locales, options) {
+        return this.http.patch(LOCALES_PATH, locales, options);
+    }
+}
+exports.LocalesResource = LocalesResource;

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

@@ -0,0 +1,17 @@
+import type { OvokLocalization, OvokLocalizationQuery, OvokLocalizationUpdate } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { I18nextResource } from "./i18next-resource";
+export type LocalizationList = {
+    total: number;
+    resources: OvokLocalization[];
+};
+export declare class LocalizationsResource {
+    private readonly http;
+    readonly i18next: I18nextResource;
+    constructor(http: HttpClient);
+    list(language: string, query?: OvokLocalizationQuery, options?: RequestOptions): Promise<LocalizationList>;
+    retrieve(language: string, key: string, options?: RequestOptions): Promise<OvokLocalization>;
+    update(language: string, key: string, body: OvokLocalizationUpdate, options?: RequestOptions): Promise<OvokLocalization>;
+    delete(language: string, key: string, options?: RequestOptions): Promise<void>;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalizationsResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const url_1 = require("../../http/url");
+const i18next_resource_1 = require("./i18next-resource");
+const languagePath = (language) => `localization/${(0, url_1.pathSegment)(language)}`;
+const entryPath = (language, key) => `${languagePath(language)}/${(0, url_1.pathSegment)(key)}`;
+class LocalizationsResource {
+    constructor(http) {
+        this.http = http;
+        this.i18next = new i18next_resource_1.I18nextResource(http);
+    }
+    list(language, query = {}, options) {
+        return this.http.get(`${languagePath(language)}${(0, query_string_1.toQueryString)(query)}`, options);
+    }
+    retrieve(language, key, options) {
+        return this.http.get(entryPath(language, key), options);
+    }
+    update(language, key, body, options) {
+        return this.http.put(entryPath(language, key), body, options);
+    }
+    delete(language, key, options) {
+        return this.http.delete(entryPath(language, key), options);
+    }
+}
+exports.LocalizationsResource = LocalizationsResource;

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

@@ -0,0 +1,42 @@
+import type { GetLatestObservationsByCodeParams } from "../../../client/observation/types/GetLatestObservationsByCodeParams";
+import type { Bundle, Observation } from "@medplum/fhirtypes";
+import { observationCodesForTypes } from "../../../client/observation/methods/observationsToMeasurements";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { FhirResource } from "../fhir-resource";
+import { BuildObservationsParams } from "./observation-builder";
+import { SessionSource } from "./signed-in-account";
+export type SaveObservationsOptions = RequestOptions & {
+    /** Identifier systems that name a reading for good; the SDK's device-reading id always counts. */
+    identifierSystems?: readonly string[];
+    /** Write over the observation saved under the same reading identifiers, for a value that changes. */
+    replace?: boolean;
+};
+export type SaveObservationsResult = {
+    status: "saved";
+    response: Bundle;
+};
+export type LatestObservationsParams = GetLatestObservationsByCodeParams;
+export type LastObservationsQuery = {
+    code: string;
+    max?: number;
+};
+export type MeasurementCodeTypes = Parameters<typeof observationCodesForTypes>[0];
+export declare class MeasurementsResource {
+    private readonly http;
+    private readonly fhir;
+    private readonly account;
+    constructor(http: HttpClient, fhir: FhirResource, session: SessionSource | null);
+    save(params: BuildObservationsParams, options?: SaveObservationsOptions): Promise<SaveObservationsResult>;
+    /** One reading, main observation first, created conditionally so a retry cannot duplicate it. */
+    saveObservations(observations: Observation[], options?: SaveObservationsOptions): Promise<SaveObservationsResult>;
+    build(params: BuildObservationsParams): Promise<Observation[]>;
+    latest(params: LatestObservationsParams, options?: RequestOptions): Promise<Bundle<Observation>>;
+    lastForPatient(patientId: string, query: LastObservationsQuery, options?: RequestOptions): Promise<Bundle<Observation>>;
+    /** The comma-joined codes the types are saved under, as `latest` and FHIR `code` searches take them. */
+    codesFor(types: MeasurementCodeTypes): string;
+    private latestPatientId;
+    /** A reading split over several requests stops once another account signs in, so none of it lands elsewhere. */
+    private send;
+    private requireOwner;
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeasurementsResource = void 0;
+const observationsToMeasurements_1 = require("../../../client/observation/methods/observationsToMeasurements");
+const observation_bundle_utils_1 = require("../../../client/observation/observation-bundle-utils");
+const offline_measurement_queue_1 = require("../../../client/offline/offline-measurement-queue");
+const query_string_1 = require("../../../client/query-string");
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const url_1 = require("../../http/url");
+const observation_builder_1 = require("./observation-builder");
+const save_error_1 = require("./save-error");
+const signed_in_account_1 = require("./signed-in-account");
+const LATEST_OBSERVATIONS_PATH = "fhir/Observation/$lastn";
+const LATEST_PER_CODE = 1;
+class MeasurementsResource {
+    constructor(http, fhir, session) {
+        this.http = http;
+        this.fhir = fhir;
+        this.account = new signed_in_account_1.SignedInAccount(session);
+    }
+    async save(params, options) {
+        return this.saveObservations(await this.build(params), options);
+    }
+    /** One reading, main observation first, created conditionally so a retry cannot duplicate it. */
+    async saveObservations(observations, options = {}) {
+        const { identifierSystems, replace, ...requestOptions } = options;
+        const entry = (0, observation_bundle_utils_1.linkObservationMembers)(observations).map((observation) => (0, offline_measurement_queue_1.entryForObservation)(observation, { identifierSystems, replace }));
+        const response = await this.send({ resourceType: "Bundle", type: "transaction", entry }, requestOptions);
+        return { status: "saved", response };
+    }
+    async build(params) {
+        const subject = params.patientId ? `Patient/${params.patientId}` : await this.account.profileReference();
+        return (0, observation_builder_1.buildObservations)(params, subject);
+    }
+    async latest(params, options) {
+        const query = (0, query_string_1.toQueryString)({
+            max: LATEST_PER_CODE,
+            code: params.codes,
+            patient: `Patient/${await this.latestPatientId(params)}`,
+            date: params.date ? `ge${params.date}` : undefined,
+        });
+        return this.http.get(`${LATEST_OBSERVATIONS_PATH}${query}`, options);
+    }
+    lastForPatient(patientId, query, options) {
+        return this.http.get(`patient/${(0, url_1.pathSegment)(patientId)}/observation${(0, query_string_1.toQueryString)(query)}`, options);
+    }
+    /** The comma-joined codes the types are saved under, as `latest` and FHIR `code` searches take them. */
+    codesFor(types) {
+        return (0, observationsToMeasurements_1.observationCodesForTypes)(types);
+    }
+    async latestPatientId(params) {
+        if (params.me) {
+            return idOf(await this.account.profileReference());
+        }
+        return params.patientId;
+    }
+    /** A reading split over several requests stops once another account signs in, so none of it lands elsewhere. */
+    async send(bundle, options) {
+        const owner = await this.account.key();
+        try {
+            return await (0, observation_bundle_utils_1.executeObservationBundle)(bundle, async (request) => {
+                await this.requireOwner(owner);
+                return this.fhir.batch(request, options);
+            });
+        }
+        catch (error) {
+            throw (0, save_error_1.isBundle)(error) ? (0, save_error_1.saveErrorFrom)(error) : error;
+        }
+    }
+    async requireOwner(owner) {
+        if (owner !== (await this.account.key())) {
+            throw new ovok_errors_1.OvokConflictError((0, ovok_errors_1.detailsFor)("The signed-in account changed during the save; the rest was not sent."));
+        }
+    }
+}
+exports.MeasurementsResource = MeasurementsResource;
+const idOf = (reference) => reference.slice(reference.indexOf("/") + 1);

package/dist/next/resources/measurements/observation-builder.d.ts

@@ -0,0 +1,5 @@
+import type { GenerateObservationBodyParams } from "../../../client/observation/types/generate-observation-body/GenerateObservationBodyParams";
+import type { Observation } from "@medplum/fhirtypes";
+export type BuildObservationsParams = GenerateObservationBodyParams;
+/** One measurement's Observations about `subject`, a reference such as `Patient/1`. */
+export declare function buildObservations(params: BuildObservationsParams, subject: string): Observation[];

package/dist/next/resources/measurements/observation-builder.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildObservations = buildObservations;
+const fhir_systems_1 = require("../../../client/observation/fhir-systems");
+const creator_1 = require("../../../client/observation/services/creator");
+const getDeviceObject_1 = require("../../../client/observation/utils/getDeviceObject");
+/** One measurement's Observations about `subject`, a reference such as `Patient/1`. */
+function buildObservations(params, subject) {
+    const service = creator_1.ObservationServiceCreator.getInstance().getService(params.measurement.measurementTypeKey);
+    const device = (0, getDeviceObject_1.getDeviceObject)(params.device);
+    const observations = fragmentsOf(service, params.measurement)
+        .map((fragment) => observationOf(fragment, subject, device))
+        .filter(hasValue)
+        .map((observation) => datedAt(observation, params.effectiveDateTime));
+    return params.sourceId ? namedAfterSource(observations, subject, params.sourceId) : observations;
+}
+/** Services without fragments describe their observations as parallel code, value and property lists. */
+const fragmentsOf = (service, measurement) => { var _a, _b; return (_b = (_a = service.generateObservationFragments) === null || _a === void 0 ? void 0 : _a.call(service, measurement)) !== null && _b !== void 0 ? _b : codeValueFragments(service, measurement); };
+const codeValueFragments = (service, measurement) => {
+    const values = service.generateValues(measurement);
+    const additionalProperties = service.getAdditionalProperties(measurement);
+    return service.getObservationCodes().map((code, index) => ({
+        code,
+        value: values[index],
+        additionalProperties: additionalProperties[index],
+    }));
+};
+const observationOf = (fragment, subject, device) => ({
+    resourceType: "Observation",
+    status: "registered",
+    subject: { reference: subject },
+    device,
+    ...fragment.value,
+    code: fragment.code,
+    ...fragment.additionalProperties,
+});
+const hasValue = (observation) => {
+    var _a, _b, _c, _d, _e, _f;
+    return ((_a = observation.valueQuantity) === null || _a === void 0 ? void 0 : _a.value) !== undefined ||
+        Boolean((_b = observation.valueSampledData) === null || _b === void 0 ? void 0 : _b.data) ||
+        Boolean((_e = (_d = (_c = observation.valueCodeableConcept) === null || _c === void 0 ? void 0 : _c.coding) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.code) ||
+        Boolean((_f = observation.component) === null || _f === void 0 ? void 0 : _f.length);
+};
+/** A period the service set wins over the measurement's time. */
+const datedAt = (observation, effectiveDateTime) => effectiveDateTime && !observation.effectivePeriod
+    ? { ...observation, effectiveDateTime: effectiveDateTime.toISOString() }
+    : observation;
+const namedAfterSource = (observations, subject, sourceId) => observations.map((observation, index) => {
+    var _a;
+    return ({
+        ...observation,
+        identifier: [
+            ...((_a = observation.identifier) !== null && _a !== void 0 ? _a : []),
+            { system: fhir_systems_1.DEVICE_READING_IDENTIFIER_SYSTEM, value: `${subject}/${sourceId}/${index}` },
+        ],
+    });
+});

package/dist/next/resources/measurements/save-error.d.ts

@@ -0,0 +1,5 @@
+import type { Bundle } from "@medplum/fhirtypes";
+import { OvokError } from "../../errors/ovok-errors";
+export declare const isBundle: (value: unknown) => value is Bundle;
+/** A save's response that refused or left out an observation; a refused one gives its own status. */
+export declare function saveErrorFrom(response: Bundle): OvokError;

package/dist/next/resources/measurements/save-error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBundle = void 0;
+exports.saveErrorFrom = saveErrorFrom;
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const FAILED_STATUS = /^[45]/;
+const isBundle = (value) => typeof value === "object" && value !== null && value.resourceType === "Bundle";
+exports.isBundle = isBundle;
+/** A save's response that refused or left out an observation; a refused one gives its own status. */
+function saveErrorFrom(response) {
+    var _a;
+    const statuses = ((_a = response.entry) !== null && _a !== void 0 ? _a : []).map((entry) => { var _a, _b; return (_b = (_a = entry.response) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : ""; });
+    const refused = statuses.find((status) => FAILED_STATUS.test(status));
+    const message = refused
+        ? `The server refused an observation of the reading: ${refused}.`
+        : "The server's response left out an observation of the reading.";
+    return (0, ovok_errors_1.errorForStatus)({ ...(0, ovok_errors_1.detailsFor)(message), status: refused ? Number.parseInt(refused, 10) : null });
+}

package/dist/next/resources/measurements/signed-in-account.d.ts

@@ -0,0 +1,11 @@
+import { UserSession } from "../../auth/user-session";
+export type SessionSource = Pick<UserSession, "current">;
+/** The account a measurement belongs to; a machine client has none. */
+export declare class SignedInAccount {
+    private readonly session;
+    constructor(session: SessionSource | null);
+    /** The project and profile signed in now, or null when no one is. */
+    key(): Promise<string | null>;
+    profileReference(): Promise<string>;
+    private current;
+}