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

package/dist/next/resources/session/saved-accounts-resource.d.ts

@@ -0,0 +1,13 @@
+import { SavedAccount } from "../../auth/saved-accounts-store";
+import { UserSession } from "../../auth/user-session";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SavedAccountsResource {
+    private readonly http;
+    private readonly session;
+    constructor(http: HttpClient, session: UserSession | null);
+    list(): Promise<SavedAccount[]>;
+    switch(accountId: string): Promise<void>;
+    remove(accountId: string, options?: RequestOptions): Promise<void>;
+    private userSession;
+}

package/dist/next/resources/session/saved-accounts-resource.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SavedAccountsResource = void 0;
+const ovok_account_error_1 = require("../../errors/ovok-account-error");
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const CURRENT_SESSION_PATH = "auth/session/current";
+class SavedAccountsResource {
+    constructor(http, session) {
+        this.http = http;
+        this.session = session;
+    }
+    list() {
+        return this.userSession().listSavedAccounts();
+    }
+    switch(accountId) {
+        return this.userSession().switchSavedAccount(accountId);
+    }
+    async remove(accountId, options) {
+        const session = this.userSession();
+        const account = await session.getSavedAccount(accountId);
+        if (account === null) {
+            throw new ovok_account_error_1.OvokAccountError("account_not_found");
+        }
+        if (!account.expired) {
+            const isolatedSession = session.forSavedAccount(account.session);
+            try {
+                await this.http.withCredentials(isolatedSession).delete(CURRENT_SESSION_PATH, options);
+            }
+            catch (error) {
+                if (!(error instanceof ovok_errors_1.OvokError && error.status === 401) && await isolatedSession.current() !== null) {
+                    throw error;
+                }
+            }
+        }
+        await session.removeSavedAccount(accountId);
+    }
+    userSession() {
+        if (this.session === null) {
+            throw new ovok_errors_1.OvokConfigError((0, ovok_errors_1.detailsFor)("Saved accounts need a user session."));
+        }
+        return this.session;
+    }
+}
+exports.SavedAccountsResource = SavedAccountsResource;

package/dist/next/resources/session/session-resource.d.ts

@@ -0,0 +1,11 @@
+import type { Session } from "../../auth/session";
+import type { SessionChangeListener, UserSession } from "../../auth/user-session";
+import { HttpClient } from "../../http/http-client";
+import { SavedAccountsResource } from "./saved-accounts-resource";
+export declare class SessionResource {
+    private readonly session;
+    readonly savedAccounts: SavedAccountsResource;
+    constructor(http: HttpClient, session: UserSession | null);
+    onChange(listener: SessionChangeListener): () => void;
+}
+export type { Session };

package/dist/next/resources/session/session-resource.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionResource = void 0;
+const saved_accounts_resource_1 = require("./saved-accounts-resource");
+class SessionResource {
+    constructor(http, session) {
+        this.session = session;
+        this.savedAccounts = new saved_accounts_resource_1.SavedAccountsResource(http, session);
+    }
+    onChange(listener) {
+        var _a, _b;
+        return (_b = (_a = this.session) === null || _a === void 0 ? void 0 : _a.onChange(listener)) !== null && _b !== void 0 ? _b : (() => undefined);
+    }
+}
+exports.SessionResource = SessionResource;

package/dist/next/resources/sharing/sharing-invites-resource.d.ts

@@ -0,0 +1,9 @@
+import type { CreatePatientSharingInvite, PatientSharingInvite, PatientSharingShare, RedeemPatientSharingInvite } from "../../../client/patient-sharing/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SharingInvitesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    create(body: CreatePatientSharingInvite, options?: RequestOptions): Promise<PatientSharingInvite>;
+    redeem(body: RedeemPatientSharingInvite, options?: RequestOptions): Promise<PatientSharingShare>;
+}

package/dist/next/resources/sharing/sharing-invites-resource.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharingInvitesResource = void 0;
+const INVITES_PATH = "v1/patient-sharing/invites";
+const REDEEM_PATH = `${INVITES_PATH}/redeem`;
+class SharingInvitesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    create(body, options) {
+        return this.http.post(INVITES_PATH, body, options);
+    }
+    redeem(body, options) {
+        return this.http.post(REDEEM_PATH, body, options);
+    }
+}
+exports.SharingInvitesResource = SharingInvitesResource;

package/dist/next/resources/sharing/sharing-resource.d.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from "../../http/http-client";
+import { SharingInvitesResource } from "./sharing-invites-resource";
+import { SharingSettingsResource } from "./sharing-settings-resource";
+import { SharingSharesResource } from "./sharing-shares-resource";
+export declare class SharingResource {
+    readonly invites: SharingInvitesResource;
+    readonly shares: SharingSharesResource;
+    readonly settings: SharingSettingsResource;
+    constructor(http: HttpClient);
+}

