@ovok/core 0.4.30 → 0.4.32

package/dist/client/ovok-client.js

@@ -47,6 +47,7 @@ const cmsMethods = __importStar(require("./cms/methods"));
 const consentMethods = __importStar(require("./consent/methods"));
 const emailMethods = __importStar(require("./email"));
 const ovok_error_1 = require("./errors/ovok-error");
+const ovok_error_utils_1 = require("./errors/ovok-error-utils");
 const rate_limit_error_1 = require("./errors/rate-limit-error");
 const experienceMethods = __importStar(require("./experience/methods"));
 const inviteMethods = __importStar(require("./invites/methods"));
@@ -64,6 +65,127 @@ const slimMethods = __importStar(require("./slim/methods"));
 exports.MAX_CONDITIONAL_OBSERVATION_ENTRIES = 8;
 var observation_bundle_utils_2 = require("./observation/observation-bundle-utils");
 Object.defineProperty(exports, "MAX_OBSERVATION_BUNDLE_BYTES", { enumerable: true, get: function () { return observation_bundle_utils_2.MAX_OBSERVATION_BUNDLE_BYTES; } });
+const retryAfterMs = (response) => {
+    var _a, _b;
+    const value = (_b = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get) === null || _b === void 0 ? void 0 : _b.call(_a, "Retry-After");
+    if (!value) {
+        return undefined;
+    }
+    const seconds = Number(value);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds * 1000);
+    }
+    const date = Date.parse(value);
+    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : undefined;
+};
+const timeoutError = () => {
+    const error = new Error("The request timed out.");
+    error.name = "TimeoutError";
+    return error;
+};
+const withHttpErrorMetadata = async (response) => {
+    var _a, _b;
+    if (response.ok || typeof response.clone !== "function") {
+        return response;
+    }
+    let bodyText = "";
+    let body;
+    try {
+        bodyText = await response.clone().text();
+        body = JSON.parse(bodyText);
+    }
+    catch (_c) {
+        body = undefined;
+    }
+    const outcome = body && typeof body === "object" && body.resourceType === "OperationOutcome"
+        ? body
+        : undefined;
+    const envelope = body && typeof body === "object" ? body : undefined;
+    const nestedError = (envelope === null || envelope === void 0 ? void 0 : envelope.error) && typeof envelope.error === "object"
+        ? envelope.error
+        : undefined;
+    const safeResponse = envelope
+        ? Object.fromEntries(Object.entries(envelope).filter(([key]) => ["code", "error", "message", "requestId", "retryAfterSec", "status", "statusCode", "errors", "missing"].includes(key)))
+        : { message: typeof body === "string" ? body : response.statusText };
+    const status = response.status;
+    const retryAfter = (_a = retryAfterMs(response)) !== null && _a !== void 0 ? _a : (typeof (envelope === null || envelope === void 0 ? void 0 : envelope.retryAfterSec) === "number" ? envelope.retryAfterSec * 1000 : undefined);
+    const requestId = (_b = response.headers.get("x-request-id")) !== null && _b !== void 0 ? _b : (typeof (envelope === null || envelope === void 0 ? void 0 : envelope.requestId) === "string" ? envelope.requestId : undefined);
+    const message = typeof (envelope === null || envelope === void 0 ? void 0 : envelope.message) === "string"
+        ? envelope.message
+        : typeof (nestedError === null || nestedError === void 0 ? void 0 : nestedError.message) === "string"
+            ? nestedError.message
+            : response.statusText || `HTTP ${status}`;
+    const extensions = [];
+    const addMetadata = (url, value, kind) => {
+        if (value !== undefined) {
+            extensions.push({ url, [`value${kind}`]: value });
+        }
+    };
+    addMetadata("status", status, "Integer");
+    addMetadata("requestId", requestId, "String");
+    addMetadata("retryAfterMs", retryAfter, "Integer");
+    if (!outcome) {
+        extensions.push({ url: "response", valueString: JSON.stringify(safeResponse) });
+    }
+    const enrichedOutcome = outcome !== null && outcome !== void 0 ? outcome : {
+        resourceType: "OperationOutcome",
+        id: "ovok-http-error",
+        issue: [{
+                severity: "error",
+                code: status === 429 ? "throttled" : "exception",
+                details: { text: bodyText || message },
+            }],
+    };
+    const existingExtensions = Array.isArray(enrichedOutcome.extension)
+        ? enrichedOutcome.extension
+        : [];
+    enrichedOutcome.extension = [
+        ...existingExtensions,
+        { url: ovok_error_utils_1.OVOK_HTTP_ERROR_EXTENSION_URL, extension: extensions },
+    ];
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    headers.set("content-type", "application/fhir+json");
+    return new Response(JSON.stringify(enrichedOutcome), {
+        status,
+        statusText: response.statusText,
+        headers,
+    });
+};
+const waitForRetry = (milliseconds, signal) => new Promise((resolve, reject) => {
+    var _a;
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+        const error = new Error("Token refresh aborted");
+        error.name = "AbortError";
+        reject((_a = signal.reason) !== null && _a !== void 0 ? _a : error);
+        return;
+    }
+    const timer = setTimeout(() => {
+        signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", abort);
+        resolve();
+    }, milliseconds);
+    const abort = () => {
+        var _a;
+        clearTimeout(timer);
+        const error = new Error("Token refresh aborted");
+        error.name = "AbortError";
+        reject((_a = signal === null || signal === void 0 ? void 0 : signal.reason) !== null && _a !== void 0 ? _a : error);
+    };
+    signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", abort, { once: true });
+});
+const isTemporaryRefreshFailure = (status) => status === 429 || (status >= 500 && status <= 599);
+const refreshUnavailableError = (response) => {
+    const error = new Error("Token refresh is temporarily unavailable");
+    error.name = "NetworkError";
+    Object.assign(error, { cause: response });
+    return error;
+};
+const refreshResponseError = (response) => {
+    const error = new Error(`Token refresh returned HTTP ${response.status}`);
+    error.name = "TokenRefreshError";
+    Object.assign(error, { status: response.status, cause: response });
+    return error;
+};
 const isNetworkError = (error) => {
     if (!(error instanceof Error)) {
         return false;
@@ -75,6 +197,7 @@ const isNetworkError = (error) => {
     }
     return isNetworkError(error.cause);
 };
+const isRetrySafePost = (pathname) => pathname === "/ai/fhir/search";
 class OvokClient extends core_1.MedplumClient {
     /**
      * @param config - The configuration for the client.
@@ -82,30 +205,217 @@ class OvokClient extends core_1.MedplumClient {
      */
     constructor(config) {
         var _a, _b, _c, _d, _e, _f;
-        const storage = (_a = config.storage) !== null && _a !== void 0 ? _a : new core_1.ClientStorage(undefined, config.storagePrefix);
+        if (config.requestTimeoutMs !== undefined && (!Number.isFinite(config.requestTimeoutMs) || config.requestTimeoutMs <= 0)) {
+            throw new RangeError("requestTimeoutMs must be a positive finite number.");
+        }
+        const storage = (_a = config.storage) !== null && _a !== void 0 ? _a : new core_1.ClientStorage(new core_1.MemoryStorage(), config.storagePrefix);
         const fetchImplementation = (_b = config.fetch) !== null && _b !== void 0 ? _b : globalThis.fetch.bind(globalThis);
         const baseUrl = (_c = config.baseUrl) !== null && _c !== void 0 ? _c : "https://api.medplum.com/";
         const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
         const tokenUrl = new URL((_d = config.tokenUrl) !== null && _d !== void 0 ? _d : "oauth2/token", normalizedBaseUrl).href;
-        super({
-            ...config,
-            storage,
-            fetch: async (url, options) => {
-                var _a, _b;
-                const response = await fetchImplementation(url, options);
-                const requestUrl = new URL(url, normalizedBaseUrl);
-                const refreshRefused = requestUrl.href === tokenUrl && [400, 401, 403].includes(response.status);
-                const sessionEnded = requestUrl.pathname.endsWith("/auth/session/current") && response.status === 401;
-                if (refreshRefused || sessionEnded) {
+        let unauthenticatedReason;
+        let clearActiveLogin = () => undefined;
+        let terminalRefreshToken;
+        let terminalRefreshError;
+        const isTokenRefresh = (url, options) => new URL(url, normalizedBaseUrl).href === tokenUrl &&
+            (options === null || options === void 0 ? void 0 : options.method) === "POST" &&
+            typeof options.body === "string" &&
+            new URLSearchParams(options.body).get("grant_type") === "refresh_token";
+        const markActiveAccountExpired = () => {
+            var _a, _b;
+            const accountId = (_b = (_a = storage.getObject("activeLogin")) === null || _a === void 0 ? void 0 : _a.profile) === null || _b === void 0 ? void 0 : _b.reference;
+            if (accountId) {
+                (0, account_storage_1.setStoredAccountExpired)(storage, accountId, true);
+            }
+        };
+        const fetchOnce = async (url, options) => {
+            var _a, _b;
+            const requestTimeoutMs = config.requestTimeoutMs;
+            let response;
+            if (requestTimeoutMs === undefined) {
+                response = await fetchImplementation(url, options);
+            }
+            else {
+                const controller = new AbortController();
+                const callerSignal = options === null || options === void 0 ? void 0 : options.signal;
+                let timedOut = false;
+                const abortFromCaller = () => controller.abort(callerSignal === null || callerSignal === void 0 ? void 0 : callerSignal.reason);
+                const timeout = setTimeout(() => {
+                    timedOut = true;
+                    controller.abort(timeoutError());
+                }, requestTimeoutMs);
+                if (callerSignal === null || callerSignal === void 0 ? void 0 : callerSignal.aborted) {
+                    abortFromCaller();
+                }
+                else {
+                    callerSignal === null || callerSignal === void 0 ? void 0 : callerSignal.addEventListener("abort", abortFromCaller, { once: true });
+                }
+                try {
+                    response = await fetchImplementation(url, { ...options, signal: controller.signal });
+                }
+                catch (error) {
+                    if (timedOut) {
+                        throw timeoutError();
+                    }
+                    throw error;
+                }
+                finally {
+                    clearTimeout(timeout);
+                    callerSignal === null || callerSignal === void 0 ? void 0 : callerSignal.removeEventListener("abort", abortFromCaller);
+                }
+            }
+            const requestUrl = new URL(url, normalizedBaseUrl);
+            if (isTokenRefresh(url, options)) {
+                if (response.status === 400) {
+                    let invalidGrant = false;
+                    try {
+                        invalidGrant = (await response.clone().json()).error === "invalid_grant";
+                    }
+                    catch (_c) {
+                        // Do not sign out unless the response confirms that the refresh token was revoked.
+                    }
+                    if (!invalidGrant) {
+                        throw refreshResponseError(response);
+                    }
+                }
+                if ([400, 401, 403].includes(response.status)) {
+                    unauthenticatedReason = {
+                        type: "refresh-rejected",
+                        status: response.status,
+                    };
+                    markActiveAccountExpired();
+                }
+                else if (response.ok) {
                     const accountId = (_b = (_a = storage.getObject("activeLogin")) === null || _a === void 0 ? void 0 : _a.profile) === null || _b === void 0 ? void 0 : _b.reference;
                     if (accountId) {
-                        (0, account_storage_1.setStoredAccountExpired)(storage, accountId, true);
+                        (0, account_storage_1.setStoredAccountExpired)(storage, accountId, false);
                     }
+                    unauthenticatedReason = undefined;
+                }
+            }
+            else if (requestUrl.href === tokenUrl && !response.ok) {
+                unauthenticatedReason = {
+                    type: "authentication-rejected",
+                    status: response.status,
+                };
+            }
+            else if (response.status === 401) {
+                unauthenticatedReason = { type: "request-unauthorized", status: 401 };
+            }
+            return isTokenRefresh(url, options)
+                ? response
+                : withHttpErrorMetadata(response);
+        };
+        const fetchWithRefreshRetry = async (url, options) => {
+            var _a, _b, _c, _d;
+            const requestUrl = new URL(url, normalizedBaseUrl);
+            if (!isTokenRefresh(url, options)) {
+                const response = await fetchOnce(url, options);
+                const sessionEnded = requestUrl.pathname.endsWith("/auth/session/current") && response.status === 401;
+                if (sessionEnded) {
+                    markActiveAccountExpired();
+                }
+                return response;
+            }
+            const login = storage.getObject("activeLogin");
+            if (terminalRefreshError) {
+                if ((login === null || login === void 0 ? void 0 : login.accessToken) && login.accessToken !== terminalRefreshToken) {
+                    terminalRefreshToken = undefined;
+                    terminalRefreshError = undefined;
+                }
+                else {
+                    throw terminalRefreshError;
+                }
+            }
+            const expiresAt = (login === null || login === void 0 ? void 0 : login.accessToken) ? (0, core_1.tryGetJwtExpiration)(login.accessToken) : undefined;
+            const signal = options === null || options === void 0 ? void 0 : options.signal;
+            if (expiresAt !== undefined && options) {
+                const tokenRequestOptions = options;
+                tokenRequestOptions.maxRetries = 0;
+                tokenRequestOptions.maxRetryTime = 0;
+            }
+            if (expiresAt === undefined) {
+                const response = await fetchOnce(url, options);
+                if (isTemporaryRefreshFailure(response.status)) {
+                    void ((_a = response.body) === null || _a === void 0 ? void 0 : _a.cancel().catch(() => undefined));
+                    throw refreshUnavailableError(response);
                 }
                 return response;
+            }
+            let attempt = 0;
+            let firstAttempt = true;
+            let lastResponse;
+            let lastNetworkError;
+            while (firstAttempt || Date.now() < expiresAt) {
+                firstAttempt = false;
+                try {
+                    lastResponse = await fetchOnce(url, options);
+                }
+                catch (error) {
+                    if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || !isNetworkError(error)) {
+                        throw error;
+                    }
+                    if (Date.now() >= expiresAt) {
+                        lastNetworkError = error;
+                        break;
+                    }
+                    lastNetworkError = error;
+                    const remainingMs = expiresAt - Date.now();
+                    const backoffMs = Math.min(500 * (2 ** Math.min(attempt, 6)), 30000);
+                    await waitForRetry(Math.min(backoffMs, remainingMs), signal);
+                    attempt += 1;
+                    continue;
+                }
+                if (!isTemporaryRefreshFailure(lastResponse.status)) {
+                    return lastResponse;
+                }
+                const remainingMs = expiresAt - Date.now();
+                if (remainingMs <= 0) {
+                    break;
+                }
+                const backoffMs = Math.min(500 * (2 ** Math.min(attempt, 6)), 30000);
+                const waitMs = Math.min(Math.max((_b = retryAfterMs(lastResponse)) !== null && _b !== void 0 ? _b : 0, backoffMs), remainingMs);
+                if (waitMs >= remainingMs) {
+                    await waitForRetry(remainingMs, signal);
+                    break;
+                }
+                void ((_c = lastResponse.body) === null || _c === void 0 ? void 0 : _c.cancel().catch(() => undefined));
+                await waitForRetry(waitMs, signal);
+                attempt += 1;
+            }
+            const status = lastResponse === null || lastResponse === void 0 ? void 0 : lastResponse.status;
+            const reason = {
+                type: "refresh-unavailable",
+                ...(status === undefined ? {} : { status }),
+            };
+            unauthenticatedReason = reason;
+            markActiveAccountExpired();
+            if (lastResponse) {
+                return lastResponse;
+            }
+            terminalRefreshToken = login === null || login === void 0 ? void 0 : login.accessToken;
+            terminalRefreshError = lastNetworkError !== null && lastNetworkError !== void 0 ? lastNetworkError : refreshUnavailableError(undefined);
+            clearActiveLogin();
+            (_d = config.onUnauthenticated) === null || _d === void 0 ? void 0 : _d.call(config, reason);
+            unauthenticatedReason = undefined;
+            throw terminalRefreshError;
+        };
+        super({
+            ...config,
+            storage,
+            onUnauthenticated: () => {
+                var _a;
+                const reason = unauthenticatedReason !== null && unauthenticatedReason !== void 0 ? unauthenticatedReason : {
+                    type: "request-unauthorized",
+                    status: 401,
+                };
+                unauthenticatedReason = undefined;
+                (_a = config.onUnauthenticated) === null || _a === void 0 ? void 0 : _a.call(config, reason);
             },
+            fetch: fetchWithRefreshRetry,
         });
         this.socialLoginClientId = "";
+        clearActiveLogin = this.clearActiveLogin.bind(this);
         this.hasExplicitStorageAdapter = config.storage !== undefined;
         this.socialLoginClientId = (_e = config.socialLoginClientId) !== null && _e !== void 0 ? _e : "";
         this.addEventListener("profileRefreshed", () => this.syncSavedAccountProfile());
@@ -135,6 +445,13 @@ class OvokClient extends core_1.MedplumClient {
         this.clientStorage = storage;
         this.offlineQueueOptions = (_f = config.offlineQueue) !== null && _f !== void 0 ? _f : {};
     }
+    post(url, body, contentType, options) {
+        const pathname = new URL(url.toString(), this.getBaseUrl()).pathname;
+        if (!isRetrySafePost(pathname)) {
+            options = { ...options, maxRetries: 0, maxRetryTime: 0 };
+        }
+        return super.post(url, body, contentType, options);
+    }
     /** Lists saved accounts without exposing their access or refresh tokens. */
     getSavedAccounts() {
         var _a, _b;
@@ -186,7 +503,7 @@ class OvokClient extends core_1.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.
      */
-    async removeAccount(accountId) {
+    async removeAccount(accountId, requestOptions) {
         var _a;
         const login = this.getLogin(accountId);
         if (!login) {
@@ -196,7 +513,7 @@ class OvokClient extends core_1.MedplumClient {
         const previousAccountId = (_a = previousLogin === null || previousLogin === void 0 ? void 0 : previousLogin.profile) === null || _a === void 0 ? void 0 : _a.reference;
         try {
             await this.setActiveLogin(login);
-            await this.delete("auth/session/current");
+            await this.delete("auth/session/current", ...(requestOptions === undefined ? [] : [requestOptions]));
         }
         catch (error) {
             if (this.getExpiredAccountIds().includes(accountId)) {
@@ -251,34 +568,34 @@ class OvokClient extends core_1.MedplumClient {
         }
     }
     /** Saves a measurement immediately, or durably queues it when the opt-in queue is enabled. */
-    async saveMeasurement(params) {
+    async saveMeasurement(params, requestOptions) {
         const observations = await this.generateObservationBodiesByMeasurement(params);
-        return this.saveObservations(observations);
+        return this.saveObservations(observations, ...(requestOptions === undefined ? [] : [requestOptions]));
     }
     /** Reads Ovok's composed FHIR and public-route capability statement. */
-    async getCapabilityStatement(version = "R4") {
-        return this.get(`/fhir/${version}/metadata`);
+    async getCapabilityStatement(version = "R4", requestOptions) {
+        return this.get(`/fhir/${version}/metadata`, ...(requestOptions === undefined ? [] : [requestOptions]));
     }
     /** Returns the non-FHIR public routes published by the backend statement. */
-    async getPublicApiEndpoints(version = "R4") {
-        return (0, capability_1.getOvokPublicApiEndpoints)(await this.getCapabilityStatement(version));
+    async getPublicApiEndpoints(version = "R4", requestOptions) {
+        return (0, capability_1.getOvokPublicApiEndpoints)(await this.getCapabilityStatement(version, ...(requestOptions === undefined ? [] : [requestOptions])));
     }
     /** Saves observations with conditional creates so a retry cannot create a duplicate. */
-    async saveObservations(observations) {
+    async saveObservations(observations, requestOptions) {
         const linkedObservations = (0, observation_bundle_utils_1.linkObservationMembers)(observations);
         const queue = this.getOfflineMeasurementQueue();
         if (queue) {
-            const { id, flush } = await queue.enqueueAndFlush(linkedObservations);
+            const { id, flush } = await queue.enqueueAndFlush(linkedObservations, ...(requestOptions === undefined ? [] : [requestOptions]));
             const response = flush.responses[id];
             return response
                 ? { status: "saved", response }
                 : { status: "queued", queueId: id };
         }
-        const response = await this.executeConditionalObservationCreates(linkedObservations);
+        const response = await this.executeConditionalObservationCreates(linkedObservations, requestOptions);
         return { status: "saved", response };
     }
     /** Flushes measurements queued while offline. Call this on connectivity/app-resume events. */
-    async flushOfflineMeasurementQueue(options = {}) {
+    async flushOfflineMeasurementQueue(options = {}, requestOptions) {
         const queue = this.getOfflineMeasurementQueue();
         if (!queue) {
             return {
@@ -289,7 +606,7 @@ class OvokClient extends core_1.MedplumClient {
                 responses: {},
             };
         }
-        return queue.flush(options);
+        return queue.flush(options, ...(requestOptions === undefined ? [] : [requestOptions]));
     }
     getOfflineMeasurementQueue() {
         var _a;
@@ -299,7 +616,7 @@ class OvokClient extends core_1.MedplumClient {
         if (!this.clientStorage || !this.hasExplicitStorageAdapter) {
             throw new Error("Offline measurement queue requires a durable client storage adapter.");
         }
-        (_a = this.offlineMeasurementQueue) !== null && _a !== void 0 ? _a : (this.offlineMeasurementQueue = new offline_1.OfflineMeasurementQueue(this.clientStorage, (bundle) => this.executeObservationBundle(bundle), {
+        (_a = this.offlineMeasurementQueue) !== null && _a !== void 0 ? _a : (this.offlineMeasurementQueue = new offline_1.OfflineMeasurementQueue(this.clientStorage, (bundle, requestOptions) => this.executeObservationBundle(bundle, ...(requestOptions === undefined ? [] : [requestOptions])), {
             ...this.offlineQueueOptions,
             getOwnerKey: () => {
                 var _a, _b, _c;
@@ -325,8 +642,13 @@ class OvokClient extends core_1.MedplumClient {
     clear() {
         var _a, _b, _c;
         const storage = this.clientStorage;
-        const logins = this.getLogins();
         const activeAccountId = (_b = (_a = this.getActiveLogin()) === null || _a === void 0 ? void 0 : _a.profile) === null || _b === void 0 ? void 0 : _b.reference;
+        const logins = this.getLogins().map((login) => {
+            var _a;
+            return ((_a = login.profile) === null || _a === void 0 ? void 0 : _a.reference) === activeAccountId
+                ? { ...login, accessToken: "", refreshToken: "" }
+                : login;
+        });
         const expiredAccountIds = new Set(this.getExpiredAccountIds());
         if (activeAccountId) {
             expiredAccountIds.add(activeAccountId);
@@ -384,16 +706,16 @@ class OvokClient extends core_1.MedplumClient {
             // Keep the saved login available for a later retry if restoration is offline.
         }
     }
-    async executeConditionalObservationCreates(observations) {
+    async executeConditionalObservationCreates(observations, requestOptions) {
         const entries = observations.map(offline_1.entryForObservation);
         return this.executeObservationBundle({
             resourceType: "Bundle",
             type: "transaction",
             entry: entries,
-        });
+        }, ...(requestOptions === undefined ? [] : [requestOptions]));
     }
-    async executeObservationBundle(bundle) {
-        const response = await (0, observation_bundle_utils_1.executeObservationBundle)(bundle, (request) => this.executeBatch(request));
+    async executeObservationBundle(bundle, requestOptions) {
+        const response = await (0, observation_bundle_utils_1.executeObservationBundle)(bundle, (request) => this.executeBatch(request, ...(requestOptions === undefined ? [] : [requestOptions])));
         this.invalidateSearches("Observation");
         return response;
     }

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

@@ -1,25 +1,26 @@
+import type { MedplumRequestOptions } from "@medplum/core";
 import { OvokClient } from "../ovok-client";
 import { OvokCurrentPatientProfile, OvokPatientLatestObservationsQuery, OvokPatientObservationBundle, OvokPatientAppointment, OvokPatientCarePlan, OvokPatientDashboard, OvokPatientDashboardQuery, OvokPatientDevice, OvokPatientMeasurement, OvokPatientNotification, OvokPatientQuestionnaire, OvokPatientQuestionnaireResponse, OvokPatientResourceQuery, OvokPatientSchedule, OvokPatientSchedulingQuery, OvokPatientSlot, OvokPatientTelemetryHistory, OvokPatientTelemetryHistoryQuery } from "./types";
-export declare function getCurrentPatientProfile(this: OvokClient): Promise<OvokCurrentPatientProfile>;
-export declare function getPatientLatestObservations(this: OvokClient, params?: OvokPatientLatestObservationsQuery): Promise<OvokPatientObservationBundle>;
-export declare function getPatientDeviceTelemetry(this: OvokClient, deviceId: string): Promise<OvokPatientObservationBundle>;
-export declare function getPatientDeviceTelemetryHistory(this: OvokClient, deviceId: string, params?: OvokPatientTelemetryHistoryQuery): Promise<OvokPatientTelemetryHistory>;
-export declare function listPatientAppointments(this: OvokClient, params?: OvokPatientSchedulingQuery): Promise<OvokPatientAppointment[]>;
-export declare function getPatientAppointment(this: OvokClient, appointmentId: string): Promise<OvokPatientAppointment>;
-export declare function createPatientAppointment(this: OvokClient, appointment: OvokPatientAppointment): Promise<OvokPatientAppointment>;
-export declare function updatePatientAppointment(this: OvokClient, appointment: OvokPatientAppointment): Promise<OvokPatientAppointment>;
-export declare function listPatientSchedules(this: OvokClient, params?: OvokPatientSchedulingQuery): Promise<OvokPatientSchedule[]>;
-export declare function listPatientSlots(this: OvokClient, params?: OvokPatientSchedulingQuery): Promise<OvokPatientSlot[]>;
-export declare function listPatientMeasurementHistory(this: OvokClient, params?: OvokPatientResourceQuery): Promise<OvokPatientMeasurement[]>;
-export declare function getPatientMeasurement(this: OvokClient, measurementId: string): Promise<OvokPatientMeasurement>;
-export declare function listPatientCarePlans(this: OvokClient, params?: OvokPatientResourceQuery): Promise<OvokPatientCarePlan[]>;
-export declare function getPatientCarePlan(this: OvokClient, carePlanId: string): Promise<OvokPatientCarePlan>;
-export declare function listPatientQuestionnaires(this: OvokClient, params?: OvokPatientResourceQuery): Promise<OvokPatientQuestionnaire[]>;
-export declare function getPatientQuestionnaire(this: OvokClient, questionnaireId: string): Promise<OvokPatientQuestionnaire>;
-export declare function listPatientQuestionnaireResponses(this: OvokClient, params?: OvokPatientResourceQuery): Promise<OvokPatientQuestionnaireResponse[]>;
-export declare function getPatientQuestionnaireResponse(this: OvokClient, questionnaireResponseId: string): Promise<OvokPatientQuestionnaireResponse>;
-export declare function listPatientDevices(this: OvokClient, params?: OvokPatientResourceQuery): Promise<OvokPatientDevice[]>;
-export declare function getPatientDevice(this: OvokClient, deviceId: string): Promise<OvokPatientDevice>;
-export declare function listPatientNotifications(this: OvokClient, params?: OvokPatientResourceQuery): Promise<OvokPatientNotification[]>;
-export declare function getPatientNotification(this: OvokClient, notificationId: string): Promise<OvokPatientNotification>;
-export declare function getPatientDashboard(this: OvokClient, params?: OvokPatientDashboardQuery): Promise<OvokPatientDashboard>;
+export declare function getCurrentPatientProfile(this: OvokClient, requestOptions?: MedplumRequestOptions): Promise<OvokCurrentPatientProfile>;
+export declare function getPatientLatestObservations(this: OvokClient, params?: OvokPatientLatestObservationsQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientObservationBundle>;
+export declare function getPatientDeviceTelemetry(this: OvokClient, deviceId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientObservationBundle>;
+export declare function getPatientDeviceTelemetryHistory(this: OvokClient, deviceId: string, params?: OvokPatientTelemetryHistoryQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientTelemetryHistory>;
+export declare function listPatientAppointments(this: OvokClient, params?: OvokPatientSchedulingQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientAppointment[]>;
+export declare function getPatientAppointment(this: OvokClient, appointmentId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientAppointment>;
+export declare function createPatientAppointment(this: OvokClient, appointment: OvokPatientAppointment, requestOptions?: MedplumRequestOptions): Promise<OvokPatientAppointment>;
+export declare function updatePatientAppointment(this: OvokClient, appointment: OvokPatientAppointment, requestOptions?: MedplumRequestOptions): Promise<OvokPatientAppointment>;
+export declare function listPatientSchedules(this: OvokClient, params?: OvokPatientSchedulingQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientSchedule[]>;
+export declare function listPatientSlots(this: OvokClient, params?: OvokPatientSchedulingQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientSlot[]>;
+export declare function listPatientMeasurementHistory(this: OvokClient, params?: OvokPatientResourceQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientMeasurement[]>;
+export declare function getPatientMeasurement(this: OvokClient, measurementId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientMeasurement>;
+export declare function listPatientCarePlans(this: OvokClient, params?: OvokPatientResourceQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientCarePlan[]>;
+export declare function getPatientCarePlan(this: OvokClient, carePlanId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientCarePlan>;
+export declare function listPatientQuestionnaires(this: OvokClient, params?: OvokPatientResourceQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientQuestionnaire[]>;
+export declare function getPatientQuestionnaire(this: OvokClient, questionnaireId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientQuestionnaire>;
+export declare function listPatientQuestionnaireResponses(this: OvokClient, params?: OvokPatientResourceQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientQuestionnaireResponse[]>;
+export declare function getPatientQuestionnaireResponse(this: OvokClient, questionnaireResponseId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientQuestionnaireResponse>;
+export declare function listPatientDevices(this: OvokClient, params?: OvokPatientResourceQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientDevice[]>;
+export declare function getPatientDevice(this: OvokClient, deviceId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientDevice>;
+export declare function listPatientNotifications(this: OvokClient, params?: OvokPatientResourceQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientNotification[]>;
+export declare function getPatientNotification(this: OvokClient, notificationId: string, requestOptions?: MedplumRequestOptions): Promise<OvokPatientNotification>;
+export declare function getPatientDashboard(this: OvokClient, params?: OvokPatientDashboardQuery, requestOptions?: MedplumRequestOptions): Promise<OvokPatientDashboard>;