@ovok/core 0.4.5 → 0.4.7

package/README.md

@@ -16,7 +16,7 @@ Core TypeScript SDK for healthcare applications. Provides authentication, AI-FHI
 - 📥 Opt-in durable offline measurement queue with idempotent retries
 - 🧭 Runtime discovery of the backend FHIR and public API capabilities
 - 🧩 Typed accounts, projects, localization, and patient-observation APIs
-- 🏥 Typed CareHub patient, device, telemetry, notification, and monitoring APIs
+- 🏥 Typed Slim patient, device, telemetry, notification, and monitoring APIs
 - 🚨 Typed Signals thresholds, alerts, and project settings APIs
 
 ## Installation
@@ -265,6 +265,15 @@ const acked = await client.acknowledgeSignalsRawAlert(alert.id);
 // acked.acknowledgedAt and acked.acknowledgedActor record when and by whom.
 ```
 
+The alert hooks take the same switch: `episodes` is optional and defaults to episodes, so existing
+calls are unchanged; `episodes: false` reads and acknowledges raw alerts, typed as `SignalsRawAlert`.
+
+```tsx
+const worklist = useSignalsAlerts({ episodes: false, acknowledged: false, codes: ["8867-4"] });
+const one = useSignalsAlert(alertId, { episodes: false });
+const { mutate: acknowledge } = useAcknowledgeSignalsAlert({ episodes: false });
+```
+
 Each `SignalsRawAlert` carries Signals' own `id`, `createdAt` and `resolvedAt`. `status` is Signals'
 state of the reading: `ACTIVE` while it breaches, `RESOLVED` once it recovered or the alert was
 acknowledged. An alert stays open for the practitioner until it is acknowledged, so list the
@@ -286,20 +295,20 @@ caller's project and the residents their access policy allows: an alert outside
 404, and acknowledging needs `signals_alerts:update` and update access to the resident (403 when the
 caller can only read them).
 
-## CareHub APIs
+## Slim APIs
 
-CareHub methods cover the verified `/v1/slim/*` and `/v2/slim/*` application routes for
+Slim methods cover the verified `/v1/slim/*` and `/v2/slim/*` application routes for
 patients, devices, telemetry, notifications, thresholds, trends, sleep, locations, zones, and
-PDF export. These routes require the backend's bearer session and CareHub permissions.
+PDF export. These routes require the backend's bearer session and Slim permissions.
 
 ```typescript
-const residents = await client.listCarehubPatients({ residentState: "active" });
-const devices = await client.listCarehubDevices({ active: true });
-const telemetry = await client.getCarehubDeviceTelemetry(deviceId);
-const alerts = await client.listCarehubMedicalNotifications({ count: 25 });
+const residents = await client.listSlimPatients({ residentState: "active" });
+const devices = await client.listSlimDevices({ active: true });
+const telemetry = await client.getSlimDeviceTelemetry(deviceId);
+const alerts = await client.listSlimMedicalNotifications({ count: 25 });
 ```
 
-CareHub is intentionally represented as typed application APIs rather than changing the FHIR
+Slim is intentionally represented as typed application APIs rather than changing the FHIR
 observation save/offline behavior used by native integrations.
 
 ## Application APIs
@@ -329,12 +338,12 @@ download elements; the backend remains responsible for authorization and signed
 ## React hooks
 
 The package exports additive hooks for capability discovery, project configuration, patient profile
-and health data, questionnaires, scheduling resources, CareHub lists, telemetry, notifications,
+and health data, questionnaires, scheduling resources, Slim lists, telemetry, notifications,
 documents, content, video consultations, and localization. Every request hook returns `data`,
 `loading`, `error`, and `reload`; mutations expose `data`, `loading`, `error`, `mutate`, and `reset`.
 
 ```tsx
-const { data: patients, loading, error } = useCarehubPatients({
+const { data: patients, loading, error } = useSlimPatients({
   residentState: "active",
 });
 
@@ -485,7 +494,7 @@ changing only practitioner sharing, send the current `enabled` value too.
 turning it off does not revoke existing shares. A project admin can toggle it
 through `PUT /v1/patient-sharing/settings`; concurrent settings changes return
 409 and should be reloaded, and non-admins receive 403. Do not enable it for a project
-whose practitioners use the Carehub dashboard. Map the email templates
+whose practitioners use the Slim dashboard. Map the email templates
 `PATIENT_INVITE`, `PATIENT_ASSIGNMENT_REQUEST`,
 `PRACTITIONER_INVITED_BY_PATIENT`, and `PRACTITIONER_PATIENT_SHARED` before
 turning the feature on; an unmapped email can still produce the uniform 202

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

@@ -4,7 +4,6 @@ import { OvokPublicApiEndpoint } from "../conformance/capability";
 import * as aiFhirMethods from "./ai-fhir/methods";
 import * as authMethods from "./auth/methods";
 import * as botMethods from "./bot/methods";
-import * as carehubMethods from "./carehub/methods";
 import * as aiMethods from "./chat/ai/methods";
 import * as emailMethods from "./email";
 import * as experienceMethods from "./experience/methods";
@@ -17,6 +16,7 @@ import * as patientSharingMethods from "./patient-sharing/methods";
 import * as platformMethods from "./platform/methods";
 import * as questionnaireResponseMethods from "./questionnaire-response/methods";
 import * as signalsMethods from "./signals/methods";
+import * as slimMethods from "./slim/methods";
 export declare const MAX_CONDITIONAL_OBSERVATION_ENTRIES = 8;
 export { MAX_OBSERVATION_BUNDLE_BYTES } from "./observation/observation-bundle-utils";
 export type SaveObservationsResult = {
@@ -62,7 +62,7 @@ export declare class OvokClient extends MedplumClient {
      */
     getSubscriptionManager(): SubscriptionManager;
 }