package/dist/next/resources/sharing/sharing-resource.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharingResource = void 0;
+const sharing_invites_resource_1 = require("./sharing-invites-resource");
+const sharing_settings_resource_1 = require("./sharing-settings-resource");
+const sharing_shares_resource_1 = require("./sharing-shares-resource");
+class SharingResource {
+    constructor(http) {
+        this.invites = new sharing_invites_resource_1.SharingInvitesResource(http);
+        this.shares = new sharing_shares_resource_1.SharingSharesResource(http);
+        this.settings = new sharing_settings_resource_1.SharingSettingsResource(http);
+    }
+}
+exports.SharingResource = SharingResource;

package/dist/next/resources/sharing/sharing-settings-resource.d.ts

@@ -0,0 +1,9 @@
+import type { PatientSharingSettings, PatientSharingSettingsUpdate } from "../../../client/patient-sharing/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SharingSettingsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    retrieve(options?: RequestOptions): Promise<PatientSharingSettings>;
+    update(settings: PatientSharingSettingsUpdate, options?: RequestOptions): Promise<PatientSharingSettings>;
+}

package/dist/next/resources/sharing/sharing-settings-resource.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharingSettingsResource = void 0;
+const SETTINGS_PATH = "v1/patient-sharing/settings";
+class SharingSettingsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(options) {
+        return this.http.get(SETTINGS_PATH, options);
+    }
+    update(settings, options) {
+        return this.http.put(SETTINGS_PATH, settings, options);
+    }
+}
+exports.SharingSettingsResource = SharingSettingsResource;

package/dist/next/resources/sharing/sharing-shares-resource.d.ts

@@ -0,0 +1,9 @@
+import type { PatientSharingShares } from "../../../client/patient-sharing/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class SharingSharesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(options?: RequestOptions): Promise<PatientSharingShares>;
+    revoke(consentId: string, options?: RequestOptions): Promise<void>;
+}

package/dist/next/resources/sharing/sharing-shares-resource.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharingSharesResource = void 0;
+const url_1 = require("../../http/url");
+const SHARES_PATH = "v1/patient-sharing/shares";
+// An older server leaves out the groups it predates.
+const withEveryGroup = (shares) => {
+    var _a, _b, _c;
+    return ({
+        ...shares,
+        practitioners: (_a = shares.practitioners) !== null && _a !== void 0 ? _a : [],
+        relatedPersons: (_b = shares.relatedPersons) !== null && _b !== void 0 ? _b : [],
+        received: (_c = shares.received) !== null && _c !== void 0 ? _c : [],
+    });
+};
+class SharingSharesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    async list(options) {
+        return withEveryGroup(await this.http.get(SHARES_PATH, options));
+    }
+    revoke(consentId, options) {
+        return this.http.delete(`${SHARES_PATH}/${(0, url_1.pathSegment)(consentId)}`, options);
+    }
+}
+exports.SharingSharesResource = SharingSharesResource;

package/dist/next/resources/signals/signals-gateway-resource.d.ts

@@ -0,0 +1,14 @@
+import { HttpClient, HttpMethod } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { QueryParams } from "../../http/url";
+export type SignalsGatewayRequest = {
+    method: HttpMethod;
+    path: readonly string[];
+    query?: QueryParams;
+    body?: unknown;
+};
+export declare class SignalsGatewayResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    request<T = unknown>(request: SignalsGatewayRequest, options?: RequestOptions): Promise<T>;
+}

