@ovok/core 0.4.30 → 0.4.32

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,26 @@ 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]));
     }
     if (resourceType === "Patient") {
-        return this.acceptPatientInvite(body);
+        return this.acceptPatientInvite(body, ...(requestOptions === undefined ? [] : [requestOptions]));
     }
     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 = {
@@ -22,7 +23,7 @@ export type OfflineMeasurementFlushResult = {
     exhausted: number;
     responses: Record<string, Bundle>;
 };
-type MeasurementTransport = (bundle: Bundle) => Promise<Bundle>;
+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 +36,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,7 +81,7 @@ class OfflineMeasurementQueue {
         this.storage = storage;
         this.transport = transport;
         this.operation = Promise.resolve();
-        this.enqueueAndFlush = (observations) => this.runExclusive(async () => {
+        this.enqueueAndFlush = (observations, requestOptions) => 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();
@@ -102,12 +102,12 @@ class OfflineMeasurementQueue {
                 });
                 this.writeQueue(queue);
             }
-            return { id, flush: await this.flushQueue(queue) };
+            return { id, flush: await this.flushQueue(queue, {}, ...(requestOptions === undefined ? [] : [requestOptions])) };
         });
-        this.flush = (options = {}) => this.runExclusive(async () => {
+        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 +134,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,
@@ -174,7 +174,7 @@ class OfflineMeasurementQueue {
                         resourceType: "Bundle",
                         type: "transaction",
                         entry: item.entries,
-                    });
+                    }, ...(requestOptions === undefined ? [] : [requestOptions]));
                     if (isFailedResponse(response)) {
                         throw response;
                     }

package/dist/client/ovok-client.d.ts

@@ -1,4 +1,4 @@
-import { IClientStorage, LoginState, MedplumClient, MedplumClientOptions, SubscriptionManager } from "@medplum/core";
+import { IClientStorage, LoginState, MedplumClient, MedplumClientOptions, MedplumRequestOptions, SubscriptionManager } from "@medplum/core";
 import { Bundle, CapabilityStatement, Observation } from "@medplum/fhirtypes";
 import { OvokPublicApiEndpoint } from "../conformance/capability";
 import * as aiFhirMethods from "./ai-fhir/methods";
@@ -32,6 +32,25 @@ export type SaveObservationsResult = {
     queueId: string;
 };
 export type OvokFhirVersion = "R4" | "R5";
+export type OvokUnauthenticatedReason = {
+    type: "refresh-rejected";
+    status: 400 | 401 | 403;
+} | {
+    type: "refresh-unavailable";
+    status?: number;
+} | {
+    type: "authentication-rejected";
+    status: number;
+} | {
+    type: "request-unauthorized";
+    status: 401;
+};
+export type OvokClientOptions = Omit<MedplumClientOptions, "onUnauthenticated"> & {
+    onUnauthenticated?: (reason: OvokUnauthenticatedReason) => void;
+    socialLoginClientId?: string;
+    requestTimeoutMs?: number;
+    offlineQueue?: OfflineMeasurementQueueOptions;
+};
 export declare class OvokClient extends MedplumClient {
     protected socialLoginClientId: string;
     clientStorage: IClientStorage | undefined;
@@ -42,10 +61,8 @@ export declare class OvokClient extends MedplumClient {
      * @param config - The configuration for the client.
      * @param config.socialLoginClientId - The social login client id to use for the client.
      */
-    constructor(config: MedplumClientOptions & {
-        socialLoginClientId?: string;
-        offlineQueue?: OfflineMeasurementQueueOptions;
-    });
+    constructor(config: OvokClientOptions);
+    post<T = unknown>(url: URL | string, body?: unknown, contentType?: string, options?: MedplumRequestOptions): Promise<T>;
     /** Lists saved accounts without exposing their access or refresh tokens. */
     getSavedAccounts(): OvokSavedAccount[];
     /** Activates a previously saved account without asking for its password again. */
@@ -55,21 +72,21 @@ export declare class OvokClient extends MedplumClient {
      * Accounts with an expired server session are removed locally; network and service
      * failures retain the account so it can be removed after connectivity returns.
      */
-    removeAccount(accountId: string): Promise<void>;
+    removeAccount(accountId: string, requestOptions?: MedplumRequestOptions): Promise<void>;
     /** Removes every saved account and expiry marker from client storage. */
     clearAllAccounts(): void;
     /** Reauthentication clears the expired marker for the account that signed in. */
     setActiveLogin(login: LoginState): Promise<void>;
     /** Saves a measurement immediately, or durably queues it when the opt-in queue is enabled. */
-    saveMeasurement(params: GenerateObservationBodyParams): Promise<SaveObservationsResult>;
+    saveMeasurement(params: GenerateObservationBodyParams, requestOptions?: MedplumRequestOptions): Promise<SaveObservationsResult>;
     /** Reads Ovok's composed FHIR and public-route capability statement. */
-    getCapabilityStatement(version?: OvokFhirVersion): Promise<CapabilityStatement>;
+    getCapabilityStatement(version?: OvokFhirVersion, requestOptions?: MedplumRequestOptions): Promise<CapabilityStatement>;
     /** Returns the non-FHIR public routes published by the backend statement. */
-    getPublicApiEndpoints(version?: OvokFhirVersion): Promise<OvokPublicApiEndpoint[]>;
+    getPublicApiEndpoints(version?: OvokFhirVersion, requestOptions?: MedplumRequestOptions): Promise<OvokPublicApiEndpoint[]>;
     /** Saves observations with conditional creates so a retry cannot create a duplicate. */
-    saveObservations(observations: Observation[]): Promise<SaveObservationsResult>;
+    saveObservations(observations: Observation[], requestOptions?: MedplumRequestOptions): Promise<SaveObservationsResult>;
     /** Flushes measurements queued while offline. Call this on connectivity/app-resume events. */
-    flushOfflineMeasurementQueue(options?: OfflineMeasurementFlushOptions): Promise<OfflineMeasurementFlushResult>;
+    flushOfflineMeasurementQueue(options?: OfflineMeasurementFlushOptions, requestOptions?: MedplumRequestOptions): Promise<OfflineMeasurementFlushResult>;
     private getOfflineMeasurementQueue;
     /**
      * Medplum clears its entire client storage after an unrecoverable 401. Keep