@ovok/core 0.4.31 → 0.4.33

package/dist/client/experience/methods.js

@@ -46,14 +46,14 @@ const query = (params) => {
     return encoded === "" ? "" : `?${encoded}`;
 };
 const documentUrl = (client, path, params) => `${client.getBaseUrl().replace(/\/$/, "")}${path}${query(params)}`;
-async function requestConsentSignature(consentId) {
-    return this.post(`/consent/signature/${segment(consentId)}`);
+async function requestConsentSignature(consentId, requestOptions) {
+    return this.post(`/consent/signature/${segment(consentId)}`, undefined, undefined, requestOptions);
 }
-async function createDocumentUpload(body) {
-    return this.post("/document", body);
+async function createDocumentUpload(body, requestOptions) {
+    return this.post("/document", body, undefined, requestOptions);
 }
-async function listDocuments(params = {}) {
-    return this.get(`/document${query(params)}`);
+async function listDocuments(params = {}, requestOptions) {
+    return this.get(`/document${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
 /** Returns the authenticated document endpoint; navigating/fetching it follows the backend redirect. */
 async function getDocumentDownloadUrl(documentId, params = {}) {
@@ -63,87 +63,87 @@ async function getDocumentDownloadUrl(documentId, params = {}) {
 async function getPublicDocumentDownloadUrl(token, params = {}) {
     return documentUrl(this, `/document/public/${segment(token)}`, params);
 }
-async function deleteDocument(documentId) {
-    return (await this.delete(`/document/${segment(documentId)}`));
+async function deleteDocument(documentId, requestOptions) {
+    return (await this.delete(`/document/${segment(documentId)}`, ...(requestOptions === undefined ? [] : [requestOptions])));
 }
-async function updateDocumentMetadata(documentId, body) {
-    return (await this.patch(`/document/${segment(documentId)}`, body));
+async function updateDocumentMetadata(documentId, body, requestOptions) {
+    return (await this.patch(`/document/${segment(documentId)}`, body, ...(requestOptions === undefined ? [] : [requestOptions])));
 }
-async function generateDocumentReplacementUpload(documentId, body) {
-    return this.post(`/document/${segment(documentId)}`, body);
+async function generateDocumentReplacementUpload(documentId, body, requestOptions) {
+    return this.post(`/document/${segment(documentId)}`, body, undefined, requestOptions);
 }
-async function searchMappedContent(type, language, params = {}) {
-    return this.get(`/cms/${segment(type)}/map/${segment(language)}${query(params)}`);
+async function searchMappedContent(type, language, params = {}, requestOptions) {
+    return this.get(`/cms/${segment(type)}/map/${segment(language)}${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
-async function copyContentsFromParent(type, language) {
-    return this.post(`/cms/${segment(type)}/${segment(language)}/copy-from-parent-project`);
+async function copyContentsFromParent(type, language, requestOptions) {
+    return this.post(`/cms/${segment(type)}/${segment(language)}/copy-from-parent-project`, undefined, undefined, requestOptions);
 }
-async function copyContentFromParent(type, language, key) {
-    return this.post(`/cms/${segment(type)}/${segment(language)}/${segment(key)}/copy-from-parent-project`);
+async function copyContentFromParent(type, language, key, requestOptions) {
+    return this.post(`/cms/${segment(type)}/${segment(language)}/${segment(key)}/copy-from-parent-project`, undefined, undefined, requestOptions);
 }
-async function createContent(type, language, body) {
-    return this.post(`/cms/${segment(type)}/${segment(language)}`, body);
+async function createContent(type, language, body, requestOptions) {
+    return this.post(`/cms/${segment(type)}/${segment(language)}`, body, undefined, requestOptions);
 }
-async function updateContent(type, language, key, body) {
-    return (await this.put(`/cms/${segment(type)}/${segment(language)}/${segment(key)}`, body));
+async function updateContent(type, language, key, body, requestOptions) {
+    return (await this.put(`/cms/${segment(type)}/${segment(language)}/${segment(key)}`, body, undefined, requestOptions));
 }
-async function getContent(type, language, key) {
-    return this.get(`/cms/${segment(type)}/${segment(language)}/${segment(key)}`);
+async function getContent(type, language, key, requestOptions) {
+    return this.get(`/cms/${segment(type)}/${segment(language)}/${segment(key)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
-async function deleteContent(type, language, key) {
-    await this.delete(`/cms/${segment(type)}/${segment(language)}/${segment(key)}`);
+async function deleteContent(type, language, key, requestOptions) {
+    await this.delete(`/cms/${segment(type)}/${segment(language)}/${segment(key)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
-async function searchContent(type, language, params = {}) {
-    return this.get(`/cms/${segment(type)}/${segment(language)}${query(params)}`);
+async function searchContent(type, language, params = {}, requestOptions) {
+    return this.get(`/cms/${segment(type)}/${segment(language)}${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
-async function createVideoCallAppointment(body) {
-    return this.post("/video-call/livekit/appointment", body);
+async function createVideoCallAppointment(body, requestOptions) {
+    return this.post("/video-call/livekit/appointment", body, undefined, requestOptions);
 }
-async function updateVideoCallAppointment(appointmentId, body) {
-    return (await this.put(`/video-call/livekit/appointment/${segment(appointmentId)}`, body));
+async function updateVideoCallAppointment(appointmentId, body, requestOptions) {
+    return (await this.put(`/video-call/livekit/appointment/${segment(appointmentId)}`, body, undefined, requestOptions));
 }
-async function listVideoCallAppointments(params = {}) {
-    return this.get(`/video-call/livekit/appointment${query(params)}`);
+async function listVideoCallAppointments(params = {}, requestOptions) {
+    return this.get(`/video-call/livekit/appointment${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
-async function getVideoCallAccessPermission(appointmentId) {
-    return this.get(`/video-call/livekit/access-permission/${segment(appointmentId)}`);
+async function getVideoCallAccessPermission(appointmentId, requestOptions) {
+    return this.get(`/video-call/livekit/access-permission/${segment(appointmentId)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
-async function createVideoCallGuestAccess(appointmentId, body) {
-    return this.post(`/video-call/livekit/guest-access/${segment(appointmentId)}`, body);
+async function createVideoCallGuestAccess(appointmentId, body, requestOptions) {
+    return this.post(`/video-call/livekit/guest-access/${segment(appointmentId)}`, body, undefined, requestOptions);
 }
-async function createVideoCallUserAccess(appointmentId) {
-    return this.post(`/video-call/livekit/user-access/${segment(appointmentId)}`);
+async function createVideoCallUserAccess(appointmentId, requestOptions) {
+    return this.post(`/video-call/livekit/user-access/${segment(appointmentId)}`, undefined, undefined, requestOptions);
 }
-async function sendVideoCallInvite(body) {
-    return this.post("/video-call/livekit/mail/invite", body);
+async function sendVideoCallInvite(body, requestOptions) {
+    return this.post("/video-call/livekit/mail/invite", body, undefined, requestOptions);
 }
-async function sendVideoCallUpdate(body) {
-    return this.post("/video-call/livekit/mail/update", body);
+async function sendVideoCallUpdate(body, requestOptions) {
+    return this.post("/video-call/livekit/mail/update", body, undefined, requestOptions);
 }
-async function sendVideoCallCancellation(body) {
-    return this.post("/video-call/livekit/mail/cancel", body);
+async function sendVideoCallCancellation(body, requestOptions) {
+    return this.post("/video-call/livekit/mail/cancel", body, undefined, requestOptions);
 }
-async function sendVideoCallActiveNotification(appointmentId) {
-    return this.post(`/video-call/livekit/notification/active-call/${segment(appointmentId)}`);
+async function sendVideoCallActiveNotification(appointmentId, requestOptions) {
+    return this.post(`/video-call/livekit/notification/active-call/${segment(appointmentId)}`, undefined, undefined, requestOptions);
 }
-async function translate(body) {
-    return this.post("/ai/translation", body);
+async function translate(body, requestOptions) {
+    return this.post("/ai/translation", body, undefined, requestOptions);
 }
-async function createChatSession(body) {
-    return this.post("/ai/session", body);
+async function createChatSession(body, requestOptions) {
+    return this.post("/ai/session", body, undefined, requestOptions);
 }
-async function sendChatMessage(sessionId, body) {
-    return this.post(`/ai/session/${segment(sessionId)}/message`, body);
+async function sendChatMessage(sessionId, body, requestOptions) {
+    return this.post(`/ai/session/${segment(sessionId)}/message`, body, undefined, requestOptions);
 }
-async function listChatSessions(params = {}) {
-    return this.get(`/ai/session${query(params)}`);
+async function listChatSessions(params = {}, requestOptions) {
+    return this.get(`/ai/session${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
-async function getChatSession(sessionId, params = {}) {
-    return this.get(`/ai/session/${segment(sessionId)}${query(params)}`);
+async function getChatSession(sessionId, params = {}, requestOptions) {
+    return this.get(`/ai/session/${segment(sessionId)}${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
-async function listChatMessages(sessionId, params = {}) {
-    return this.get(`/ai/session/${segment(sessionId)}/message${query(params)}`);
+async function listChatMessages(sessionId, params = {}, requestOptions) {
+    return this.get(`/ai/session/${segment(sessionId)}/message${query(params)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
-async function searchAIFhir(request) {
-    return this.post("/ai/fhir/search", request);
+async function searchAIFhir(request, requestOptions) {
+    return this.post("/ai/fhir/search", request, undefined, requestOptions);
 }

package/dist/client/invites/methods.d.ts

@@ -1,8 +1,9 @@
+import type { MedplumRequestOptions } from "@medplum/core";
 import { OvokClient } from "../ovok-client";
 import { PatientSharingPractitionerShare } from "../patient-sharing/types";
 import { AcceptInviteBody, InviteBody, InviteSent } from "./types";
-export declare function invitePractitioner(this: OvokClient, body: InviteBody): Promise<InviteSent>;
-export declare function invitePatient(this: OvokClient, body: InviteBody): Promise<InviteSent>;
-export declare function acceptPractitionerInvite(this: OvokClient, body: AcceptInviteBody): Promise<PatientSharingPractitionerShare>;
-export declare function acceptPatientInvite(this: OvokClient, body: AcceptInviteBody): Promise<PatientSharingPractitionerShare>;
-export declare function acceptInvite(this: OvokClient, body: AcceptInviteBody): Promise<PatientSharingPractitionerShare>;
+export declare function invitePractitioner(this: OvokClient, body: InviteBody, requestOptions?: MedplumRequestOptions): Promise<InviteSent>;
+export declare function invitePatient(this: OvokClient, body: InviteBody, requestOptions?: MedplumRequestOptions): Promise<InviteSent>;
+export declare function acceptPractitionerInvite(this: OvokClient, body: AcceptInviteBody, requestOptions?: MedplumRequestOptions): Promise<PatientSharingPractitionerShare>;
+export declare function acceptPatientInvite(this: OvokClient, body: AcceptInviteBody, requestOptions?: MedplumRequestOptions): Promise<PatientSharingPractitionerShare>;
+export declare function acceptInvite(this: OvokClient, body: AcceptInviteBody, requestOptions?: MedplumRequestOptions): Promise<PatientSharingPractitionerShare>;

package/dist/client/invites/methods.js

@@ -5,26 +5,32 @@ exports.invitePatient = invitePatient;
 exports.acceptPractitionerInvite = acceptPractitionerInvite;
 exports.acceptPatientInvite = acceptPatientInvite;
 exports.acceptInvite = acceptInvite;
-function invitePractitioner(body) {
-    return this.post("/v1/invites/practitioner", body);
+function invitePractitioner(body, requestOptions) {
+    return this.post("/v1/invites/practitioner", body, undefined, requestOptions);
 }
-function invitePatient(body) {
-    return this.post("/v1/invites/patient", body);
+function invitePatient(body, requestOptions) {
+    return this.post("/v1/invites/patient", body, undefined, requestOptions);
 }
-function acceptPractitionerInvite(body) {
-    return this.post("/v1/invites/practitioner/accept", body);
+function acceptPractitionerInvite(body, requestOptions) {
+    return this.post("/v1/invites/practitioner/accept", body, undefined, requestOptions);
 }
-function acceptPatientInvite(body) {
-    return this.post("/v1/invites/patient/accept", body);
+function acceptPatientInvite(body, requestOptions) {
+    return this.post("/v1/invites/patient/accept", body, undefined, requestOptions);
 }
-function acceptInvite(body) {
+function acceptInvite(body, requestOptions) {
     var _a;
     const resourceType = (_a = this.getProfile()) === null || _a === void 0 ? void 0 : _a.resourceType;
     if (resourceType === "Practitioner") {
-        return this.acceptPractitionerInvite(body);
+        return this.acceptPractitionerInvite(body, ...(requestOptions === undefined ? [] : [requestOptions])).then((result) => {
+            this.invalidateUrl("/v1/patient-sharing/shares");
+            return result;
+        });
     }
     if (resourceType === "Patient") {
-        return this.acceptPatientInvite(body);
+        return this.acceptPatientInvite(body, ...(requestOptions === undefined ? [] : [requestOptions])).then((result) => {
+            this.invalidateUrl("/v1/patient-sharing/shares");
+            return result;
+        });
     }
     throw new Error("Accepting an invite requires a signed-in Patient or Practitioner profile.");
 }

package/dist/client/notifications/methods.d.ts

@@ -1,7 +1,8 @@
+import type { MedplumRequestOptions } from "@medplum/core";
 import { OvokClient } from "../ovok-client";
 import { CreateNotificationNote, NotificationNote, NotificationNotes, NotificationTargetKind, UpdateNotificationNote } from "./types";
-export declare function createNotificationNote(this: OvokClient, body: CreateNotificationNote): Promise<NotificationNote>;
-export declare function listNotificationNotes(this: OvokClient, kind: NotificationTargetKind, id: string): Promise<NotificationNotes>;
-export declare function updateNotificationNote(this: OvokClient, noteId: string, body: UpdateNotificationNote): Promise<NotificationNote>;
-export declare function patchNotificationNote(this: OvokClient, noteId: string, body: UpdateNotificationNote): Promise<NotificationNote>;
-export declare function deleteNotificationNote(this: OvokClient, noteId: string): Promise<void>;
+export declare function createNotificationNote(this: OvokClient, body: CreateNotificationNote, requestOptions?: MedplumRequestOptions): Promise<NotificationNote>;
+export declare function listNotificationNotes(this: OvokClient, kind: NotificationTargetKind, id: string, requestOptions?: MedplumRequestOptions): Promise<NotificationNotes>;
+export declare function updateNotificationNote(this: OvokClient, noteId: string, body: UpdateNotificationNote, requestOptions?: MedplumRequestOptions): Promise<NotificationNote>;
+export declare function patchNotificationNote(this: OvokClient, noteId: string, body: UpdateNotificationNote, requestOptions?: MedplumRequestOptions): Promise<NotificationNote>;
+export declare function deleteNotificationNote(this: OvokClient, noteId: string, requestOptions?: MedplumRequestOptions): Promise<void>;

package/dist/client/notifications/methods.js

@@ -12,18 +12,18 @@ const TARGET_PATH = {
     medical: "medical",
     alert: "raw-alerts",
 };
-function createNotificationNote(body) {
-    return this.post("/v1/slim/notifications/notes", body);
+function createNotificationNote(body, requestOptions) {
+    return this.post("/v1/slim/notifications/notes", body, undefined, requestOptions);
 }
-function listNotificationNotes(kind, id) {
-    return this.get(`/v1/slim/notifications/${TARGET_PATH[kind]}/${segment(id)}/notes`, { cache: "reload" });
+function listNotificationNotes(kind, id, requestOptions) {
+    return this.get(`/v1/slim/notifications/${TARGET_PATH[kind]}/${segment(id)}/notes`, { ...{ cache: "reload" }, ...requestOptions });
 }
-function updateNotificationNote(noteId, body) {
-    return this.put(`/v1/slim/notifications/notes/${segment(noteId)}`, body);
+function updateNotificationNote(noteId, body, requestOptions) {
+    return this.put(`/v1/slim/notifications/notes/${segment(noteId)}`, body, undefined, requestOptions);
 }
-function patchNotificationNote(noteId, body) {
-    return this.patch(`/v1/slim/notifications/notes/${segment(noteId)}`, body);
+function patchNotificationNote(noteId, body, requestOptions) {
+    return this.patch(`/v1/slim/notifications/notes/${segment(noteId)}`, body, ...(requestOptions === undefined ? [] : [requestOptions]));
 }
-async function deleteNotificationNote(noteId) {
-    await this.delete(`/v1/slim/notifications/notes/${segment(noteId)}`);
+async function deleteNotificationNote(noteId, requestOptions) {
+    await this.delete(`/v1/slim/notifications/notes/${segment(noteId)}`, ...(requestOptions === undefined ? [] : [requestOptions]));
 }

package/dist/client/notifications/types.d.ts

@@ -30,14 +30,15 @@ export type UpdateNotificationNote = {
 export type SlimAlarmType = "deviceAlarm" | "attention";
 export type SlimAlarmSeverity = "RED" | "YELLOW" | "ATTENTION";
 export type SlimAlarmStatus = "active" | "completed";
+export type SlimAlarmDetails = {
+    episodeId: string;
+    severity: SlimAlarmSeverity;
+    /** The server forwards the device's alarm type without normalizing it. */
+    type: string;
+    text: string | null;
+};
 export type SlimAlarm = SlimNotification & {
-    alarm: {
-        episodeId: string;
-        severity: SlimAlarmSeverity;
-        type: SlimAlarmType;
-        text: string;
-    };
-    noteCount: number | null;
+    alarm: SlimAlarmDetails | null;
 };
 export type SlimAlarmQuery = {
     type?: SlimAlarmType | readonly SlimAlarmType[];
@@ -56,6 +57,10 @@ export type SlimAlarmsPage = {
     page: number;
     count: number;
     resources: SlimAlarm[];
+    truncated: {
+        reason: "result-cap" | "scan-budget";
+        limit: number;
+    } | null;
 };
 export type SlimRecentAlarms = {
     recent: Array<Omit<SlimAlarm, "noteCount"> & {
@@ -63,7 +68,7 @@ export type SlimRecentAlarms = {
     }>;
     total: number;
     warm: false;
-    source: "medplum";
+    source: "redis" | "fhirStore";
 };
 export type SlimRecentOutOfBed = {
     recent: Array<SlimNotification & {
@@ -83,8 +88,84 @@ export type SlimMedicalNotificationsQuery = {
     cursor?: string;
 };
 export type SlimMedicalNotificationsPage = {
-    items: Array<SlimNotification & {
-        noteCount: number | null;
-    }>;
+    items: SlimMedicalNotificationRow[];
     nextCursor: string | null;
 };
+export type SlimMedicalNotificationsCollection = SlimMedicalNotificationsPage & {
+    total: number;
+    truncated: boolean;
+};
+/** Mirrors the response DTO in Ovok Core's medical-notification contract. */
+export type SlimMedicalNotificationActor = {
+    reference: string;
+    display: string | null;
+};
+export type SlimMedicalNotificationAcknowledgement = {
+    acknowledgedAt: string | null;
+    acknowledgedBy: string | null;
+    acknowledgedActor: SlimMedicalNotificationActor | null;
+};
+export type SlimMedicalNotificationContext = {
+    patientId: string | null;
+    patientName: string | null;
+    locationId: string | null;
+    locationName: string | null;
+    room: string | null;
+    bed: string | null;
+    floor: string | null;
+    deviceId: string | null;
+    deviceMedplumId: string | null;
+    deviceName: string | null;
+    organizationId: string | null;
+    organizationName: string | null;
+};
+export type SlimMedicalEpisodeValue = {
+    observationId: string;
+    valueNumber: number | null;
+    valueString: string | null;
+    valueUnit: string | null;
+    note: string | null;
+    observedAt: string | null;
+    recordedAt: string;
+};
+export type SlimMedicalEpisodeCore = {
+    id: string;
+    patientId: string;
+    code: string;
+    system: string | null;
+    display: string | null;
+    status: string;
+    openedAt: string;
+    closedAt: string | null;
+    closeReason: string | null;
+    lastSampleAt: string | null;
+    durationMs: number | null;
+    observationCount: number | null;
+    firingCount: number | null;
+    minValue: number | null;
+    maxValue: number | null;
+    avgValue: number | null;
+    lastValue: number | null;
+    peakValue: number | null;
+    peakAt: string | null;
+    lastFiringValue: number | null;
+    lastFiringAt: string | null;
+    lastObservationId: string | null;
+    firedBand: {
+        min: number | null;
+        max: number | null;
+        triggerVersion: number | null;
+    } | null;
+};
+export type SlimMedicalNotificationRow = {
+    episode: SlimMedicalEpisodeCore;
+    carehub: SlimMedicalNotificationContext;
+    acknowledgement: SlimMedicalNotificationAcknowledgement | null;
+    noteCount: number | null;
+};
+export type SlimMedicalNotificationDetail = Omit<SlimMedicalNotificationRow, "episode"> & {
+    episode: SlimMedicalEpisodeCore & {
+        values: SlimMedicalEpisodeValue[];
+        truncated: boolean;
+    };
+};

package/dist/client/observation/methods/getLatestObservationsByCodes.d.ts

@@ -1,4 +1,5 @@
 import { Bundle, Observation } from "@medplum/fhirtypes";
+import type { MedplumRequestOptions } from "@medplum/core";
 import { OvokClient } from "../../ovok-client";
 import { GetLatestObservationsByCodeParams } from "../types/GetLatestObservationsByCodeParams";
-export declare function getLatestObservationsByCodes(this: OvokClient, params: GetLatestObservationsByCodeParams): Promise<Bundle<Observation>>;
+export declare function getLatestObservationsByCodes(this: OvokClient, params: GetLatestObservationsByCodeParams, requestOptions?: MedplumRequestOptions): Promise<Bundle<Observation>>;

package/dist/client/observation/methods/getLatestObservationsByCodes.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLatestObservationsByCodes = getLatestObservationsByCodes;
-async function getLatestObservationsByCodes(params) {
+async function getLatestObservationsByCodes(params, requestOptions) {
     var _a;
     let patientId = "patientId" in params ? params.patientId : "";
     if (params.me) {
@@ -15,7 +15,7 @@ async function getLatestObservationsByCodes(params) {
         patient: `Patient/${patientId}`,
         ...(params.date ? { date: `ge${params.date}` } : {}),
     });
-    return this.get(`/fhir/Observation/$lastn?${urlParams.toString()}`, {
-        cache: "no-cache",
-    });
+    return this.get(`/fhir/Observation/$lastn?${urlParams.toString()}`, { ...{
+            cache: "no-cache",
+        }, ...requestOptions });
 }

package/dist/client/offline/offline-measurement-queue.d.ts

@@ -1,5 +1,6 @@
 import { IClientStorage } from "@medplum/core";
 import { Bundle, BundleEntry, Observation } from "@medplum/fhirtypes";
+import type { MedplumRequestOptions } from "@medplum/core";
 export declare const OFFLINE_MEASUREMENT_QUEUE_STORAGE_KEY = "ovok.core.offline-measurements";
 declare const IDENTIFIER_SYSTEM = "https://api.ovok.com/fhir/StructureDefinition/offline-measurement-id";
 export type OfflineMeasurementQueueOptions = {
@@ -21,8 +22,14 @@ export type OfflineMeasurementFlushResult = {
     queued: number;
     exhausted: number;
     responses: Record<string, Bundle>;
+    failures: Record<string, OfflineMeasurementFailure>;
 };
-type MeasurementTransport = (bundle: Bundle) => Promise<Bundle>;
+export type OfflineMeasurementFailure = {
+    name: string;
+    code?: string;
+    status?: number;
+};
+type MeasurementTransport = (bundle: Bundle, requestOptions?: MedplumRequestOptions) => Promise<Bundle>;
 declare const stableMeasurementId: (observation: Observation) => string;
 declare const entryForObservation: (observation: Observation) => BundleEntry<Observation>;
 export declare class OfflineMeasurementQueue {
@@ -35,11 +42,11 @@ export declare class OfflineMeasurementQueue {
     private readonly getOwnerKey?;
     private operation;
     constructor(storage: IClientStorage, transport: MeasurementTransport, options?: OfflineMeasurementQueueOptions);
-    enqueueAndFlush: (observations: Observation[]) => Promise<{
+    enqueueAndFlush: (observations: Observation[], requestOptions?: MedplumRequestOptions) => Promise<{
         id: string;
         flush: OfflineMeasurementFlushResult;
     }>;
-    flush: (options?: OfflineMeasurementFlushOptions) => Promise<OfflineMeasurementFlushResult>;
+    flush: (options?: OfflineMeasurementFlushOptions, requestOptions?: MedplumRequestOptions) => Promise<OfflineMeasurementFlushResult>;
     private runExclusive;
     private readQueue;
     private writeQueue;

package/dist/client/offline/offline-measurement-queue.js

@@ -81,33 +81,36 @@ class OfflineMeasurementQueue {
         this.storage = storage;
         this.transport = transport;
         this.operation = Promise.resolve();
-        this.enqueueAndFlush = (observations) => this.runExclusive(async () => {
-            var _a, _b, _c;
-            await ((_b = (_a = this.storage).getInitPromise) === null || _b === void 0 ? void 0 : _b.call(_a));
-            const queue = this.readQueue();
-            const entries = observations.map(entryForObservation);
-            const ownerKey = (_c = this.getOwnerKey) === null || _c === void 0 ? void 0 : _c.call(this);
-            if (this.getOwnerKey && !ownerKey) {
-                throw new Error("Offline measurements require an active account to prevent cross-account delivery.");
-            }
-            const id = stableValueId({ ownerKey, entries });
-            if (!queue.some((item) => item.id === id)) {
-                queue.push({
-                    id,
-                    ownerKey,
-                    queuedAt: new Date().toISOString(),
-                    attempt: 0,
-                    nextAttemptAt: 0,
-                    entries,
-                });
-                this.writeQueue(queue);
-            }
-            return { id, flush: await this.flushQueue(queue) };
-        });
-        this.flush = (options = {}) => this.runExclusive(async () => {
+        this.enqueueAndFlush = (observations, requestOptions) => {
+            var _a;
+            const ownerKey = (_a = this.getOwnerKey) === null || _a === void 0 ? void 0 : _a.call(this);
+            return this.runExclusive(async () => {
+                var _a, _b;
+                await ((_b = (_a = this.storage).getInitPromise) === null || _b === void 0 ? void 0 : _b.call(_a));
+                const queue = this.readQueue();
+                const entries = observations.map(entryForObservation);
+                if (this.getOwnerKey && !ownerKey) {
+                    throw new Error("Offline measurements require an active account to prevent cross-account delivery.");
+                }
+                const id = stableValueId({ ownerKey, entries });
+                if (!queue.some((item) => item.id === id)) {
+                    queue.push({
+                        id,
+                        ownerKey,
+                        queuedAt: new Date().toISOString(),
+                        attempt: 0,
+                        nextAttemptAt: 0,
+                        entries,
+                    });
+                    this.writeQueue(queue);
+                }
+                return { id, flush: await this.flushQueue(queue, {}, ...(requestOptions === undefined ? [] : [requestOptions])) };
+            });
+        };
+        this.flush = (options = {}, requestOptions) => this.runExclusive(async () => {
             var _a, _b;
             await ((_b = (_a = this.storage).getInitPromise) === null || _b === void 0 ? void 0 : _b.call(_a));
-            return this.flushQueue(this.readQueue(), options);
+            return this.flushQueue(this.readQueue(), options, ...(requestOptions === undefined ? [] : [requestOptions]));
         });
         this.runExclusive = (operation) => {
             const next = this.operation.then(operation, operation);
@@ -134,7 +137,7 @@ class OfflineMeasurementQueue {
                 throw new Error(`Offline measurement queue could not be persisted at storage key "${this.storageKey}".`);
             }
         };
-        this.flushQueue = async (queue, options = {}) => {
+        this.flushQueue = async (queue, options = {}, requestOptions) => {
             var _a;
             const result = {
                 attempted: 0,
@@ -142,11 +145,14 @@ class OfflineMeasurementQueue {
                 queued: 0,
                 exhausted: 0,
                 responses: {},
+                failures: {},
             };
             const now = Date.now();
-            const ownerKey = (_a = this.getOwnerKey) === null || _a === void 0 ? void 0 : _a.call(this);
             let changed = false;
             for (const item of [...queue]) {
+                if (item.lastFailure) {
+                    result.failures[item.id] = item.lastFailure;
+                }
                 if (item.exhausted && options.resetExhausted) {
                     item.attempt = 0;
                     item.exhausted = false;
@@ -163,6 +169,7 @@ class OfflineMeasurementQueue {
                     }
                     continue;
                 }
+                const ownerKey = (_a = this.getOwnerKey) === null || _a === void 0 ? void 0 : _a.call(this);
                 if (this.getOwnerKey && (!ownerKey || item.ownerKey !== ownerKey)) {
                     result.queued++;
                     continue;
@@ -174,7 +181,7 @@ class OfflineMeasurementQueue {
                         resourceType: "Bundle",
                         type: "transaction",
                         entry: item.entries,
-                    });
+                    }, ...(requestOptions === undefined ? [] : [requestOptions]));
                     if (isFailedResponse(response)) {
                         throw response;
                     }
@@ -183,7 +190,7 @@ class OfflineMeasurementQueue {
                     result.responses[item.id] = response;
                     changed = true;
                 }
-                catch (_b) {
+                catch (error) {
                     item.attempt = attempt;
                     item.exhausted = attempt >= this.maxRetries;
                     item.nextAttemptAt = item.exhausted
@@ -191,6 +198,14 @@ class OfflineMeasurementQueue {
                         : Date.now() +
                             Math.min(this.maxRetryBackoffMs, this.retryBackoffMs * 2 ** (attempt - 1));
                     changed = true;
+                    const failure = error;
+                    const lastFailure = {
+                        name: typeof (failure === null || failure === void 0 ? void 0 : failure.name) === "string" ? failure.name : "Error",
+                        ...(typeof (failure === null || failure === void 0 ? void 0 : failure.code) === "string" ? { code: failure.code } : {}),
+                        ...(typeof (failure === null || failure === void 0 ? void 0 : failure.status) === "number" ? { status: failure.status } : {}),
+                    };
+                    item.lastFailure = lastFailure;
+                    result.failures[item.id] = lastFailure;
                     if (item.exhausted) {
                         result.exhausted++;
                     }