package/dist/next/resources/signals/signals-gateway-resource.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalsGatewayResource = void 0;
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const url_1 = require("../../http/url");
+const GATEWAY_PATH = "v1/signals/api";
+const CONTROL_CHARACTER_RANGE_END = 0x1f;
+const DELETE_CHARACTER_CODE = 0x7f;
+class SignalsGatewayResource {
+    constructor(http) {
+        this.http = http;
+    }
+    request(request, options) {
+        var _a;
+        const path = pathFor(request.path);
+        const query = (0, url_1.toSearchQuery)((_a = request.query) !== null && _a !== void 0 ? _a : {});
+        return this.http.send({
+            method: request.method,
+            path: `${GATEWAY_PATH}/${path}${query}`,
+            body: request.body,
+        }, options);
+    }
+}
+exports.SignalsGatewayResource = SignalsGatewayResource;
+const pathFor = (segments) => {
+    if (!Array.isArray(segments) ||
+        segments.length === 0 ||
+        !segments.every((segment) => isSafePathSegment(segment))) {
+        throw new ovok_errors_1.OvokValidationError((0, ovok_errors_1.detailsFor)("Signals gateway paths need non-empty, safe path segments."));
+    }
+    return segments.map(encodePathSegment).join("/");
+};
+const isSafePathSegment = (segment) => typeof segment === "string" &&
+    segment.length > 0 &&
+    segment !== "." &&
+    segment !== ".." &&
+    !segment.includes("/") &&
+    !segment.includes("\\") &&
+    !Array.from(segment).some(isControlCharacter);
+const isControlCharacter = (character) => {
+    const code = character.charCodeAt(0);
+    return code <= CONTROL_CHARACTER_RANGE_END || code === DELETE_CHARACTER_CODE;
+};
+const encodePathSegment = (segment) => encodeURIComponent(segment).replace(/[!'()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`);

package/dist/next/resources/signals/signals-resource.d.ts

@@ -0,0 +1,13 @@
+import type { EnableSignalsResponse } from "../../../client/signals/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { SignalsGatewayResource } from "./signals-gateway-resource";
+import { UndeliverableResource } from "./undeliverable-resource";
+export declare class SignalsResource {
+    private readonly http;
+    readonly gateway: SignalsGatewayResource;
+    readonly undeliverable: UndeliverableResource;
+    constructor(http: HttpClient);
+    /** Idempotent: retry after 409 or 503. Readings saved through Ovok reach Signals without a second submit. */
+    enable(patientId: string, options?: RequestOptions): Promise<EnableSignalsResponse>;
+}

package/dist/next/resources/signals/signals-resource.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalsResource = void 0;
+const url_1 = require("../../http/url");
+const signals_gateway_resource_1 = require("./signals-gateway-resource");
+const undeliverable_resource_1 = require("./undeliverable-resource");
+const enableSignalsPath = (patientId) => `fhir/Patient/${(0, url_1.pathSegment)(patientId)}/$enable-signals`;
+class SignalsResource {
+    constructor(http) {
+        this.http = http;
+        this.gateway = new signals_gateway_resource_1.SignalsGatewayResource(http);
+        this.undeliverable = new undeliverable_resource_1.UndeliverableResource(http);
+    }
+    /** Idempotent: retry after 409 or 503. Readings saved through Ovok reach Signals without a second submit. */
+    enable(patientId, options) {
+        return this.http.post(enableSignalsPath(patientId), undefined, options);
+    }
+}
+exports.SignalsResource = SignalsResource;

package/dist/next/resources/signals/undeliverable-resource.d.ts

@@ -0,0 +1,26 @@
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export type SignalsUndeliverableResident = {
+    patientId: string;
+};
+export type SignalsUndeliverable = {
+    count: number;
+    residents: SignalsUndeliverableResident[];
+};
+export type SignalsDeliveryRepair = {
+    patientIds?: string[];
+};
+export type SignalsDeliveryRepairResult = {
+    attempted: number;
+    repaired: number;
+    stillUndeliverable: number;
+    skipped: number;
+    notReached: number;
+};
+export declare class UndeliverableResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(options?: RequestOptions): Promise<SignalsUndeliverable>;
+    /** Without `patientIds`, repairs the residents `list` shows. */
+    repair(request?: SignalsDeliveryRepair, options?: RequestOptions): Promise<SignalsDeliveryRepairResult>;
+}

package/dist/next/resources/signals/undeliverable-resource.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndeliverableResource = void 0;
+const UNDELIVERABLE_PATH = "signals/config/undeliverable";
+const REPAIR_PATH = `${UNDELIVERABLE_PATH}/repair`;
+class UndeliverableResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(options) {
+        return this.http.get(UNDELIVERABLE_PATH, options);
+    }
+    /** Without `patientIds`, repairs the residents `list` shows. */
+    repair(request = {}, options) {
+        return this.http.post(REPAIR_PATH, request, options);
+    }
+}
+exports.UndeliverableResource = UndeliverableResource;

package/dist/next/resources/slim/live-reads.d.ts

@@ -0,0 +1,13 @@
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+/** Identical concurrent reads share one request, aborted only once every caller has aborted. */
+export declare class LiveReads {
+    private readonly http;
+    private readonly inFlight;
+    constructor(http: HttpClient);
+    clear(): void;
+    get<T>(path: string, options?: RequestOptions): Promise<T>;
+    private share;
+    private start;
+    private forget;
+}

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

@@ -0,0 +1,87 @@
+"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.abort();
+        }
+    }
+    abort() {
+        this.finish();
+        this.controller.abort();
+    }
+    finish() {
+        if (!this.pending) {
+            return;
+        }
+        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();
+    }
+    clear() {
+        const reads = [...this.inFlight.values()];
+        this.inFlight.clear();
+        reads.forEach((read) => read.abort());
+    }
+    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,29 @@
+import type { SlimAssignDevice, SlimCreateDevice, SlimDevice, SlimDeviceListItem, SlimDeviceListQuery, SlimDeviceTelemetry, SlimLiveQuery, SlimLiveTelemetry, SlimObservationIds, SlimUpdateDevice } from "../../../client/slim/types";
+import type { UserSession } from "../../auth/user-session";
+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, session?: UserSession | null);
+    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;
+}