@ovok/core 0.4.49-dev.494 → 0.4.49-dev.496

package/dist/next/resources/slim/live-reads.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveReads = void 0;
+const SIGNAL_OPTION = "signal";
+const ABORT_ERROR = "AbortError";
+const ABORTED_MESSAGE = "The request was aborted.";
+class SharedRead {
+    constructor(load, onDone) {
+        this.onDone = onDone;
+        this.controller = new AbortController();
+        this.subscribers = 0;
+        this.pending = true;
+        this.result = load(this.controller.signal).finally(() => this.finish());
+        this.result.catch(() => undefined);
+    }
+    join() {
+        this.subscribers += 1;
+    }
+    leave() {
+        this.subscribers -= 1;
+        const abandoned = this.pending && this.subscribers === 0;
+        if (abandoned) {
+            this.finish();
+            this.controller.abort();
+        }
+    }
+    finish() {
+        this.pending = false;
+        this.onDone();
+    }
+}
+/** Identical concurrent reads share one request, aborted only once every caller has aborted. */
+class LiveReads {
+    constructor(http) {
+        this.http = http;
+        this.inFlight = new Map();
+    }
+    get(path, options = {}) {
+        const shareable = Object.keys(options).every((key) => key === SIGNAL_OPTION);
+        return shareable ? this.share(path, options.signal) : this.http.get(path, options);
+    }
+    share(path, signal) {
+        var _a;
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            return Promise.reject(abortReason(signal));
+        }
+        return subscribe((_a = this.inFlight.get(path)) !== null && _a !== void 0 ? _a : this.start(path), signal);
+    }
+    start(path) {
+        const read = new SharedRead((signal) => this.http.get(path, { signal }), () => this.forget(path, read));
+        this.inFlight.set(path, read);
+        return read;
+    }
+    forget(path, read) {
+        if (this.inFlight.get(path) === read) {
+            this.inFlight.delete(path);
+        }
+    }
+}
+exports.LiveReads = LiveReads;
+const subscribe = (read, signal) => new Promise((resolve, reject) => {
+    let subscribed = true;
+    const settle = (finish) => {
+        if (subscribed) {
+            subscribed = false;
+            signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", onAbort);
+            read.leave();
+            finish();
+        }
+    };
+    const onAbort = () => settle(() => reject(abortReason(signal)));
+    read.join();
+    signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+    read.result.then((value) => settle(() => resolve(value)), (error) => settle(() => reject(error)));
+});
+const abortReason = (signal) => { var _a; return (_a = signal === null || signal === void 0 ? void 0 : signal.reason) !== null && _a !== void 0 ? _a : Object.assign(new Error(ABORTED_MESSAGE), { name: ABORT_ERROR }); };

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

@@ -0,0 +1,13 @@
+import type { SlimAlarmQuery, SlimAlarmsPage, SlimRecentAlarms } from "../../../client/notifications/types";
+import type { SlimNotification } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { SlimRecentQuery } from "./slim-queries";
+export declare class SlimAlarmsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: SlimAlarmQuery, options?: RequestOptions): Promise<SlimAlarmsPage>;
+    recent(params?: SlimRecentQuery, options?: RequestOptions): Promise<SlimRecentAlarms>;
+    /** Can take about 12 s; the server makes it safe to repeat, so a 503 is retried. */
+    acknowledge(notificationId: string, options?: RequestOptions): Promise<SlimNotification>;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimAlarmsResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const url_1 = require("../../http/url");
+const slim_paths_1 = require("./slim-paths");
+const ALARMS_PATH = `${slim_paths_1.NOTIFICATIONS_PATH}/alarms`;
+const RECENT_ALARMS_PATH = `${slim_paths_1.RECENT_NOTIFICATIONS_PATH}/alarms`;
+class SlimAlarmsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(params = {}, options) {
+        return this.http.get(`${ALARMS_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    recent(params = {}, options) {
+        return this.http.get(`${RECENT_ALARMS_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    /** Can take about 12 s; the server makes it safe to repeat, so a 503 is retried. */
+    acknowledge(notificationId, options) {
+        const path = `${slim_paths_1.NOTIFICATIONS_PATH}/${(0, url_1.pathSegment)(notificationId)}/ack`;
+        return this.http.send({ method: "PATCH", path, idempotent: true }, options);
+    }
+}
+exports.SlimAlarmsResource = SlimAlarmsResource;

package/dist/next/resources/slim/slim-change-history-resource.d.ts

@@ -0,0 +1,9 @@
+import type { ChangeHistoryQuery, ChangeHistoryRow } from "../../../client/change-history/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+export declare class SlimChangeHistoryResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(params?: ChangeHistoryQuery, options?: RequestOptions): PagePromise<ChangeHistoryRow>;
+}

package/dist/next/resources/slim/slim-change-history-resource.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimChangeHistoryResource = void 0;
+const url_1 = require("../../http/url");
+const numbered_pages_1 = require("../../paging/numbered-pages");
+const slim_paths_1 = require("./slim-paths");
+const CHANGE_HISTORY_PATH = `${slim_paths_1.SLIM_PATH}/change-history`;
+const TYPES_LIST_KEY = "types[]";
+class SlimChangeHistoryResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(params = {}, options) {
+        return (0, numbered_pages_1.numberedPages)((page) => this.http.get(`${CHANGE_HISTORY_PATH}${changeHistoryQuery({ ...params, page })}`, options), params.page);
+    }
+}
+exports.SlimChangeHistoryResource = SlimChangeHistoryResource;
+// The route reads `types[]` as a list; every other list repeats its own key.
+const changeHistoryQuery = ({ types, ...rest }) => (0, url_1.toSearchQuery)({ ...rest, [TYPES_LIST_KEY]: types });

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

