@ovok/core 0.4.49-dev.495 → 0.4.49-dev.497

package/dist/next/resources/slim/slim-devices-resource.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimDevicesResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const url_1 = require("../../http/url");
+const numbered_pages_1 = require("../../paging/numbered-pages");
+const live_reads_1 = require("./live-reads");
+const slim_paths_1 = require("./slim-paths");
+const DEVICES_PATH = `${slim_paths_1.SLIM_PATH}/device`;
+const ASSIGN_TO_PROJECT_PATH = `${DEVICES_PATH}/assign/project`;
+const LIVE_PATH = `${DEVICES_PATH}/live`;
+const LIVE_TELEMETRY_PATH = `${LIVE_PATH}/telemetry`;
+const TELEMETRY_PATH = `${slim_paths_1.SLIM_PATH}/telemetry`;
+const EFFECTIVE_IDS = "effectiveIds";
+const LAST_IDS = "lastIds";
+const MIN_LIVE_COUNT = 1;
+const MAX_LIVE_COUNT = 100;
+const LIVE_COUNT_MESSAGE = `count must be an integer from ${MIN_LIVE_COUNT} to ${MAX_LIVE_COUNT}.`;
+const devicePath = (deviceId) => `${DEVICES_PATH}/${(0, url_1.pathSegment)(deviceId)}`;
+const telemetryPath = (deviceId) => `${TELEMETRY_PATH}/${(0, url_1.pathSegment)(deviceId)}`;
+class SlimDevicesResource {
+    constructor(http, session = null) {
+        this.http = http;
+        this.liveReads = new live_reads_1.LiveReads(http);
+        session === null || session === void 0 ? void 0 : session.onChange(() => this.liveReads.clear());
+    }
+    list(params = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), DEVICES_PATH, params);
+    }
+    retrieve(deviceId, options) {
+        return this.http.get(devicePath(deviceId), options);
+    }
+    /** 409 when another customer holds the serial; 422 when this project already uses it. */
+    create(body, options) {
+        return this.http.post(DEVICES_PATH, body, options);
+    }
+    /** Renaming moves the serial: live values return only after a reading under the new serial. */
+    update(deviceId, body, options) {
+        return this.http.put(devicePath(deviceId), body, options);
+    }
+    delete(deviceId, options) {
+        return this.http.delete(devicePath(deviceId), options);
+    }
+    assignToProject(body, options) {
+        return this.http.put(ASSIGN_TO_PROJECT_PATH, body, options);
+    }
+    live(params = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.readLive(path, params, options), LIVE_PATH, params);
+    }
+    liveTelemetry(params = {}, options) {
+        return this.readLive(`${LIVE_TELEMETRY_PATH}${(0, query_string_1.toQueryString)(params)}`, params, options);
+    }
+    telemetry(deviceId, options) {
+        return this.liveReads.get(telemetryPath(deviceId), options);
+    }
+    effectiveObservationIds(deviceId, options) {
+        return this.http.get(`${telemetryPath(deviceId)}/${EFFECTIVE_IDS}`, options);
+    }
+    effectiveObservationIdsByDevice(options) {
+        return this.http.get(`${TELEMETRY_PATH}/${EFFECTIVE_IDS}`, options);
+    }
+    lastObservationIds(deviceId, options) {
+        return this.http.get(`${telemetryPath(deviceId)}/${LAST_IDS}`, options);
+    }
+    lastObservationIdsByDevice(options) {
+        return this.http.get(`${TELEMETRY_PATH}/${LAST_IDS}`, options);
+    }
+    async readLive(path, params, options) {
+        requireLiveCount(params);
+        return this.liveReads.get(path, options);
+    }
+}
+exports.SlimDevicesResource = SlimDevicesResource;
+const isLiveCount = (count) => count === undefined || (Number.isInteger(count) && count >= MIN_LIVE_COUNT && count <= MAX_LIVE_COUNT);
+const requireLiveCount = ({ count }) => {
+    if (isLiveCount(count)) {
+        return;
+    }
+    throw new ovok_errors_1.OvokValidationError((0, ovok_errors_1.detailsFor)(LIVE_COUNT_MESSAGE));
+};

package/dist/next/resources/slim/slim-exports-resource.d.ts

