@ovok/core 0.4.42 → 0.4.43

package/README.md

@@ -330,6 +330,28 @@ validation errors or 424 when the baseline has not been collected. Hooks never r
 a stale body; transient 503 transport retries do not clear the session.
 The unconfirmed-limit list and repush routes require project-admin access; a 403 remains an error.
 
+Resident deletion returns 409 while the resident has a device; unassign the device with
+`updateSlimPatient()` before deleting. Resident, room, and device writes can also return 422 when
+their device, room, and zone assignments disagree; show the server message and reload before
+retrying. Device serial conflicts return 409 when another customer holds the serial and 422 when
+another device in the project already uses it. Renaming a device moves its serial: old-serial
+readings stop reaching it, and live values return after a reading arrives under the new serial.
+Resident updates replace the editable fields; omitting `locationId` unassigns its devices, and names
+are trimmed by the server.
+
+A resident threshold save can return 409 while another save is running; nothing changed, so wait
+briefly and send it again. A home threshold save can return 502 when Signals did not take every
+resident's limits; nothing was written. A home with no saved limits reads as the default template
+with heart rate 40–110 and respiratory rate 8–25 enabled, and `id: null`.
+
+Notification feeds and episode reads can wait 5 seconds for Signals before returning 503
+`signals_unavailable`; realtime trends can wait 12 seconds. Realtime trends may also be shed
+immediately under load. Wait for `retryAfterMs` before trying again. The paged medical feed returns
+503 during an outage, while recent medical notifications may return the last good page, up to 10
+minutes old, without a marker. Episode `values` contains only readings the episode counted, not
+valueless or history readings. Acknowledgements can take about 12 seconds and are safe to repeat.
+Realtime trends allow 20 calls per minute per caller; load once per view instead of polling.
+
 `getLegalConsent()` returns the signed-in practitioner's own terms status. If
 `needsLegalConsentReacceptance(response.legal)` is true, show the current terms before continuing.
 
@@ -483,9 +505,11 @@ create a second copy of the same observation. The queue is opt-in and requires d
 
 ## Rate limits
 
-Authentication methods reject with `RateLimitError` when the server returns a throttling outcome.
-Use `isRateLimitError(error)` and `retryAfterMs` to show a translated wait message without parsing
-backend text.
+Ovok-defined methods, including measurement saves, reject with `RateLimitError` when the server
+returns 429. A 429 or 503 with a retry delay is returned without an automatic retry; wait for
+`retryAfterMs` before trying again. Use `isRateLimitError(error)` and `retryAfterMs` to show a
+translated wait message without parsing backend text. Inherited Medplum FHIR methods keep their
+`OperationOutcomeError`; use `readOvokError(error)` to read their status and delay.
 
 ## Session management
 

package/dist/client/auth/session-fetch.js