@@ -0,0 +1,17 @@
+import type { SlimChildProjectInput, SlimProjectRelationshipsV2 } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export type SlimChildProjectCreated = {
+    projectId: string;
+    success: true;
+};
+export type SlimChildProjectDeleted = {
+    success: true;
+};
+export declare class SlimChildProjectsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(options?: RequestOptions): Promise<SlimProjectRelationshipsV2>;
+    create(body: SlimChildProjectInput, options?: RequestOptions): Promise<SlimChildProjectCreated>;
+    delete(subProjectId: string, options?: RequestOptions): Promise<SlimChildProjectDeleted>;
+}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlimChildProjectsResource = void 0;
+const url_1 = require("../../http/url");
+const slim_paths_1 = require("./slim-paths");
+const CHILD_PROJECTS_PATH = `${slim_paths_1.PROJECT_PATH}/child`;
+const CHILD_PROJECTS_V2_PATH = `${slim_paths_1.SLIM_V2_PATH}/project/child`;
+class SlimChildProjectsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(options) {
+        return this.http.get(CHILD_PROJECTS_V2_PATH, options);
+    }
+    create(body, options) {
+        return this.http.post(CHILD_PROJECTS_PATH, body, options);
+    }
+    delete(subProjectId, options) {
+        return this.http.delete(`${CHILD_PROJECTS_PATH}/${(0, url_1.pathSegment)(subProjectId)}`, options);
+    }
+}
+exports.SlimChildProjectsResource = SlimChildProjectsResource;

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

@@ -0,0 +1,28 @@
+import type { SlimAssignDevice, SlimCreateDevice, SlimDevice, SlimDeviceListItem, SlimDeviceListQuery, SlimDeviceTelemetry, SlimLiveQuery, SlimLiveTelemetry, SlimObservationIds, SlimUpdateDevice } from "../../../client/slim/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+export type SlimLiveDevice = Record<string, unknown>;
+export type SlimDeviceObservationIds = Omit<SlimObservationIds, "batch">;
+export type SlimObservationIdsByDevice = Record<string, SlimObservationIds>;
+export declare class SlimDevicesResource {
+    private readonly http;
+    private readonly liveReads;
+    constructor(http: HttpClient);
+    list(params?: SlimDeviceListQuery, options?: RequestOptions): PagePromise<SlimDeviceListItem>;
+    retrieve(deviceId: string, options?: RequestOptions): Promise<SlimDevice>;
+    /** 409 when another customer holds the serial; 422 when this project already uses it. */
+    create(body: SlimCreateDevice, options?: RequestOptions): Promise<SlimDevice>;
+    /** Renaming moves the serial: live values return only after a reading under the new serial. */
+    update(deviceId: string, body: SlimUpdateDevice, options?: RequestOptions): Promise<SlimDevice>;
+    delete(deviceId: string, options?: RequestOptions): Promise<void>;
+    assignToProject(body: SlimAssignDevice, options?: RequestOptions): Promise<SlimDevice>;
+    live(params?: SlimLiveQuery, options?: RequestOptions): PagePromise<SlimLiveDevice>;
+    liveTelemetry(params?: SlimLiveQuery, options?: RequestOptions): Promise<SlimLiveTelemetry>;
+    telemetry(deviceId: string, options?: RequestOptions): Promise<SlimDeviceTelemetry>;
+    effectiveObservationIds(deviceId: string, options?: RequestOptions): Promise<SlimDeviceObservationIds>;
+    effectiveObservationIdsByDevice(options?: RequestOptions): Promise<SlimObservationIdsByDevice>;
+    lastObservationIds(deviceId: string, options?: RequestOptions): Promise<SlimObservationIds>;
+    lastObservationIdsByDevice(options?: RequestOptions): Promise<SlimObservationIdsByDevice>;
+    private readLive;
+}

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

@@ -0,0 +1,80 @@
+"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) {
+        this.http = http;
+        this.liveReads = new live_reads_1.LiveReads(http);
+    }
+    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>;
+}