@@ -0,0 +1,8 @@
+import type { SlimExportPdf, SlimExportPdfRequest } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SlimExportsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    patientPdf(body: SlimExportPdfRequest, options?: RequestOptions): Promise<SlimExportPdf>;
+}

package/dist/next/resources/slim/slim-exports-resource.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimExportsResource = void 0;
+const slim_paths_1 = require("./slim-paths");
+const PATIENT_PDF_PATH = `${slim_paths_1.SLIM_PATH}/export/pdf`;
+class SlimExportsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    patientPdf(body, options) {
+        return this.http.post(PATIENT_PDF_PATH, body, options);
+    }
+}
+exports.SlimExportsResource = SlimExportsResource;

package/dist/next/resources/slim/slim-locations-resource.d.ts

@@ -0,0 +1,14 @@
+import type { SlimCreateLocation, SlimLocation, SlimLocationQuery, SlimUpdateLocation } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+export declare class SlimLocationsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: SlimLocationQuery, options?: RequestOptions): PagePromise<SlimLocation>;
+    retrieve(locationId: string, options?: RequestOptions): Promise<SlimLocation>;
+    create(body: SlimCreateLocation, options?: RequestOptions): Promise<SlimLocation>;
+    /** A 422 "Device not found" means the requested device is unreadable and nothing was saved. */
+    update(locationId: string, body: SlimUpdateLocation, options?: RequestOptions): Promise<SlimLocation>;
+    delete(locationId: string, options?: RequestOptions): Promise<void>;
+}

package/dist/next/resources/slim/slim-locations-resource.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimLocationsResource = void 0;
+const url_1 = require("../../http/url");
+const numbered_pages_1 = require("../../paging/numbered-pages");
+const slim_paths_1 = require("./slim-paths");
+const LOCATIONS_PATH = `${slim_paths_1.SLIM_PATH}/location`;
+const locationPath = (locationId) => `${LOCATIONS_PATH}/${(0, url_1.pathSegment)(locationId)}`;
+class SlimLocationsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(params = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), LOCATIONS_PATH, params);
+    }
+    retrieve(locationId, options) {
+        return this.http.get(locationPath(locationId), options);
+    }
+    create(body, options) {
+        return this.http.post(LOCATIONS_PATH, body, options);
+    }
+    /** A 422 "Device not found" means the requested device is unreadable and nothing was saved. */
+    update(locationId, body, options) {
+        return this.http.put(locationPath(locationId), body, options);
+    }
+    delete(locationId, options) {
+        return this.http.delete(locationPath(locationId), options);
+    }
+}
+exports.SlimLocationsResource = SlimLocationsResource;

package/dist/next/resources/slim/slim-medical-notifications-resource.d.ts

@@ -0,0 +1,18 @@
+import type { SlimMedicalNotificationDetail, SlimMedicalNotificationRow, SlimMedicalNotificationsQuery } from "../../../client/notifications/types";
+import type { SlimRecentNotificationsResponse } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+import { SlimRecentQuery } from "./slim-queries";
+export declare class SlimMedicalNotificationsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** `params.cursor` is where the first page starts. */
+    list(params?: SlimMedicalNotificationsQuery, options?: RequestOptions): PagePromise<SlimMedicalNotificationRow>;
+    /** During a Signals outage this may answer the last good page from up to 10 minutes ago. */
+    recent(params?: SlimRecentQuery, options?: RequestOptions): Promise<SlimRecentNotificationsResponse>;
+    retrieve(episodeId: string, options?: RequestOptions): Promise<SlimMedicalNotificationDetail>;
+    /** Can take about 12 s; the server makes it safe to repeat, so a 503 is retried. */
+    acknowledge(episodeId: string, options?: RequestOptions): Promise<SlimMedicalNotificationRow>;
+    private page;
+}