@@ -28,6 +28,14 @@ function createSessionFetch({ config, storage, fetchImplementation, normalizedBa
     };
     const fetchOnce = async (url, options) => {
         const response = await (0, session_http_1.fetchWithTimeout)(fetchImplementation, url, options, config.requestTimeoutMs);
+        const retry = !response.ok && !isTokenRefresh(url, options)
+            ? { milliseconds: await (0, session_http_1.retryAfterMs)(response) }
+            : undefined;
+        if ((retry === null || retry === void 0 ? void 0 : retry.milliseconds) !== undefined &&
+            (response.status === 429 || response.status === 503) &&
+            options) {
+            options.maxRetryTime = 0;
+        }
         const requestUrl = new URL(url, normalizedBaseUrl);
         if (isTokenRefresh(url, options)) {
             if (response.status === 400) {
@@ -68,7 +76,7 @@ function createSessionFetch({ config, storage, fetchImplementation, normalizedBa
         }
         return isTokenRefresh(url, options)
             ? response
-            : (0, session_http_1.withHttpErrorMetadata)(response);
+            : (0, session_http_1.withHttpErrorMetadata)(response, retry);
     };
     const fetchWithRefreshRetry = async (url, options) => {
         var _a, _b, _c, _d, _e;
@@ -150,7 +158,7 @@ function createSessionFetch({ config, storage, fetchImplementation, normalizedBa
                 break;
             }
             const backoffMs = (0, session_http_1.refreshBackoffMs)(attempt);
-            const waitMs = Math.min(Math.max((_b = (0, session_http_1.retryAfterMs)(lastResponse)) !== null && _b !== void 0 ? _b : 0, backoffMs), remainingMs);
+            const waitMs = Math.min(Math.max((_b = (await (0, session_http_1.retryAfterMs)(lastResponse))) !== null && _b !== void 0 ? _b : 0, backoffMs), remainingMs);
             if (waitMs >= remainingMs) {
                 await (0, session_http_1.waitForRetry)(remainingMs, signal);
                 break;

package/dist/client/auth/session-http.d.ts

@@ -1,5 +1,7 @@
-export declare const retryAfterMs: (response: Response) => number | undefined;
-export declare const withHttpErrorMetadata: (response: Response) => Promise<Response>;
+export declare const retryAfterMs: (response: Response) => Promise<number | undefined>;
+export declare const withHttpErrorMetadata: (response: Response, retry?: {
+    milliseconds: number | undefined;
+}) => Promise<Response>;
 export declare const waitForRetry: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
 export declare const isTemporaryRefreshFailure: (status: number) => boolean;
 export declare const refreshUnavailableError: (response?: Response) => Error;

package/dist/client/auth/session-http.js

@@ -2,23 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.refreshBackoffMs = exports.fetchWithTimeout = exports.isNetworkError = exports.refreshResponseError = exports.refreshUnavailableError = exports.isTemporaryRefreshFailure = exports.waitForRetry = exports.withHttpErrorMetadata = exports.retryAfterMs = void 0;
 const ovok_error_utils_1 = require("../errors/ovok-error-utils");
-const retryAfterMs = (response) => {
+const retryAfterMs = async (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;
+    if (value) {
+        const seconds = Number(value);
+        if (Number.isFinite(seconds)) {
+            return Math.max(0, seconds * 1000);
+        }
+        const date = Date.parse(value);
+        if (Number.isFinite(date)) {
+            return Math.max(0, date - Date.now());
+        }
+    }
+    try {
+        const body = await response.clone().json();
+        return typeof body.retryAfterSec === "number" ? Math.max(0, body.retryAfterSec * 1000) : undefined;
     }
-    const seconds = Number(value);
-    if (Number.isFinite(seconds)) {
-        return Math.max(0, seconds * 1000);
+    catch (_c) {
+        return undefined;
     }
-    const date = Date.parse(value);
-    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : undefined;
 };
 exports.retryAfterMs = retryAfterMs;
 const timeoutError = () => (0, ovok_error_utils_1.namedError)("TimeoutError", "The request timed out.");
-const withHttpErrorMetadata = async (response) => {
-    var _a, _b;
+const withHttpErrorMetadata = async (response, retry) => {
+    var _a;
     if (response.ok || typeof response.clone !== "function") {
         return response;
     }
@@ -28,7 +36,7 @@ const withHttpErrorMetadata = async (response) => {
         bodyText = await response.clone().text();
         body = JSON.parse(bodyText);
     }
-    catch (_c) {
+    catch (_b) {
         body = undefined;
     }
     const outcome = body && typeof body === "object" && body.resourceType === "OperationOutcome"
@@ -42,8 +50,8 @@ const withHttpErrorMetadata = async (response) => {
         ? 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 = (0, exports.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 retryAfter = retry ? retry.milliseconds : await (0, exports.retryAfterMs)(response);
+    const requestId = (_a = response.headers.get("x-request-id")) !== null && _a !== void 0 ? _a : (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"
@@ -79,6 +87,7 @@ const withHttpErrorMetadata = async (response) => {
     ];
     const headers = new Headers(response.headers);
     headers.delete("content-length");
+    headers.delete("content-encoding");
     headers.set("content-type", "application/fhir+json");
     return new Response(JSON.stringify(enrichedOutcome), {
         status,

package/dist/client/change-history/methods.js

@@ -9,9 +9,10 @@ function serializeChangeHistoryQuery(params = {}) {
         if (value === undefined) {
             continue;
         }
-        if (key === "types" && Array.isArray(value)) {
-            for (const type of value) {
-                search.append("types[]", type);
+        if (Array.isArray(value)) {
+            const name = key === "types" ? "types[]" : key;
+            for (const item of value) {
+                search.append(name, item);
             }
         }
         else {

package/dist/client/change-history/types.d.ts

@@ -1,28 +1,41 @@
-export type ChangeHistoryKey = "deviceCreated" | "deviceDeleted" | "deviceProjectChanged" | "deviceLocationChanged" | "deviceZoneChanged" | "deviceRenamed" | "locationCreated" | "locationDeleted" | "locationRenamed" | "locationZoneChanged" | "locationFloorChanged" | "locationRoomChanged" | "locationBedChanged" | "zoneCreated" | "zoneDeleted" | "zoneRenamed";
+export type ChangeHistoryKey = "residentDeleted" | "residentMaidenNameChanged" | "orgThresholdRangeChanged" | "patientSignalsThresholdSet" | "patientSignalsThresholdRemoved" | "orgSignalsSettingsChanged" | "userInvited" | "userRenamed" | "userRoleChanged" | "userRemoved" | "roleCreated" | "roleDeleted" | "rolePermissionsChanged" | "residentAssignedToDeviceAndLocation" | "residentUnassignedFromDevicesAndLocation" | "residentUnassignedFromDevicesAndLocationWithZone" | "residentUnassignedFromDeviceAndLocation" | "residentDeviceAssigned" | "residentDeviceUnassigned" | "residentMovedToLocation" | "residentRemovedFromLocation" | "residentMovedToZone" | "residentRemovedFromZone" | "patientThresholdMetricSetToIndividual" | "patientThresholdMetricSetToGlobal" | "patientTimeOutOfBedMetricSetToIndividual" | "patientTimeOutOfBedMetricSetToGlobal" | "orgTimeOutOfBedMetricUpdated" | "residentDischarged" | "residentReactivated" | "residentArchived" | "residentNameChanged" | "orgThresholdMetricUpdated" | "patientThresholdMetricUpdated" | "deviceCreated" | "deviceDeleted" | "deviceProjectChanged" | "deviceLocationChanged" | "deviceZoneChanged" | "deviceRenamed" | "locationCreated" | "locationDeleted" | "locationRenamed" | "locationZoneChanged" | "locationFloorChanged" | "locationRoomChanged" | "locationBedChanged" | "zoneCreated" | "zoneDeleted" | "zoneRenamed";
+export type ChangeHistoryType = "Threshold" | "Location" | "Zone" | "Device" | "Resident" | "Access";
+export type ChangeHistoryScope = "all" | "global";
+export type ChangeHistorySort = "asc" | "desc";
+export type ChangeHistoryAction = "created" | "deleted" | "renamed" | "moved" | "assigned" | "unassigned" | "discharged" | "reactivated" | "thresholdChanged";
+export type ChangeHistoryResident = {
+    patientId: string;
+    residentId: string | null;
+};
+export type ChangeHistoryReference = `Patient/${string}` | `Device/${string}` | `Location/${string}` | `Organization/${string}` | `Practitioner/${string}` | `AccessPolicy/${string}`;
 export type ChangeHistoryRow = {
     id: string;
-    type: string;
-    user: Record<string, unknown> | null;
-    residentId: string | null;
-    deviceId: string | null;
+    type: ChangeHistoryType;
+    user: string;
+    residentId: string;
+    deviceId: string;
+    resident: ChangeHistoryResident | null;
     locationId?: string | null;
     zoneId?: string | null;
     time: string;
     details: {
         key: ChangeHistoryKey | (string & {});
-        values: Record<string, unknown>;
+        values: Record<string, string | number | null>;
     };
 };
 export type ChangeHistoryQuery = {
     page?: number;
     count?: number;
-    types?: readonly string[];
-    scope?: string;
-    userId?: string;
-    residentId?: string;
-    deviceId?: string;
-    locationId?: string;
-    zoneId?: string;
+    types?: readonly ChangeHistoryType[];
+    scope?: ChangeHistoryScope;
+    userId?: string | readonly string[];
+    residentId?: string | readonly string[];
+    deviceId?: string | readonly string[];
+    locationId?: string | readonly string[];
+    zoneId?: string | readonly string[];
+    relatedTo?: ChangeHistoryReference | readonly ChangeHistoryReference[];
+    actions?: ChangeHistoryAction | readonly ChangeHistoryAction[];
+    sort?: ChangeHistorySort;
     startDate?: string;
     endDate?: string;
 };

package/dist/client/errors/ovok-error.js

@@ -103,8 +103,8 @@ function mapOvokApiError(error, options = {}) {
     }
     const details = (0, exports.readOvokError)(error);
     const typedStatuses = options.includeAccessErrors
-        ? [403, 404, 409, 422, 424, 503]
-        : [409, 422, 424, 503];
+        ? [403, 404, 409, 410, 422, 424, 503]
+        : [409, 410, 422, 424, 503];
     return typedStatuses.includes((_a = details.status) !== null && _a !== void 0 ? _a : 0)
         ? new OvokApiError(details, error)
         : error;

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

@@ -128,6 +128,8 @@ export type SlimMedicalEpisodeValue = {
     observedAt: string | null;
     recordedAt: string;
 };
+/** STALE closes an out-of-bed episode that stayed open for 48 hours. */
+export type SlimEpisodeCloseReason = "RECOVERED" | "TIMEOUT" | "ACKNOWLEDGED" | "CROSSED" | "THRESHOLD_CHANGED" | "AWAY" | "STALE" | "MANUAL";
 export type SlimMedicalEpisodeCore = {
     id: string;
     patientId: string;
@@ -137,7 +139,7 @@ export type SlimMedicalEpisodeCore = {
     status: string;
     openedAt: string;
     closedAt: string | null;
-    closeReason: string | null;
+    closeReason: SlimEpisodeCloseReason | (string & {}) | null;
     lastSampleAt: string | null;
     durationMs: number | null;
     observationCount: number | null;

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

@@ -136,6 +136,7 @@ export declare class OvokClient extends MedplumClient {
      * account differs from `account`: the rest of a reading is never written under someone else's sign-in.
      */
     private executeObservationBundle;
+    private mapError;
     private bindMethods;
     /**
      * Gets the `SubscriptionManager` for WebSocket subscriptions.

package/dist/client/ovok-client.js

@@ -261,7 +261,7 @@ class OvokClient extends core_1.MedplumClient {
                 ((_b = previousLogin.profile) === null || _b === void 0 ? void 0 : _b.reference) !== accountId) {
                 await this.restoreActiveLogin(previousLogin);
             }
-            throw error;
+            throw this.mapError(error);
         }
     }
     /**
@@ -284,7 +284,7 @@ class OvokClient extends core_1.MedplumClient {
         }
         catch (error) {
             if (!sessionClient.getSavedAccounts().some((account) => account.id === accountId && account.expired)) {
-                throw error;
+                throw this.mapError(error);
             }
         }
         this.removeSavedAccount(accountId);
@@ -326,11 +326,21 @@ class OvokClient extends core_1.MedplumClient {
     }
     /** Reads Ovok's composed FHIR and public-route capability statement. */
     async getCapabilityStatement(version = "R4", requestOptions) {
-        return this.get(`/fhir/${version}/metadata`, ...(0, request_options_1.optionalArg)(requestOptions));
+        try {
+            return await this.get(`/fhir/${version}/metadata`, ...(0, request_options_1.optionalArg)(requestOptions));
+        }
+        catch (error) {
+            throw this.mapError(error);
+        }
     }
     /** Returns the non-FHIR public routes published by the backend statement. */
     async getPublicApiEndpoints(version = "R4", requestOptions) {
-        return (0, capability_1.getOvokPublicApiEndpoints)(await this.getCapabilityStatement(version, ...(0, request_options_1.optionalArg)(requestOptions)));
+        try {
+            return (0, capability_1.getOvokPublicApiEndpoints)(await this.getCapabilityStatement(version, ...(0, request_options_1.optionalArg)(requestOptions)));
+        }
+        catch (error) {
+            throw this.mapError(error);
+        }
     }
     /**
      * Saves one reading's observations, main first, with conditional creates so a retry cannot create a duplicate.
@@ -518,16 +528,24 @@ class OvokClient extends core_1.MedplumClient {
      * account differs from `account`: the rest of a reading is never written under someone else's sign-in.
      */
     async executeObservationBundle(bundle, requestOptions, account = this.accountKey()) {
-        const response = await (0, observation_bundle_utils_1.executeObservationBundle)(bundle, (request) => {
-            if (this.accountKey() !== account) {
-                throw new Error("The signed-in account changed during the save; the rest of it was not sent.");
-            }
-            return this.executeBatch(request, ...(0, request_options_1.optionalArg)(requestOptions));
-        });
-        this.invalidateSearches("Observation");
-        return response;
+        try {
+            const response = await (0, observation_bundle_utils_1.executeObservationBundle)(bundle, (request) => {
+                if (this.accountKey() !== account) {
+                    throw new Error("The signed-in account changed during the save; the rest of it was not sent.");
+                }
+                return this.executeBatch(request, ...(0, request_options_1.optionalArg)(requestOptions));
+            });
+            this.invalidateSearches("Observation");
+            return response;
+        }
+        catch (error) {
+            throw this.mapError(error);
+        }
+    }
+    mapError(error) {
+        return (0, ovok_error_1.mapOvokApiError)((0, rate_limit_error_1.mapRateLimitError)(error));
     }
-    bindMethods(methods, mapError = (error) => (0, ovok_error_1.mapOvokApiError)((0, rate_limit_error_1.mapRateLimitError)(error))) {
+    bindMethods(methods, mapError = (error) => this.mapError(error)) {
         for (const [name, method] of Object.entries(methods)) {
             const boundMethod = method.bind(this);
             this[name] = async (...args) => {

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

@@ -7,18 +7,22 @@ export declare function listSlimPatients(this: OvokClient, params?: SlimPatientL
 export declare function getSlimPatient(this: OvokClient, patientId: string, requestOptions?: MedplumRequestOptions): Promise<SlimPatient>;
 export declare function getSlimPatientEverything(this: OvokClient, patientId: string, requestOptions?: MedplumRequestOptions): Promise<Bundle<Resource>>;
 export declare function getSlimPatientCurrentVitals(this: OvokClient, patientId: string, requestOptions?: MedplumRequestOptions): Promise<Record<string, unknown>>;
+/** 422 when organizationId has no locationId or deviceId, or the assigned devices span zones. */
 export declare function createSlimPatient(this: OvokClient, body: SlimCreatePatient, requestOptions?: MedplumRequestOptions): Promise<SlimPatient>;
+/** Replaces editable fields; omitting locationId unassigns devices; 422 for null, empty, or [] deviceId with a location or devices across zones. Names are trimmed. */
 export declare function updateSlimPatient(this: OvokClient, patientId: string, body: SlimUpdatePatient, requestOptions?: MedplumRequestOptions): Promise<SlimPatient>;
+/** 409 while the resident has a device; unassign it first with updateSlimPatient and no locationId. */
 export declare function deleteSlimPatient(this: OvokClient, patientId: string, requestOptions?: MedplumRequestOptions): Promise<void>;
 export declare function listSlimDevices(this: OvokClient, params?: SlimDeviceListQuery, requestOptions?: MedplumRequestOptions): Promise<SlimPage<SlimDeviceListItem>>;
 export declare function getSlimDevice(this: OvokClient, deviceId: string, requestOptions?: MedplumRequestOptions): Promise<SlimDevice>;
+/** 409 when another customer holds the serial; 422 when this project already uses it or its organization differs from the room's zone. */
 export declare function createSlimDevice(this: OvokClient, body: SlimCreateDevice, requestOptions?: MedplumRequestOptions): Promise<SlimDevice>;
+/** 409 when another customer holds the serial; 422 when this project already uses it or its organization differs from the room's zone. Renaming moves the serial, so old-serial readings stop and live values return after a reading under the new serial. */
 export declare function updateSlimDevice(this: OvokClient, deviceId: string, body: SlimUpdateDevice, requestOptions?: MedplumRequestOptions): Promise<SlimDevice>;
 export declare function deleteSlimDevice(this: OvokClient, deviceId: string, requestOptions?: MedplumRequestOptions): Promise<void>;
 export declare function assignSlimDeviceToProject(this: OvokClient, body: SlimAssignDevice, requestOptions?: MedplumRequestOptions): Promise<SlimDevice>;
 export declare function listSlimLiveDevices(this: OvokClient, params?: SlimLiveQuery, requestOptions?: MedplumRequestOptions): Promise<SlimPage<Record<string, unknown>>>;
 export declare function listSlimLiveTelemetry(this: OvokClient, params?: SlimLiveQuery, requestOptions?: MedplumRequestOptions): Promise<SlimLiveTelemetry>;
-export declare function getSlimDeviceSleepStatus(this: OvokClient, deviceId: string, requestOptions?: MedplumRequestOptions): Promise<Record<string, unknown>>;
 export declare function getSlimDeviceTelemetry(this: OvokClient, deviceId: string, requestOptions?: MedplumRequestOptions): Promise<SlimDeviceTelemetry>;
 export declare function listSlimEffectiveObservationIds(this: OvokClient, requestOptions?: MedplumRequestOptions): Promise<Record<string, SlimObservationIds>>;
 export declare function listSlimLastObservationIds(this: OvokClient, requestOptions?: MedplumRequestOptions): Promise<Record<string, SlimObservationIds>>;
@@ -28,6 +32,7 @@ export declare function getSlimDeviceLastObservationIds(this: OvokClient, device
 export declare function listSlimNotifications(this: OvokClient, params?: SlimNotificationsQuery, requestOptions?: MedplumRequestOptions): Promise<SlimNotificationsResponse>;
 export declare function getRecentSlimNotifications(this: OvokClient, count?: number, requestOptions?: MedplumRequestOptions): Promise<SlimRecentNotificationsResponse>;
 export declare function listSlimAlarms(this: OvokClient, params?: SlimAlarmQuery, requestOptions?: MedplumRequestOptions): Promise<SlimAlarmsPage>;
+/** Can take about 12 s; a 503 signals_unavailable means it was not confirmed, so repeat after retryAfterMs (safe to repeat). */
 export declare function acknowledgeSlimAlarm(this: OvokClient, notificationId: string, requestOptions?: MedplumRequestOptions): Promise<SlimNotification>;
 export declare function getRecentSlimAlarms(this: OvokClient, count?: number, requestOptions?: MedplumRequestOptions): Promise<SlimRecentAlarms>;
 /** Same as `getRecentSlimAlarms`. */
@@ -35,24 +40,33 @@ export declare function getRecentAlarms(this: OvokClient, count?: number, reques
 export declare function getRecentSlimOutOfBed(this: OvokClient, count?: number, requestOptions?: MedplumRequestOptions): Promise<SlimRecentOutOfBed>;
 /** Same as `getRecentSlimOutOfBed`. */
 export declare function getRecentOutOfBed(this: OvokClient, count?: number, requestOptions?: MedplumRequestOptions): Promise<SlimRecentOutOfBed>;
+/** Omitting status lists new and reviewed rows; active is new, completed reviewed, and revoked hand-closed. */
 export declare function listSlimOutOfBedNotifications(this: OvokClient, params?: Omit<SlimNotificationsQuery, "type">, requestOptions?: MedplumRequestOptions): Promise<SlimNotificationsResponse>;
 export declare function listSlimMedicalNotifications(this: OvokClient, params?: SlimMedicalNotificationsQuery, requestOptions?: MedplumRequestOptions): Promise<SlimMedicalNotificationsPage>;
+/** During a Signals outage, this may return the last good page from up to 10 minutes ago, without a marker. */
 export declare function getRecentSlimMedicalNotifications(this: OvokClient, count?: number, requestOptions?: MedplumRequestOptions): Promise<SlimRecentNotificationsResponse>;
 export declare function getSlimMedicalNotification(this: OvokClient, episodeId: string, requestOptions?: MedplumRequestOptions): Promise<SlimMedicalNotificationDetail>;
+/** Can take about 12 s; a 503 signals_unavailable means it was not confirmed, so repeat after retryAfterMs (safe to repeat). */
 export declare function acknowledgeSlimMedicalNotification(this: OvokClient, episodeId: string, requestOptions?: MedplumRequestOptions): Promise<SlimMedicalNotificationRow>;
 /** Same as `acknowledgeSlimAlarm`. */
 export declare function acknowledgeSlimNotification(this: OvokClient, notificationId: string, requestOptions?: MedplumRequestOptions): Promise<SlimNotification>;
+/** A home with no stored limits reads as the default template, not as unset. */
 export declare function getSlimThreshold(this: OvokClient, requestOptions?: MedplumRequestOptions): Promise<SlimThreshold>;
+/** A 502 means Signals did not take every resident's limits and nothing was written. */
 export declare function updateSlimThreshold(this: OvokClient, body: {
     settings: SlimThresholdSettingsUpdateV1;
 }, requestOptions?: MedplumRequestOptions): Promise<SlimThreshold>;
 export declare function getSlimPatientThreshold(this: OvokClient, patientId: string, requestOptions?: MedplumRequestOptions): Promise<Record<string, unknown>>;
+/** 409 means another save for this resident is running and nothing changed; wait briefly, then send again. */
 export declare function updateSlimPatientThreshold(this: OvokClient, patientId: string, body: {
     settings: SlimThresholdSettingsUpdateV1;
 }, requestOptions?: MedplumRequestOptions): Promise<Record<string, unknown>>;
+/** A home with no stored limits reads as the default template, not as unset. */
 export declare function getSlimThresholdV2(this: OvokClient, requestOptions?: MedplumRequestOptions): Promise<SlimThresholdV2>;
+/** A 502 means Signals did not take every resident's limits and nothing was written. */
 export declare function updateSlimThresholdV2(this: OvokClient, body: SlimThresholdV2Update, requestOptions?: MedplumRequestOptions): Promise<SlimThresholdV2>;
 export declare function getSlimPatientThresholdV2(this: OvokClient, patientId: string, requestOptions?: MedplumRequestOptions): Promise<SlimPatientThresholdV2>;
+/** 409 means another save for this resident is running and nothing changed; wait briefly, then send again. */
 export declare function updateSlimPatientThresholdV2(this: OvokClient, patientId: string, body: SlimThresholdV2Update, requestOptions?: MedplumRequestOptions): Promise<SlimPatientThresholdV2>;
 export declare function getSlimTrends(this: OvokClient, params: {
     patientId: string;
@@ -60,6 +74,7 @@ export declare function getSlimTrends(this: OvokClient, params: {
     endDate: string;
     graphType: SlimHistoricalGraphType | readonly SlimHistoricalGraphType[];
 }, requestOptions?: MedplumRequestOptions): Promise<SlimTrends>;
+/** At most 20 calls per minute per caller; load once per view and wait retryAfterMs after 503. */
 export declare function getSlimRealtimeTrends(this: OvokClient, params: {
     patientId: string;
     startTime: string;
@@ -74,6 +89,7 @@ export declare function getSlimSleepStatistics(this: OvokClient, params: {
 export declare function listSlimLocations(this: OvokClient, params?: SlimLocationQuery, requestOptions?: MedplumRequestOptions): Promise<SlimPage<SlimLocation>>;
 export declare function getSlimLocation(this: OvokClient, locationId: string, requestOptions?: MedplumRequestOptions): Promise<SlimLocation>;
 export declare function createSlimLocation(this: OvokClient, body: SlimCreateLocation, requestOptions?: MedplumRequestOptions): Promise<SlimLocation>;
+/** 422 Device not found means the requested device is unreadable; nothing was saved. */
 export declare function updateSlimLocation(this: OvokClient, locationId: string, body: SlimUpdateLocation, requestOptions?: MedplumRequestOptions): Promise<SlimLocation>;
 export declare function deleteSlimLocation(this: OvokClient, locationId: string, requestOptions?: MedplumRequestOptions): Promise<void>;
 export declare function listSlimZones(this: OvokClient, params?: {

package/dist/client/slim/methods.js

@@ -15,7 +15,6 @@ exports.deleteSlimDevice = deleteSlimDevice;
 exports.assignSlimDeviceToProject = assignSlimDeviceToProject;
 exports.listSlimLiveDevices = listSlimLiveDevices;
 exports.listSlimLiveTelemetry = listSlimLiveTelemetry;
-exports.getSlimDeviceSleepStatus = getSlimDeviceSleepStatus;
 exports.getSlimDeviceTelemetry = getSlimDeviceTelemetry;
 exports.listSlimEffectiveObservationIds = listSlimEffectiveObservationIds;
 exports.listSlimLastObservationIds = listSlimLastObservationIds;
@@ -97,12 +96,15 @@ async function getSlimPatientEverything(patientId, requestOptions) {
 async function getSlimPatientCurrentVitals(patientId, requestOptions) {
     return this.get(`/v1/slim/patient/${encodeURIComponent(patientId)}/current-vitals`, ...(0, request_options_1.optionalArg)(requestOptions));
 }
+/** 422 when organizationId has no locationId or deviceId, or the assigned devices span zones. */
 async function createSlimPatient(body, requestOptions) {
     return this.post("/v1/slim/patient", body, undefined, requestOptions);
 }
+/** Replaces editable fields; omitting locationId unassigns devices; 422 for null, empty, or [] deviceId with a location or devices across zones. Names are trimmed. */
 async function updateSlimPatient(patientId, body, requestOptions) {
     return (await this.put(`/v1/slim/patient/${encodeURIComponent(patientId)}`, body, undefined, requestOptions));
 }
+/** 409 while the resident has a device; unassign it first with updateSlimPatient and no locationId. */
 async function deleteSlimPatient(patientId, requestOptions) {
     await this.delete(`/v1/slim/patient/${encodeURIComponent(patientId)}`, ...(0, request_options_1.optionalArg)(requestOptions));
 }
@@ -112,9 +114,11 @@ async function listSlimDevices(params = {}, requestOptions) {
 async function getSlimDevice(deviceId, requestOptions) {
     return this.get(`/v1/slim/device/${encodeURIComponent(deviceId)}`, ...(0, request_options_1.optionalArg)(requestOptions));
 }
+/** 409 when another customer holds the serial; 422 when this project already uses it or its organization differs from the room's zone. */
 async function createSlimDevice(body, requestOptions) {
     return this.post("/v1/slim/device", body, undefined, requestOptions);
 }
+/** 409 when another customer holds the serial; 422 when this project already uses it or its organization differs from the room's zone. Renaming moves the serial, so old-serial readings stop and live values return after a reading under the new serial. */
 async function updateSlimDevice(deviceId, body, requestOptions) {
     return (await this.put(`/v1/slim/device/${encodeURIComponent(deviceId)}`, body, undefined, requestOptions));
 }
@@ -132,9 +136,6 @@ async function listSlimLiveTelemetry(params = {}, requestOptions) {
     validateLiveCount(params);
     return (0, live_read_1.liveGet)(this, `/v1/slim/device/live/telemetry${(0, query_string_1.toQueryString)(params)}`, requestOptions);
 }
-async function getSlimDeviceSleepStatus(deviceId, requestOptions) {
-    return (0, live_read_1.liveGet)(this, `/v1/slim/device/live/cloudwatch/${encodeURIComponent(deviceId)}`, requestOptions);
-}
 async function getSlimDeviceTelemetry(deviceId, requestOptions) {
     return (0, live_read_1.liveGet)(this, `/v1/slim/telemetry/${encodeURIComponent(deviceId)}`, requestOptions);
 }
@@ -160,6 +161,7 @@ async function getRecentSlimNotifications(count, requestOptions) {
 async function listSlimAlarms(params = {}, requestOptions) {
     return this.get(`/v1/slim/notifications/alarms${(0, query_string_1.toQueryString)(params)}`, { cache: "reload", ...requestOptions });
 }
+/** Can take about 12 s; a 503 signals_unavailable means it was not confirmed, so repeat after retryAfterMs (safe to repeat). */
 async function acknowledgeSlimAlarm(notificationId, requestOptions) {
     return (await this.patch(`/v1/slim/notifications/${encodeURIComponent(notificationId)}/ack`, [], ...(0, request_options_1.optionalArg)(requestOptions)));
 }
@@ -177,6 +179,7 @@ async function getRecentSlimOutOfBed(count, requestOptions) {
 function getRecentOutOfBed(count, requestOptions) {
     return getRecentSlimOutOfBed.call(this, count, ...(0, request_options_1.optionalArg)(requestOptions));
 }
+/** Omitting status lists new and reviewed rows; active is new, completed reviewed, and revoked hand-closed. */
 async function listSlimOutOfBedNotifications(params = {}, requestOptions) {
     return this.get(`/v1/slim/notifications/oob${(0, query_string_1.toQueryString)(params)}`, { cache: "reload", ...requestOptions });
 }
@@ -191,12 +194,14 @@ function validateMedicalCodes(codes) {
         throw new TypeError("codes must contain at most 32 valid LOINC codes or PI.");
     }
 }
+/** During a Signals outage, this may return the last good page from up to 10 minutes ago, without a marker. */
 async function getRecentSlimMedicalNotifications(count, requestOptions) {
     return this.get(`/v1/slim/notifications/recent/medical${(0, query_string_1.toQueryString)({ count })}`, { cache: "reload", ...requestOptions });
 }
 async function getSlimMedicalNotification(episodeId, requestOptions) {
     return this.get(`/v1/slim/notifications/medical/${encodeURIComponent(episodeId)}`, { cache: "reload", ...requestOptions });
 }
+/** Can take about 12 s; a 503 signals_unavailable means it was not confirmed, so repeat after retryAfterMs (safe to repeat). */
 async function acknowledgeSlimMedicalNotification(episodeId, requestOptions) {
     return this.post(`/v1/slim/notifications/medical/${encodeURIComponent(episodeId)}/ack`, undefined, undefined, requestOptions);
 }
@@ -204,33 +209,44 @@ async function acknowledgeSlimMedicalNotification(episodeId, requestOptions) {
 function acknowledgeSlimNotification(notificationId, requestOptions) {
     return acknowledgeSlimAlarm.call(this, notificationId, ...(0, request_options_1.optionalArg)(requestOptions));
 }
+/** A home with no stored limits reads as the default template, not as unset. */
 async function getSlimThreshold(requestOptions) {
     return this.get("/v1/slim/threshold", ...(0, request_options_1.optionalArg)(requestOptions));
 }
+/** A 502 means Signals did not take every resident's limits and nothing was written. */
 async function updateSlimThreshold(body, requestOptions) {
-    return (await this.put("/v1/slim/threshold", body, undefined, requestOptions));
+    return (await this.put("/v1/slim/threshold", body, undefined, {
+        ...requestOptions, maxRetries: 0, maxRetryTime: 0,
+    }));
 }
 async function getSlimPatientThreshold(patientId, requestOptions) {
     return this.get(`/v1/slim/threshold/patient/${encodeURIComponent(patientId)}`, ...(0, request_options_1.optionalArg)(requestOptions));
 }
+/** 409 means another save for this resident is running and nothing changed; wait briefly, then send again. */
 async function updateSlimPatientThreshold(patientId, body, requestOptions) {
-    return (await this.put(`/v1/slim/threshold/patient/${encodeURIComponent(patientId)}`, body, undefined, requestOptions));
+    return (await this.put(`/v1/slim/threshold/patient/${encodeURIComponent(patientId)}`, body, undefined, { ...requestOptions, maxRetries: 0, maxRetryTime: 0 }));
 }
+/** A home with no stored limits reads as the default template, not as unset. */
 async function getSlimThresholdV2(requestOptions) {
     return this.get("/v2/slim/threshold", ...(0, request_options_1.optionalArg)(requestOptions));
 }
+/** A 502 means Signals did not take every resident's limits and nothing was written. */
 async function updateSlimThresholdV2(body, requestOptions) {
-    return (await this.put("/v2/slim/threshold", body, undefined, requestOptions));
+    return (await this.put("/v2/slim/threshold", body, undefined, {
+        ...requestOptions, maxRetries: 0, maxRetryTime: 0,
+    }));
 }
 async function getSlimPatientThresholdV2(patientId, requestOptions) {
     return this.get(`/v2/slim/threshold/patient/${encodeURIComponent(patientId)}`, ...(0, request_options_1.optionalArg)(requestOptions));
 }
+/** 409 means another save for this resident is running and nothing changed; wait briefly, then send again. */
 async function updateSlimPatientThresholdV2(patientId, body, requestOptions) {
-    return (await this.put(`/v2/slim/threshold/patient/${encodeURIComponent(patientId)}`, body, undefined, requestOptions));
+    return (await this.put(`/v2/slim/threshold/patient/${encodeURIComponent(patientId)}`, body, undefined, { ...requestOptions, maxRetries: 0, maxRetryTime: 0 }));
 }
 async function getSlimTrends(params, requestOptions) {
     return this.get(`/v1/slim/trends/graphs${(0, query_string_1.toQueryString)(params)}`, ...(0, request_options_1.optionalArg)(requestOptions));
 }
+/** At most 20 calls per minute per caller; load once per view and wait retryAfterMs after 503. */
 async function getSlimRealtimeTrends(params, requestOptions) {
     return this.get(`/v1/slim/trends/realtime${(0, query_string_1.toQueryString)(params)}`, ...(0, request_options_1.optionalArg)(requestOptions));
 }
@@ -246,6 +262,7 @@ async function getSlimLocation(locationId, requestOptions) {
 async function createSlimLocation(body, requestOptions) {
     return this.post("/v1/slim/location", body, undefined, requestOptions);
 }
+/** 422 Device not found means the requested device is unreadable; nothing was saved. */
 async function updateSlimLocation(locationId, body, requestOptions) {
     return (await this.put(`/v1/slim/location/${encodeURIComponent(locationId)}`, body, undefined, requestOptions));
 }

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

@@ -38,9 +38,10 @@ export type SlimPatientListItem = {
     locationName: string | null;
     deviceId: string | null;
     deviceName: string | null;
-    medicalSettings: string | null;
-    bedActivitySettings: string | null;
+    medicalSettings: SlimSettingsScope | null;
+    bedActivitySettings: SlimSettingsScope | null;
 };
+export type SlimSettingsScope = "inactive" | "global" | "individual";
 export type SlimPatientListQuery = {
     page?: number;
     count?: number;
@@ -51,8 +52,8 @@ export type SlimPatientListQuery = {
     includeDischargedRecent?: boolean;
     organizationId?: string;
     hasDevice?: boolean;
-    medicalSettings?: string;
-    bedActivitySettings?: string;
+    medicalSettings?: SlimSettingsScope;
+    bedActivitySettings?: SlimSettingsScope;
 };
 export type SlimCreatePatient = {
     name: SlimHumanName[];
@@ -63,6 +64,7 @@ export type SlimCreatePatient = {
     locationId?: string;
     admissionDate?: string;
 };
+/** Replaces the editable fields; omitting locationId unassigns the resident's devices. */
 export type SlimUpdatePatient = Partial<SlimCreatePatient> & {
     residentState?: SlimResidentState;
     dischargeDate?: string;
@@ -222,6 +224,7 @@ export type SlimThresholdSettingsUpdateV1 = Record<string, SlimThresholdSettingU
 export type SlimThresholdV2Setting = {
     mode: string;
     deviationPercent: number | null;
+    /** Null when the bed window is 23 hours 59 minutes or longer. */
     baselineAverage: number | null;
     effectiveBand: {
         min: number;
@@ -239,7 +242,7 @@ export type SignalsSyncStatus = {
     reason: string;
 } | null;
 export type SlimThresholdV2 = {
-    id?: string;
+    id: string | null;
     projectId?: string;
     status?: "active" | "retired";
     date?: string;

package/dist/conformance/api-requirements.js

@@ -122,7 +122,6 @@ exports.OVOK_CORE_API_REQUIREMENTS = {
         { method: "PUT", path: "/v1/slim/device/assign/project", group: "Slim/Device" },
         { method: "GET", path: "/v1/slim/device/live", group: "Slim/Device" },
         { method: "GET", path: "/v1/slim/device/live/telemetry", group: "Slim/Device" },
-        { method: "GET", path: "/v1/slim/device/live/cloudwatch/:deviceId", group: "Slim/Device" },
         { method: "GET", path: "/v1/slim/telemetry/:deviceId", group: "Slim/Telemetry" },
         { method: "GET", path: "/v1/slim/telemetry/effectiveIds", group: "Slim/Telemetry" },
         { method: "GET", path: "/v1/slim/telemetry/lastIds", group: "Slim/Telemetry" },

package/dist/conformance/capability-requirements.js

@@ -48,7 +48,7 @@ exports.OVOK_CORE_REQUIREMENTS = {
     description: "The FHIR surface a server must provide for the @ovok/core client library's own methods to function.",
     software: {
         name: "@ovok/core",
-        version: "0.4.42",
+        version: "0.4.43",
     },
     fhirVersion: "4.0.1",
     format: ["json"],

package/dist/hooks/notification-hooks.d.ts

@@ -7,6 +7,7 @@ export declare const useRecentSlimNotifications: (count?: number) => OvokRequest
 export declare const useSlimAlarms: (params?: SlimAlarmQuery) => OvokRequestState<SlimAlarmsPage>;
 export declare const useRecentAlarms: (count?: number) => OvokRequestState<SlimRecentAlarms>;
 export declare const useRecentOutOfBed: (count?: number) => OvokRequestState<SlimRecentOutOfBed>;
+/** Without status, loads new and reviewed rows together; active is new, completed reviewed, and revoked hand-closed. */
 export declare const useSlimOutOfBedNotifications: (params?: Omit<SlimNotificationsQuery, "type">) => OvokRequestState<SlimNotificationsResponse>;
 /** Fetches every cursor page; a short page is not treated as the end of the feed. */
 export declare const useSlimMedicalNotifications: (params?: Omit<SlimMedicalNotificationsQuery, "cursor">, options?: {

package/dist/hooks/notification-hooks.js

@@ -73,6 +73,7 @@ const useRecentAlarms = (count) => useSlimNotificationFeed((client, signal) => c
 exports.useRecentAlarms = useRecentAlarms;
 const useRecentOutOfBed = (count) => useSlimNotificationFeed((client, signal) => client.getRecentOutOfBed(count, { signal }), count, "recent");
 exports.useRecentOutOfBed = useRecentOutOfBed;
+/** Without status, loads new and reviewed rows together; active is new, completed reviewed, and revoked hand-closed. */
 const useSlimOutOfBedNotifications = (params = {}) => useSlimNotificationFeed((client, signal) => client.listSlimOutOfBedNotifications(params, { signal }), params, "resources");
 exports.useSlimOutOfBedNotifications = useSlimOutOfBedNotifications;
 /** Fetches every cursor page; a short page is not treated as the end of the feed. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ovok/core",
-  "version": "0.4.42",
+  "version": "0.4.43",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",