-type Methods = typeof authMethods & typeof observationMethods & typeof questionnaireResponseMethods & typeof aiMethods & typeof aiFhirMethods & typeof botMethods & typeof carehubMethods & typeof emailMethods & typeof platformMethods & typeof experienceMethods & typeof inviteMethods & typeof patientMethods & typeof patientSharingMethods & typeof signalsMethods;
+type Methods = typeof authMethods & typeof observationMethods & typeof questionnaireResponseMethods & typeof aiMethods & typeof aiFhirMethods & typeof botMethods & typeof slimMethods & typeof emailMethods & typeof platformMethods & typeof experienceMethods & typeof inviteMethods & typeof patientMethods & typeof patientSharingMethods & typeof signalsMethods;
 type Omitted<T> = Omit<T, "executeBot">;
 declare module "./ovok-client" {
     interface OvokClient extends Omitted<Methods> {

package/dist/client/ovok-client.js

@@ -40,7 +40,6 @@ const capability_1 = require("../conformance/capability");
 const aiFhirMethods = __importStar(require("./ai-fhir/methods"));
 const authMethods = __importStar(require("./auth/methods"));
 const botMethods = __importStar(require("./bot/methods"));
-const carehubMethods = __importStar(require("./carehub/methods"));
 const aiMethods = __importStar(require("./chat/ai/methods"));
 const emailMethods = __importStar(require("./email"));
 const rate_limit_error_1 = require("./errors/rate-limit-error");
@@ -55,6 +54,7 @@ const platformMethods = __importStar(require("./platform/methods"));
 const questionnaireResponseMethods = __importStar(require("./questionnaire-response/methods"));
 const errors_1 = require("./signals/errors");
 const signalsMethods = __importStar(require("./signals/methods"));
+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; } });
@@ -74,7 +74,7 @@ class OvokClient extends core_1.MedplumClient {
         this.bindMethods(aiMethods);
         this.bindMethods(aiFhirMethods);
         this.bindMethods(botMethods);
-        this.bindMethods(carehubMethods);
+        this.bindMethods(slimMethods);
         this.bindMethods(emailMethods);
         this.bindMethods(platformMethods);
         this.bindMethods(experienceMethods);

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

@@ -0,0 +1,71 @@
+import { Bundle, Resource } from "@medplum/fhirtypes";
+import { OvokClient } from "../ovok-client";
+import { SlimAssignDevice, SlimCreateDevice, SlimCreateLocation, SlimCreatePatient, SlimDevice, SlimDeviceListItem, SlimDeviceListQuery, SlimDeviceTelemetry, SlimExportPdf, SlimExportPdfRequest, SlimLiveQuery, SlimLiveTelemetry, SlimLocation, SlimLocationQuery, SlimNotification, SlimNotificationsQuery, SlimNotificationsResponse, SlimObservationIds, SlimPage, SlimPatient, SlimPatientListItem, SlimPatientListQuery, SlimRecentNotificationsResponse, SlimSleepStatistics, SlimThreshold, SlimTrends, SlimUpdateDevice, SlimUpdateLocation, SlimUpdatePatient, SlimZone, SlimZoneDetail } from "./types";
+export declare function listSlimPatients(this: OvokClient, params?: SlimPatientListQuery): Promise<SlimPage<SlimPatientListItem>>;
+export declare function getSlimPatient(this: OvokClient, patientId: string): Promise<SlimPatient>;
+export declare function getSlimPatientEverything(this: OvokClient, patientId: string): Promise<Bundle<Resource>>;
+export declare function getSlimPatientCurrentVitals(this: OvokClient, patientId: string): Promise<Record<string, unknown>>;
+export declare function createSlimPatient(this: OvokClient, body: SlimCreatePatient): Promise<SlimPatient>;
+export declare function updateSlimPatient(this: OvokClient, patientId: string, body: SlimUpdatePatient): Promise<SlimPatient>;
+export declare function deleteSlimPatient(this: OvokClient, patientId: string): Promise<void>;
+export declare function listSlimDevices(this: OvokClient, params?: SlimDeviceListQuery): Promise<SlimPage<SlimDeviceListItem>>;
+export declare function getSlimDevice(this: OvokClient, deviceId: string): Promise<SlimDevice>;
+export declare function createSlimDevice(this: OvokClient, body: SlimCreateDevice): Promise<SlimDevice>;
+export declare function updateSlimDevice(this: OvokClient, deviceId: string, body: SlimUpdateDevice): Promise<SlimDevice>;
+export declare function deleteSlimDevice(this: OvokClient, deviceId: string): Promise<void>;
+export declare function assignSlimDeviceToProject(this: OvokClient, body: SlimAssignDevice): Promise<SlimDevice>;
+export declare function listSlimLiveDevices(this: OvokClient, params?: SlimLiveQuery): Promise<SlimPage<Record<string, unknown>>>;
+export declare function listSlimLiveTelemetry(this: OvokClient, params?: SlimLiveQuery): Promise<SlimLiveTelemetry>;
+export declare function getSlimDeviceSleepStatus(this: OvokClient, deviceId: string): Promise<Record<string, unknown>>;
+export declare function getSlimDeviceTelemetry(this: OvokClient, deviceId: string): Promise<SlimDeviceTelemetry>;
+export declare function listSlimEffectiveObservationIds(this: OvokClient): Promise<Record<string, SlimObservationIds>>;
+export declare function listSlimLastObservationIds(this: OvokClient): Promise<Record<string, SlimObservationIds>>;
+export declare function getSlimDeviceEffectiveObservationIds(this: OvokClient, deviceId: string): Promise<Omit<SlimObservationIds, "batch">>;
+export declare function getSlimDeviceLastObservationIds(this: OvokClient, deviceId: string): Promise<SlimObservationIds>;
+export declare function listSlimNotifications(this: OvokClient, params?: SlimNotificationsQuery): Promise<SlimNotificationsResponse>;
+export declare function getRecentSlimNotifications(this: OvokClient, count?: number): Promise<SlimRecentNotificationsResponse>;
+export declare function listSlimOutOfBedNotifications(this: OvokClient, params?: Omit<SlimNotificationsQuery, "type">): Promise<SlimNotificationsResponse>;
+export declare function listSlimMedicalNotifications(this: OvokClient, params?: SlimNotificationsQuery): Promise<SlimNotificationsResponse>;
+export declare function getRecentSlimMedicalNotifications(this: OvokClient, count?: number): Promise<SlimRecentNotificationsResponse>;
+export declare function getSlimMedicalNotification(this: OvokClient, episodeId: string): Promise<SlimNotification>;
+export declare function acknowledgeSlimMedicalNotification(this: OvokClient, episodeId: string): Promise<SlimNotification>;
+export declare function acknowledgeSlimNotification(this: OvokClient, notificationId: string): Promise<SlimNotification>;
+export declare function getSlimThreshold(this: OvokClient): Promise<SlimThreshold>;
+export declare function updateSlimThreshold(this: OvokClient, body: Record<string, unknown>): Promise<SlimThreshold>;
+export declare function getSlimPatientThreshold(this: OvokClient, patientId: string): Promise<Record<string, unknown>>;
+export declare function updateSlimPatientThreshold(this: OvokClient, patientId: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function getSlimThresholdV2(this: OvokClient): Promise<Record<string, unknown>>;
+export declare function updateSlimThresholdV2(this: OvokClient, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function getSlimPatientThresholdV2(this: OvokClient, patientId: string): Promise<Record<string, unknown>>;
+export declare function updateSlimPatientThresholdV2(this: OvokClient, patientId: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function getSlimTrends(this: OvokClient, params: {
+    patientId: string;
+    startDate: string;
+    endDate: string;
+    graphType: string;
+}): Promise<SlimTrends>;
+export declare function getSlimSleepStatistics(this: OvokClient, params: {
+    endDate: string;
+    lastDayCount?: number;
+    patientId: string;
+}): Promise<SlimSleepStatistics>;
+export declare function listSlimLocations(this: OvokClient, params?: SlimLocationQuery): Promise<SlimPage<SlimLocation>>;
+export declare function getSlimLocation(this: OvokClient, locationId: string): Promise<SlimLocation>;
+export declare function createSlimLocation(this: OvokClient, body: SlimCreateLocation): Promise<SlimLocation>;
+export declare function updateSlimLocation(this: OvokClient, locationId: string, body: SlimUpdateLocation): Promise<SlimLocation>;
+export declare function deleteSlimLocation(this: OvokClient, locationId: string): Promise<void>;
+export declare function listSlimZones(this: OvokClient, params?: {
+    page?: number;
+    count?: number;
+    sortBy?: string;
+    orderBy?: "ASC" | "DESC";
+    search?: string;
+}): Promise<SlimPage<SlimZone>>;
+export declare function getSlimZone(this: OvokClient, zoneId: string): Promise<SlimZoneDetail>;
+export declare function getSlimZoneDeviceCounts(this: OvokClient, params?: {
+    all?: boolean;
+    effectiveSleepStatus?: string;
+    includeUnassigned?: boolean;
+    includeEmpty?: boolean;
+}): Promise<Record<string, unknown>>;
+export declare function exportSlimPatientPdf(this: OvokClient, body: SlimExportPdfRequest): Promise<SlimExportPdf>;

package/dist/client/slim/methods.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSlimPatients = listSlimPatients;
+exports.getSlimPatient = getSlimPatient;
+exports.getSlimPatientEverything = getSlimPatientEverything;
+exports.getSlimPatientCurrentVitals = getSlimPatientCurrentVitals;
+exports.createSlimPatient = createSlimPatient;
+exports.updateSlimPatient = updateSlimPatient;
+exports.deleteSlimPatient = deleteSlimPatient;
+exports.listSlimDevices = listSlimDevices;
+exports.getSlimDevice = getSlimDevice;
+exports.createSlimDevice = createSlimDevice;
+exports.updateSlimDevice = updateSlimDevice;
+exports.deleteSlimDevice = deleteSlimDevice;
+exports.assignSlimDeviceToProject = assignSlimDeviceToProject;
+exports.listSlimLiveDevices = listSlimLiveDevices;
+exports.listSlimLiveTelemetry = listSlimLiveTelemetry;
+exports.getSlimDeviceSleepStatus = getSlimDeviceSleepStatus;
+exports.getSlimDeviceTelemetry = getSlimDeviceTelemetry;
+exports.listSlimEffectiveObservationIds = listSlimEffectiveObservationIds;
+exports.listSlimLastObservationIds = listSlimLastObservationIds;
+exports.getSlimDeviceEffectiveObservationIds = getSlimDeviceEffectiveObservationIds;
+exports.getSlimDeviceLastObservationIds = getSlimDeviceLastObservationIds;
+exports.listSlimNotifications = listSlimNotifications;
+exports.getRecentSlimNotifications = getRecentSlimNotifications;
+exports.listSlimOutOfBedNotifications = listSlimOutOfBedNotifications;
+exports.listSlimMedicalNotifications = listSlimMedicalNotifications;
+exports.getRecentSlimMedicalNotifications = getRecentSlimMedicalNotifications;
+exports.getSlimMedicalNotification = getSlimMedicalNotification;
+exports.acknowledgeSlimMedicalNotification = acknowledgeSlimMedicalNotification;
+exports.acknowledgeSlimNotification = acknowledgeSlimNotification;
+exports.getSlimThreshold = getSlimThreshold;
+exports.updateSlimThreshold = updateSlimThreshold;
+exports.getSlimPatientThreshold = getSlimPatientThreshold;
+exports.updateSlimPatientThreshold = updateSlimPatientThreshold;
+exports.getSlimThresholdV2 = getSlimThresholdV2;
+exports.updateSlimThresholdV2 = updateSlimThresholdV2;
+exports.getSlimPatientThresholdV2 = getSlimPatientThresholdV2;
+exports.updateSlimPatientThresholdV2 = updateSlimPatientThresholdV2;
+exports.getSlimTrends = getSlimTrends;
+exports.getSlimSleepStatistics = getSlimSleepStatistics;
+exports.listSlimLocations = listSlimLocations;
+exports.getSlimLocation = getSlimLocation;
+exports.createSlimLocation = createSlimLocation;
+exports.updateSlimLocation = updateSlimLocation;
+exports.deleteSlimLocation = deleteSlimLocation;
+exports.listSlimZones = listSlimZones;
+exports.getSlimZone = getSlimZone;
+exports.getSlimZoneDeviceCounts = getSlimZoneDeviceCounts;
+exports.exportSlimPatientPdf = exportSlimPatientPdf;
+const query = (params) => {
+    const values = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined) {
+            values.set(key, String(value));
+        }
+    }
+    const encoded = values.toString();
+    return encoded === "" ? "" : `?${encoded}`;
+};
+const segment = (value) => encodeURIComponent(value);
+async function listSlimPatients(params = {}) {
+    return this.get(`/v1/slim/patient${query(params)}`);
+}
+async function getSlimPatient(patientId) {
+    return this.get(`/v1/slim/patient/${segment(patientId)}`);
+}
+async function getSlimPatientEverything(patientId) {
+    return this.get(`/v1/slim/patient/${segment(patientId)}/$everything`);
+}
+async function getSlimPatientCurrentVitals(patientId) {
+    return this.get(`/v1/slim/patient/${segment(patientId)}/current-vitals`);
+}
+async function createSlimPatient(body) {
+    return this.post("/v1/slim/patient", body);
+}
+async function updateSlimPatient(patientId, body) {
+    return (await this.put(`/v1/slim/patient/${segment(patientId)}`, body));
+}
+async function deleteSlimPatient(patientId) {
+    await this.delete(`/v1/slim/patient/${segment(patientId)}`);
+}
+async function listSlimDevices(params = {}) {
+    return this.get(`/v1/slim/device${query(params)}`);
+}
+async function getSlimDevice(deviceId) {
+    return this.get(`/v1/slim/device/${segment(deviceId)}`);
+}
+async function createSlimDevice(body) {
+    return this.post("/v1/slim/device", body);
+}
+async function updateSlimDevice(deviceId, body) {
+    return (await this.put(`/v1/slim/device/${segment(deviceId)}`, body));
+}
+async function deleteSlimDevice(deviceId) {
+    await this.delete(`/v1/slim/device/${segment(deviceId)}`);
+}
+async function assignSlimDeviceToProject(body) {
+    return (await this.put("/v1/slim/device/assign/project", body));
+}
+async function listSlimLiveDevices(params = {}) {
+    return this.get(`/v1/slim/device/live${query(params)}`);
+}
+async function listSlimLiveTelemetry(params = {}) {
+    return this.get(`/v1/slim/device/live/telemetry${query(params)}`);
+}
+async function getSlimDeviceSleepStatus(deviceId) {
+    return this.get(`/v1/slim/device/live/cloudwatch/${segment(deviceId)}`);
+}
+async function getSlimDeviceTelemetry(deviceId) {
+    return this.get(`/v1/slim/telemetry/${segment(deviceId)}`);
+}
+async function listSlimEffectiveObservationIds() {
+    return this.get("/v1/slim/telemetry/effectiveIds");
+}
+async function listSlimLastObservationIds() {
+    return this.get("/v1/slim/telemetry/lastIds");
+}
+async function getSlimDeviceEffectiveObservationIds(deviceId) {
+    return this.get(`/v1/slim/telemetry/${segment(deviceId)}/effectiveIds`);
+}
+async function getSlimDeviceLastObservationIds(deviceId) {
+    return this.get(`/v1/slim/telemetry/${segment(deviceId)}/lastIds`);
+}
+async function listSlimNotifications(params = {}) {
+    return this.get(`/v1/slim/notifications${query(params)}`);
+}
+async function getRecentSlimNotifications(count) {
+    return this.get(`/v1/slim/notifications/recent${query({ count })}`);
+}
+async function listSlimOutOfBedNotifications(params = {}) {
+    return this.get(`/v1/slim/notifications/oob${query(params)}`);
+}
+async function listSlimMedicalNotifications(params = {}) {
+    return this.get(`/v1/slim/notifications/medical${query(params)}`);
+}
+async function getRecentSlimMedicalNotifications(count) {
+    return this.get(`/v1/slim/notifications/recent/medical${query({ count })}`);
+}
+async function getSlimMedicalNotification(episodeId) {
+    return this.get(`/v1/slim/notifications/medical/${segment(episodeId)}`);
+}
+async function acknowledgeSlimMedicalNotification(episodeId) {
+    return this.post(`/v1/slim/notifications/medical/${segment(episodeId)}/ack`);
+}
+async function acknowledgeSlimNotification(notificationId) {
+    return (await this.patch(`/v1/slim/notifications/${segment(notificationId)}/ack`, []));
+}
+async function getSlimThreshold() {
+    return this.get("/v1/slim/threshold");
+}
+async function updateSlimThreshold(body) {
+    return (await this.put("/v1/slim/threshold", body));
+}
+async function getSlimPatientThreshold(patientId) {
+    return this.get(`/v1/slim/threshold/patient/${segment(patientId)}`);
+}
+async function updateSlimPatientThreshold(patientId, body) {
+    return (await this.put(`/v1/slim/threshold/patient/${segment(patientId)}`, body));
+}
+async function getSlimThresholdV2() {
+    return this.get("/v2/slim/threshold");
+}
+async function updateSlimThresholdV2(body) {
+    return (await this.put("/v2/slim/threshold", body));
+}
+async function getSlimPatientThresholdV2(patientId) {
+    return this.get(`/v2/slim/threshold/patient/${segment(patientId)}`);
+}
+async function updateSlimPatientThresholdV2(patientId, body) {
+    return (await this.put(`/v2/slim/threshold/patient/${segment(patientId)}`, body));
+}
+async function getSlimTrends(params) {
+    return this.get(`/v1/slim/trends/graphs${query(params)}`);
+}
+async function getSlimSleepStatistics(params) {
+    return this.get(`/v1/slim/sleep/statistics${query(params)}`);
+}
+async function listSlimLocations(params = {}) {
+    return this.get(`/v1/slim/location${query(params)}`);
+}
+async function getSlimLocation(locationId) {
+    return this.get(`/v1/slim/location/${segment(locationId)}`);
+}
+async function createSlimLocation(body) {
+    return this.post("/v1/slim/location", body);
+}
+async function updateSlimLocation(locationId, body) {
+    return (await this.put(`/v1/slim/location/${segment(locationId)}`, body));
+}
+async function deleteSlimLocation(locationId) {
+    await this.delete(`/v1/slim/location/${segment(locationId)}`);
+}
+async function listSlimZones(params = {}) {
+    return this.get(`/v1/slim/zones${query(params)}`);
+}
+async function getSlimZone(zoneId) {
+    return this.get(`/v1/slim/zones/${segment(zoneId)}`);
+}
+async function getSlimZoneDeviceCounts(params = {}) {
+    return this.get(`/v1/slim/zones/device-counts${query(params)}`);
+}
+async function exportSlimPatientPdf(body) {
+    return this.post("/v1/slim/export/pdf", body);
+}