package/dist/next/resources/slim/slim-medical-notifications-resource.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimMedicalNotificationsResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const url_1 = require("../../http/url");
+const cursor_pages_1 = require("../../paging/cursor-pages");
+const slim_paths_1 = require("./slim-paths");
+const MEDICAL_PATH = `${slim_paths_1.NOTIFICATIONS_PATH}/medical`;
+const RECENT_MEDICAL_PATH = `${slim_paths_1.RECENT_NOTIFICATIONS_PATH}/medical`;
+const MEDICAL_CODE = /^(?:\d{1,7}-\d|PI)$/;
+const MAX_MEDICAL_CODES = 32;
+const MEDICAL_CODES_MESSAGE = `codes must contain at most ${MAX_MEDICAL_CODES} valid LOINC codes or PI.`;
+const episodePath = (episodeId) => `${MEDICAL_PATH}/${(0, url_1.pathSegment)(episodeId)}`;
+class SlimMedicalNotificationsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    /** `params.cursor` is where the first page starts. */
+    list(params = {}, options) {
+        return (0, cursor_pages_1.cursorPages)((cursor) => this.page({ ...params, cursor: cursor !== null && cursor !== void 0 ? cursor : params.cursor }, options));
+    }
+    /** During a Signals outage this may answer the last good page from up to 10 minutes ago. */
+    recent(params = {}, options) {
+        return this.http.get(`${RECENT_MEDICAL_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    retrieve(episodeId, options) {
+        return this.http.get(episodePath(episodeId), options);
+    }
+    /** Can take about 12 s; the server makes it safe to repeat, so a 503 is retried. */
+    acknowledge(episodeId, options) {
+        return this.http.send({ method: "POST", path: `${episodePath(episodeId)}/ack`, idempotent: true }, options);
+    }
+    async page(params, options) {
+        requireMedicalCodes(params);
+        return this.http.get(`${MEDICAL_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+}
+exports.SlimMedicalNotificationsResource = SlimMedicalNotificationsResource;
+const isMedicalCodeList = (codes) => codes.length > 0 && codes.length <= MAX_MEDICAL_CODES && codes.every((code) => MEDICAL_CODE.test(code));
+const requireMedicalCodes = ({ codes }) => {
+    if (codes === undefined || isMedicalCodeList(codes)) {
+        return;
+    }
+    throw new ovok_errors_1.OvokValidationError((0, ovok_errors_1.detailsFor)(MEDICAL_CODES_MESSAGE));
+};

package/dist/next/resources/slim/slim-notification-notes-resource.d.ts

@@ -0,0 +1,12 @@
+import type { CreateNotificationNote, NotificationNote, NotificationNotes, NotificationTargetKind, UpdateNotificationNote } from "../../../client/notifications/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SlimNotificationNotesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(kind: NotificationTargetKind, targetId: string, options?: RequestOptions): Promise<NotificationNotes>;
+    create(body: CreateNotificationNote, options?: RequestOptions): Promise<NotificationNote>;
+    update(noteId: string, body: UpdateNotificationNote, options?: RequestOptions): Promise<NotificationNote>;
+    patch(noteId: string, body: UpdateNotificationNote, options?: RequestOptions): Promise<NotificationNote>;
+    delete(noteId: string, options?: RequestOptions): Promise<void>;
+}

package/dist/next/resources/slim/slim-notification-notes-resource.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimNotificationNotesResource = void 0;
+const url_1 = require("../../http/url");
+const slim_paths_1 = require("./slim-paths");
+const NOTES_PATH = `${slim_paths_1.NOTIFICATIONS_PATH}/notes`;
+const TARGET_SEGMENT = {
+    oob: "oob",
+    alarm: "alarms",
+    medical: "medical",
+    alert: "raw-alerts",
+};
+const notePath = (noteId) => `${NOTES_PATH}/${(0, url_1.pathSegment)(noteId)}`;
+class SlimNotificationNotesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(kind, targetId, options) {
+        return this.http.get(`${slim_paths_1.NOTIFICATIONS_PATH}/${TARGET_SEGMENT[kind]}/${(0, url_1.pathSegment)(targetId)}/notes`, options);
+    }
+    create(body, options) {
+        return this.http.post(NOTES_PATH, body, options);
+    }
+    update(noteId, body, options) {
+        return this.http.put(notePath(noteId), body, options);
+    }
+    patch(noteId, body, options) {
+        return this.http.patch(notePath(noteId), body, options);
+    }
+    delete(noteId, options) {
+        return this.http.delete(notePath(noteId), options);
+    }
+}
+exports.SlimNotificationNotesResource = SlimNotificationNotesResource;

package/dist/next/resources/slim/slim-notifications-resource.d.ts

@@ -0,0 +1,19 @@
+import type { SlimNotificationsQuery, SlimNotificationsResponse, SlimRecentNotificationsResponse } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { SlimAlarmsResource } from "./slim-alarms-resource";
+import { SlimMedicalNotificationsResource } from "./slim-medical-notifications-resource";
+import { SlimNotificationNotesResource } from "./slim-notification-notes-resource";
+import { SlimOutOfBedResource } from "./slim-out-of-bed-resource";
+import { SlimRecentQuery } from "./slim-queries";
+export declare class SlimNotificationsResource {
+    private readonly http;
+    readonly alarms: SlimAlarmsResource;
+    readonly outOfBed: SlimOutOfBedResource;
+    readonly medical: SlimMedicalNotificationsResource;
+    readonly notes: SlimNotificationNotesResource;
+    constructor(http: HttpClient);
+    /** @deprecated Use outOfBed.list, alarms.list or medical.list. */
+    list(params?: SlimNotificationsQuery, options?: RequestOptions): Promise<SlimNotificationsResponse>;
+    recent(params?: SlimRecentQuery, options?: RequestOptions): Promise<SlimRecentNotificationsResponse>;
+}

package/dist/next/resources/slim/slim-notifications-resource.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimNotificationsResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const slim_alarms_resource_1 = require("./slim-alarms-resource");
+const slim_medical_notifications_resource_1 = require("./slim-medical-notifications-resource");
+const slim_notification_notes_resource_1 = require("./slim-notification-notes-resource");
+const slim_out_of_bed_resource_1 = require("./slim-out-of-bed-resource");
+const slim_paths_1 = require("./slim-paths");
+class SlimNotificationsResource {
+    constructor(http) {
+        this.http = http;
+        this.alarms = new slim_alarms_resource_1.SlimAlarmsResource(http);
+        this.outOfBed = new slim_out_of_bed_resource_1.SlimOutOfBedResource(http);
+        this.medical = new slim_medical_notifications_resource_1.SlimMedicalNotificationsResource(http);
+        this.notes = new slim_notification_notes_resource_1.SlimNotificationNotesResource(http);
+    }
+    /** @deprecated Use outOfBed.list, alarms.list or medical.list. */
+    list(params = {}, options) {
+        return this.http.get(`${slim_paths_1.NOTIFICATIONS_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    recent(params = {}, options) {
+        return this.http.get(`${slim_paths_1.RECENT_NOTIFICATIONS_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+}
+exports.SlimNotificationsResource = SlimNotificationsResource;

package/dist/next/resources/slim/slim-organizations-resource.d.ts

@@ -0,0 +1,11 @@
+import type { SlimOrganization, SlimOrganizationInput } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SlimOrganizationsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    retrieve(organizationId: string, options?: RequestOptions): Promise<SlimOrganization>;
+    create(body: SlimOrganizationInput, options?: RequestOptions): Promise<SlimOrganization>;
+    update(organizationId: string, body: SlimOrganizationInput, options?: RequestOptions): Promise<SlimOrganization>;
+    delete(organizationId: string, options?: RequestOptions): Promise<void>;
+}

package/dist/next/resources/slim/slim-organizations-resource.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimOrganizationsResource = void 0;
+const url_1 = require("../../http/url");
+const slim_paths_1 = require("./slim-paths");
+const ORGANIZATIONS_PATH = `${slim_paths_1.SLIM_PATH}/organization`;
+const organizationPath = (organizationId) => `${ORGANIZATIONS_PATH}/${(0, url_1.pathSegment)(organizationId)}`;
+class SlimOrganizationsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(organizationId, options) {
+        return this.http.get(organizationPath(organizationId), options);
+    }
+    create(body, options) {
+        return this.http.post(ORGANIZATIONS_PATH, body, options);
+    }
+    update(organizationId, body, options) {
+        return this.http.put(organizationPath(organizationId), body, options);
+    }
+    delete(organizationId, options) {
+        return this.http.delete(organizationPath(organizationId), options);
+    }
+}
+exports.SlimOrganizationsResource = SlimOrganizationsResource;

package/dist/next/resources/slim/slim-out-of-bed-resource.d.ts

@@ -0,0 +1,13 @@
+import type { SlimRecentOutOfBed } from "../../../client/notifications/types";
+import type { SlimNotificationsQuery, SlimNotificationsResponse } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { SlimRecentQuery } from "./slim-queries";
+export type SlimOutOfBedQuery = Omit<SlimNotificationsQuery, "type">;
+export declare class SlimOutOfBedResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Omitting status lists new and reviewed rows. */
+    list(params?: SlimOutOfBedQuery, options?: RequestOptions): Promise<SlimNotificationsResponse>;
+    recent(params?: SlimRecentQuery, options?: RequestOptions): Promise<SlimRecentOutOfBed>;
+}

package/dist/next/resources/slim/slim-out-of-bed-resource.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimOutOfBedResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const slim_paths_1 = require("./slim-paths");
+const OUT_OF_BED_PATH = `${slim_paths_1.NOTIFICATIONS_PATH}/oob`;
+const RECENT_OUT_OF_BED_PATH = `${slim_paths_1.RECENT_NOTIFICATIONS_PATH}/oob`;
+class SlimOutOfBedResource {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Omitting status lists new and reviewed rows. */
+    list(params = {}, options) {
+        return this.http.get(`${OUT_OF_BED_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    recent(params = {}, options) {
+        return this.http.get(`${RECENT_OUT_OF_BED_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+}
+exports.SlimOutOfBedResource = SlimOutOfBedResource;

package/dist/next/resources/slim/slim-paths.d.ts

@@ -0,0 +1,6 @@
+export declare const SLIM_PATH = "v1/slim";
+export declare const SLIM_V2_PATH = "v2/slim";
+export declare const NOTIFICATIONS_PATH = "v1/slim/notifications";
+export declare const RECENT_NOTIFICATIONS_PATH = "v1/slim/notifications/recent";
+export declare const THRESHOLD_V2_PATH = "v2/slim/threshold";
+export declare const PROJECT_PATH = "v1/slim/project";

package/dist/next/resources/slim/slim-paths.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROJECT_PATH = exports.THRESHOLD_V2_PATH = exports.RECENT_NOTIFICATIONS_PATH = exports.NOTIFICATIONS_PATH = exports.SLIM_V2_PATH = exports.SLIM_PATH = void 0;
+exports.SLIM_PATH = "v1/slim";
+exports.SLIM_V2_PATH = "v2/slim";
+exports.NOTIFICATIONS_PATH = `${exports.SLIM_PATH}/notifications`;
+exports.RECENT_NOTIFICATIONS_PATH = `${exports.NOTIFICATIONS_PATH}/recent`;
+exports.THRESHOLD_V2_PATH = `${exports.SLIM_V2_PATH}/threshold`;
+exports.PROJECT_PATH = `${exports.SLIM_PATH}/project`;

package/dist/next/resources/slim/slim-patient-thresholds-resource.d.ts

@@ -0,0 +1,10 @@
+import type { SlimPatientThresholdV2, SlimThresholdV2Update } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SlimPatientThresholdsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    retrieve(patientId: string, options?: RequestOptions): Promise<SlimPatientThresholdV2>;
+    /** Never retried: a 409 means another save for this resident is running and nothing changed. */
+    update(patientId: string, body: SlimThresholdV2Update, options?: RequestOptions): Promise<SlimPatientThresholdV2>;
+}

package/dist/next/resources/slim/slim-patient-thresholds-resource.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimPatientThresholdsResource = void 0;
+const url_1 = require("../../http/url");
+const slim_paths_1 = require("./slim-paths");
+const PATIENT_THRESHOLDS_PATH = `${slim_paths_1.THRESHOLD_V2_PATH}/patient`;
+const patientThresholdPath = (patientId) => `${PATIENT_THRESHOLDS_PATH}/${(0, url_1.pathSegment)(patientId)}`;
+class SlimPatientThresholdsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(patientId, options) {
+        return this.http.get(patientThresholdPath(patientId), options);
+    }
+    /** Never retried: a 409 means another save for this resident is running and nothing changed. */
+    update(patientId, body, options) {
+        return this.http.send({ method: "PUT", path: patientThresholdPath(patientId), body, idempotent: false }, options);
+    }
+}
+exports.SlimPatientThresholdsResource = SlimPatientThresholdsResource;

package/dist/next/resources/slim/slim-patients-resource.d.ts

@@ -0,0 +1,20 @@
+import type { SlimCreatePatient, SlimPatient, SlimPatientListItem, SlimPatientListQuery, SlimUpdatePatient } from "../../../client/slim/types";
+import type { Bundle, Resource } from "@medplum/fhirtypes";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+import { SlimPatientThresholdsResource } from "./slim-patient-thresholds-resource";
+export declare class SlimPatientsResource {
+    private readonly http;
+    readonly thresholds: SlimPatientThresholdsResource;
+    constructor(http: HttpClient);
+    list(params?: SlimPatientListQuery, options?: RequestOptions): PagePromise<SlimPatientListItem>;
+    retrieve(patientId: string, options?: RequestOptions): Promise<SlimPatient>;
+    create(body: SlimCreatePatient, options?: RequestOptions): Promise<SlimPatient>;
+    /** Replaces the editable fields: omitting locationId unassigns the resident's devices. */
+    update(patientId: string, body: SlimUpdatePatient, options?: RequestOptions): Promise<SlimPatient>;
+    /** 409 while the resident has a device: unassign it first with an update that omits locationId. */
+    delete(patientId: string, options?: RequestOptions): Promise<void>;
+    everything(patientId: string, options?: RequestOptions): Promise<Bundle<Resource>>;
+    currentVitals(patientId: string, options?: RequestOptions): Promise<Record<string, unknown>>;
+}

package/dist/next/resources/slim/slim-patients-resource.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimPatientsResource = void 0;
+const url_1 = require("../../http/url");
+const numbered_pages_1 = require("../../paging/numbered-pages");
+const slim_paths_1 = require("./slim-paths");
+const slim_patient_thresholds_resource_1 = require("./slim-patient-thresholds-resource");
+const PATIENTS_PATH = `${slim_paths_1.SLIM_PATH}/patient`;
+const patientPath = (patientId) => `${PATIENTS_PATH}/${(0, url_1.pathSegment)(patientId)}`;
+class SlimPatientsResource {
+    constructor(http) {
+        this.http = http;
+        this.thresholds = new slim_patient_thresholds_resource_1.SlimPatientThresholdsResource(http);
+    }
+    list(params = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), PATIENTS_PATH, params);
+    }
+    retrieve(patientId, options) {
+        return this.http.get(patientPath(patientId), options);
+    }
+    create(body, options) {
+        return this.http.post(PATIENTS_PATH, body, options);
+    }
+    /** Replaces the editable fields: omitting locationId unassigns the resident's devices. */
+    update(patientId, body, options) {
+        return this.http.put(patientPath(patientId), body, options);
+    }
+    /** 409 while the resident has a device: unassign it first with an update that omits locationId. */
+    delete(patientId, options) {
+        return this.http.delete(patientPath(patientId), options);
+    }
+    everything(patientId, options) {
+        return this.http.get(`${patientPath(patientId)}/$everything`, options);
+    }
+    currentVitals(patientId, options) {
+        return this.http.get(`${patientPath(patientId)}/current-vitals`, options);
+    }
+}
+exports.SlimPatientsResource = SlimPatientsResource;

package/dist/next/resources/slim/slim-policies-resource.d.ts

@@ -0,0 +1,12 @@
+import type { SlimCreatePolicy, SlimPolicyList, SlimPolicyListQuery, SlimPolicyResponse, SlimUpdatePolicy } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SlimPoliciesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: SlimPolicyListQuery, options?: RequestOptions): Promise<SlimPolicyList>;
+    retrieve(policyId: string, options?: RequestOptions): Promise<SlimPolicyResponse>;
+    create(body: SlimCreatePolicy, options?: RequestOptions): Promise<SlimPolicyResponse>;
+    update(policyId: string, body: SlimUpdatePolicy, options?: RequestOptions): Promise<SlimPolicyResponse>;
+    delete(policyId: string, options?: RequestOptions): Promise<void>;
+}

package/dist/next/resources/slim/slim-policies-resource.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimPoliciesResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const url_1 = require("../../http/url");
+const slim_paths_1 = require("./slim-paths");
+const POLICIES_PATH = `${slim_paths_1.SLIM_PATH}/policy`;
+const policyPath = (policyId) => `${POLICIES_PATH}/${(0, url_1.pathSegment)(policyId)}`;
+class SlimPoliciesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(params = {}, options) {
+        return this.http.get(`${POLICIES_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    retrieve(policyId, options) {
+        return this.http.get(policyPath(policyId), options);
+    }
+    create(body, options) {
+        return this.http.post(POLICIES_PATH, body, options);
+    }
+    update(policyId, body, options) {
+        return this.http.put(policyPath(policyId), body, options);
+    }
+    delete(policyId, options) {
+        return this.http.delete(policyPath(policyId), options);
+    }
+}
+exports.SlimPoliciesResource = SlimPoliciesResource;

package/dist/next/resources/slim/slim-practitioners-resource.d.ts

@@ -0,0 +1,8 @@
+import type { SlimPractitionerInviteInput, SlimPractitionerInviteResponse } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SlimPractitionersResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    invite(body: SlimPractitionerInviteInput, options?: RequestOptions): Promise<SlimPractitionerInviteResponse>;
+}

package/dist/next/resources/slim/slim-practitioners-resource.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimPractitionersResource = void 0;
+const slim_paths_1 = require("./slim-paths");
+const INVITE_PRACTITIONER_PATH = `${slim_paths_1.SLIM_PATH}/invite/practitioner`;
+class SlimPractitionersResource {
+    constructor(http) {
+        this.http = http;
+    }
+    invite(body, options) {
+        return this.http.post(INVITE_PRACTITIONER_PATH, body, options);
+    }
+}
+exports.SlimPractitionersResource = SlimPractitionersResource;

package/dist/next/resources/slim/slim-projects-resource.d.ts

@@ -0,0 +1,16 @@
+import type { SlimChildProjectInput, SlimProject, SlimProjectDeviceCounts, SlimProjectPatientCounts, SlimProjectUser, SlimProjectUsersQuery } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+import { SlimChildProjectsResource } from "./slim-child-projects-resource";
+export declare class SlimProjectsResource {
+    private readonly http;
+    readonly children: SlimChildProjectsResource;
+    constructor(http: HttpClient);
+    retrieve(projectId: string, options?: RequestOptions): Promise<SlimProject>;
+    update(projectId: string, body: SlimChildProjectInput, options?: RequestOptions): Promise<SlimProject>;
+    users(projectId: string, params?: SlimProjectUsersQuery, options?: RequestOptions): PagePromise<SlimProjectUser>;
+    currentUsers(params?: SlimProjectUsersQuery, options?: RequestOptions): PagePromise<SlimProjectUser>;
+    deviceCounts(projectId: string, options?: RequestOptions): Promise<SlimProjectDeviceCounts>;
+    patientCounts(projectId: string, options?: RequestOptions): Promise<SlimProjectPatientCounts>;
+}

package/dist/next/resources/slim/slim-projects-resource.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimProjectsResource = void 0;
+const url_1 = require("../../http/url");
+const numbered_pages_1 = require("../../paging/numbered-pages");
+const slim_child_projects_resource_1 = require("./slim-child-projects-resource");
+const slim_paths_1 = require("./slim-paths");
+const USERS = "users";
+const CURRENT_USERS_PATH = `${slim_paths_1.PROJECT_PATH}/${USERS}`;
+const projectPath = (projectId) => `${slim_paths_1.PROJECT_PATH}/${(0, url_1.pathSegment)(projectId)}`;
+class SlimProjectsResource {
+    constructor(http) {
+        this.http = http;
+        this.children = new slim_child_projects_resource_1.SlimChildProjectsResource(http);
+    }
+    retrieve(projectId, options) {
+        return this.http.get(projectPath(projectId), options);
+    }
+    update(projectId, body, options) {
+        return this.http.put(projectPath(projectId), body, options);
+    }
+    users(projectId, params = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), `${projectPath(projectId)}/${USERS}`, params);
+    }
+    currentUsers(params = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), CURRENT_USERS_PATH, params);
+    }
+    deviceCounts(projectId, options) {
+        return this.http.get(`${projectPath(projectId)}/device-counts`, options);
+    }
+    patientCounts(projectId, options) {
+        return this.http.get(`${projectPath(projectId)}/patient-counts`, options);
+    }
+}
+exports.SlimProjectsResource = SlimProjectsResource;