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

package/dist/next/resources/measurements/signed-in-account.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignedInAccount = void 0;
+const ovok_errors_1 = require("../../errors/ovok-errors");
+/** The account a measurement belongs to; a machine client has none. */
+class SignedInAccount {
+    constructor(session) {
+        this.session = session;
+    }
+    /** The project and profile signed in now, or null when no one is. */
+    async key() {
+        const session = await this.current();
+        return session === null ? null : `${session.project.reference}|${session.profile.reference}`;
+    }
+    async profileReference() {
+        const session = await this.current();
+        if (session === null) {
+            throw new ovok_errors_1.OvokValidationError((0, ovok_errors_1.detailsFor)("No user is signed in; name the patient instead."));
+        }
+        return session.profile.reference;
+    }
+    async current() {
+        return this.session === null ? null : this.session.current();
+    }
+}
+exports.SignedInAccount = SignedInAccount;

package/dist/next/resources/patient/fhir-records.d.ts

@@ -0,0 +1,19 @@
+import type { Appointment, ExtractResource, ResourceType } from "@medplum/fhirtypes";
+import { RequestOptions } from "../../http/transmit";
+import { QueryParams } from "../../http/url";
+import { FhirResource } from "../fhir-resource";
+/** Lists resolve to the first page's resources, as the Medplum client's `searchResources` did. */
+export declare class FhirListResource<K extends ResourceType> {
+    protected readonly fhir: FhirResource;
+    protected readonly type: K;
+    constructor(fhir: FhirResource, type: K);
+    list(params?: QueryParams, options?: RequestOptions): Promise<ExtractResource<K>[]>;
+}
+export declare class FhirRecordsResource<K extends ResourceType> extends FhirListResource<K> {
+    retrieve(id: string, options?: RequestOptions): Promise<ExtractResource<K>>;
+}
+export declare class AppointmentsResource extends FhirRecordsResource<"Appointment"> {
+    constructor(fhir: FhirResource);
+    create(appointment: Appointment, options?: RequestOptions): Promise<Appointment>;
+    update(id: string, appointment: Appointment, options?: RequestOptions): Promise<Appointment>;
+}

package/dist/next/resources/patient/fhir-records.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppointmentsResource = exports.FhirRecordsResource = exports.FhirListResource = void 0;
+/** Lists resolve to the first page's resources, as the Medplum client's `searchResources` did. */
+class FhirListResource {
+    constructor(fhir, type) {
+        this.fhir = fhir;
+        this.type = type;
+    }
+    async list(params = {}, options) {
+        const page = await this.fhir.search(this.type, params, options);
+        return page.data;
+    }
+}
+exports.FhirListResource = FhirListResource;
+class FhirRecordsResource extends FhirListResource {
+    retrieve(id, options) {
+        return this.fhir.read(this.type, id, options);
+    }
+}
+exports.FhirRecordsResource = FhirRecordsResource;
+class AppointmentsResource extends FhirRecordsResource {
+    constructor(fhir) {
+        super(fhir, "Appointment");
+    }
+    create(appointment, options) {
+        return this.fhir.create(appointment, options);
+    }
+    update(id, appointment, options) {
+        return this.fhir.update({ ...appointment, id }, options);
+    }
+}
+exports.AppointmentsResource = AppointmentsResource;

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

@@ -0,0 +1,21 @@
+import type { OvokPatientDashboard, OvokPatientDashboardQuery, OvokPatientLatestObservationsQuery, OvokPatientObservationBundle } from "../../../client/patient/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { FhirResource } from "../fhir-resource";
+import { AppointmentsResource, FhirListResource, FhirRecordsResource } from "./fhir-records";
+export declare class PatientResource {
+    private readonly http;
+    readonly appointments: AppointmentsResource;
+    readonly schedules: FhirListResource<"Schedule">;
+    readonly slots: FhirListResource<"Slot">;
+    readonly measurements: FhirRecordsResource<"Observation">;
+    readonly carePlans: FhirRecordsResource<"CarePlan">;
+    readonly questionnaires: FhirRecordsResource<"Questionnaire">;
+    readonly questionnaireResponses: FhirRecordsResource<"QuestionnaireResponse">;
+    readonly devices: FhirRecordsResource<"Device">;
+    readonly notifications: FhirRecordsResource<"CommunicationRequest">;
+    constructor(http: HttpClient, fhir: FhirResource);
+    latestObservations(params?: OvokPatientLatestObservationsQuery, options?: RequestOptions): Promise<OvokPatientObservationBundle>;
+    /** Every read is scoped to the signed-in patient unless its query names another. */
+    dashboard(params?: OvokPatientDashboardQuery, options?: RequestOptions): Promise<OvokPatientDashboard>;
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatientResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const auth_resource_1 = require("../auth-resource");
+const fhir_records_1 = require("./fhir-records");
+const LATEST_OBSERVATIONS_PATH = "fhir/Observation/$lastn";
+class PatientResource {
+    constructor(http, fhir) {
+        this.http = http;
+        this.appointments = new fhir_records_1.AppointmentsResource(fhir);
+        this.schedules = new fhir_records_1.FhirListResource(fhir, "Schedule");
+        this.slots = new fhir_records_1.FhirListResource(fhir, "Slot");
+        this.measurements = new fhir_records_1.FhirRecordsResource(fhir, "Observation");
+        this.carePlans = new fhir_records_1.FhirRecordsResource(fhir, "CarePlan");
+        this.questionnaires = new fhir_records_1.FhirRecordsResource(fhir, "Questionnaire");
+        this.questionnaireResponses = new fhir_records_1.FhirRecordsResource(fhir, "QuestionnaireResponse");
+        this.devices = new fhir_records_1.FhirRecordsResource(fhir, "Device");
+        this.notifications = new fhir_records_1.FhirRecordsResource(fhir, "CommunicationRequest");
+    }
+    latestObservations(params = {}, options) {
+        const { patient, max, code } = params;
+        return this.http.get(`${LATEST_OBSERVATIONS_PATH}${(0, query_string_1.toQueryString)({ patient, max, code })}`, options);
+    }
+    /** Every read is scoped to the signed-in patient unless its query names another. */
+    async dashboard(params = {}, options) {
+        const profile = await this.http.get(auth_resource_1.ME_PATH, options);
+        const patient = `Patient/${profile.profile.id}`;
+        const latestObservations = await this.latestObservations(withPatient(params.latestObservations, patient), options);
+        const [measurementHistory, carePlans] = await Promise.all([
+            this.measurements.list(withPatient(params.measurementHistory, patient), options),
+            this.carePlans.list(withPatient(params.carePlans, patient), options),
+        ]);
+        return { carePlans, latestObservations, measurementHistory, profile };
+    }
+}
+exports.PatientResource = PatientResource;
+const withPatient = (query, patient) => { var _a; return ({ ...query, patient: (_a = query === null || query === void 0 ? void 0 : query.patient) !== null && _a !== void 0 ? _a : patient }); };

package/dist/next/resources/projects/project-features-resource.d.ts

@@ -0,0 +1,9 @@
+import type { OvokProjectFeature, OvokProjectFeatures } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class ProjectFeaturesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    retrieve(options?: RequestOptions): Promise<OvokProjectFeatures>;
+    update(features: OvokProjectFeature[], options?: RequestOptions): Promise<OvokProjectFeatures>;
+}

package/dist/next/resources/projects/project-features-resource.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectFeaturesResource = void 0;
+const FEATURES_PATH = "v1/projects/me/features";
+class ProjectFeaturesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(options) {
+        return this.http.get(FEATURES_PATH, options);
+    }
+    update(features, options) {
+        const body = { features };
+        return this.http.patch(FEATURES_PATH, body, options);
+    }
+}
+exports.ProjectFeaturesResource = ProjectFeaturesResource;

package/dist/next/resources/projects/project-members-resource.d.ts

@@ -0,0 +1,19 @@
+import type { OvokInviteProjectMember, OvokProjectMember, OvokProjectMemberResponse, OvokRemoveProjectMemberResponse, OvokUpdateProjectMember } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+export type ProjectMemberListQuery = {
+    accessPolicyId?: string;
+    profileId?: string;
+    userId?: string;
+    page?: number;
+    count?: number;
+};
+export declare class ProjectMembersResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(query?: ProjectMemberListQuery, options?: RequestOptions): PagePromise<OvokProjectMember>;
+    invite(body: OvokInviteProjectMember, options?: RequestOptions): Promise<OvokProjectMemberResponse>;
+    update(membershipId: string, body: OvokUpdateProjectMember, options?: RequestOptions): Promise<OvokProjectMemberResponse>;
+    remove(membershipId: string, options?: RequestOptions): Promise<OvokRemoveProjectMemberResponse>;
+}

package/dist/next/resources/projects/project-members-resource.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectMembersResource = void 0;
+const url_1 = require("../../http/url");
+const numbered_pages_1 = require("../../paging/numbered-pages");
+const MEMBERS_PATH = "v1/projects/me/members";
+const memberPath = (membershipId) => `${MEMBERS_PATH}/${(0, url_1.pathSegment)(membershipId)}`;
+class ProjectMembersResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(query = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), MEMBERS_PATH, query);
+    }
+    invite(body, options) {
+        return this.http.post(MEMBERS_PATH, body, options);
+    }
+    update(membershipId, body, options) {
+        return this.http.patch(memberPath(membershipId), body, options);
+    }
+    remove(membershipId, options) {
+        return this.http.delete(memberPath(membershipId), options);
+    }
+}
+exports.ProjectMembersResource = ProjectMembersResource;

package/dist/next/resources/projects/project-settings-resource.d.ts

@@ -0,0 +1,10 @@
+import type { OvokProjectSettingKey, OvokProjectSettings, OvokProjectTextSettingKey } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class ProjectSettingsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    retrieve(options?: RequestOptions): Promise<OvokProjectSettings>;
+    update(key: OvokProjectSettingKey, enabled: boolean, options?: RequestOptions): Promise<OvokProjectSettings>;
+    updateText(key: OvokProjectTextSettingKey, value: string | null, options?: RequestOptions): Promise<OvokProjectSettings>;
+}

package/dist/next/resources/projects/project-settings-resource.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectSettingsResource = void 0;
+const url_1 = require("../../http/url");
+const SETTINGS_PATH = "v1/project/settings";
+const TEXT_SETTINGS_PATH = `${SETTINGS_PATH}/values`;
+class ProjectSettingsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    retrieve(options) {
+        return this.http.get(SETTINGS_PATH, options);
+    }
+    update(key, enabled, options) {
+        return this.http.put(`${SETTINGS_PATH}/${(0, url_1.pathSegment)(key)}`, { enabled }, options);
+    }
+    updateText(key, value, options) {
+        return this.http.put(`${TEXT_SETTINGS_PATH}/${(0, url_1.pathSegment)(key)}`, { value }, options);
+    }
+}
+exports.ProjectSettingsResource = ProjectSettingsResource;

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

@@ -0,0 +1,20 @@
+import type { OvokAdministeredProject } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+import { ProjectFeaturesResource } from "./project-features-resource";
+import { ProjectMembersResource } from "./project-members-resource";
+import { ProjectSettingsResource } from "./project-settings-resource";
+export type ProjectListQuery = {
+    page?: number;
+    count?: number;
+};
+export declare class ProjectsResource {
+    private readonly http;
+    readonly members: ProjectMembersResource;
+    readonly features: ProjectFeaturesResource;
+    readonly settings: ProjectSettingsResource;
+    constructor(http: HttpClient);
+    /** The projects the caller administers, wherever they are signed in. */
+    list(query?: ProjectListQuery, options?: RequestOptions): PagePromise<OvokAdministeredProject>;
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectsResource = void 0;
+const numbered_pages_1 = require("../../paging/numbered-pages");
+const project_features_resource_1 = require("./project-features-resource");
+const project_members_resource_1 = require("./project-members-resource");
+const project_settings_resource_1 = require("./project-settings-resource");
+const PROJECTS_PATH = "v1/projects";
+class ProjectsResource {
+    constructor(http) {
+        this.http = http;
+        this.members = new project_members_resource_1.ProjectMembersResource(http);
+        this.features = new project_features_resource_1.ProjectFeaturesResource(http);
+        this.settings = new project_settings_resource_1.ProjectSettingsResource(http);
+    }
+    /** The projects the caller administers, wherever they are signed in. */
+    list(query = {}, options) {
+        return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), PROJECTS_PATH, query);
+    }
+}
+exports.ProjectsResource = ProjectsResource;

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

@@ -0,0 +1,18 @@
+import type { Bundle, Observation, Parameters, QuestionnaireResponse } from "@medplum/fhirtypes";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { FhirResource } from "../fhir-resource";
+export declare class QuestionnairesResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    populate(questionnaireId: string, parameters?: Parameters, options?: RequestOptions): Promise<Parameters>;
+}
+export declare class QuestionnaireResponsesResource {
+    private readonly http;
+    private readonly fhir;
+    constructor(http: HttpClient, fhir: FhirResource);
+    submit(response: QuestionnaireResponse, options?: RequestOptions): Promise<Bundle>;
+    /** One transaction, so the response is never saved without its observations. */
+    submitWithObservations(response: QuestionnaireResponse, observations: Observation[], options?: RequestOptions): Promise<Bundle>;
+    extract(questionnaireResponseId: string, options?: RequestOptions): Promise<Parameters>;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionnaireResponsesResource = exports.QuestionnairesResource = void 0;
+const url_1 = require("../../http/url");
+class QuestionnairesResource {
+    constructor(http) {
+        this.http = http;
+    }
+    populate(questionnaireId, parameters = { resourceType: "Parameters", parameter: [] }, options) {
+        return this.http.post(`fhir/Questionnaire/${(0, url_1.pathSegment)(questionnaireId)}/$populate`, parameters, options);
+    }
+}
+exports.QuestionnairesResource = QuestionnairesResource;
+class QuestionnaireResponsesResource {
+    constructor(http, fhir) {
+        this.http = http;
+        this.fhir = fhir;
+    }
+    submit(response, options) {
+        return this.submitWithObservations(response, [], options);
+    }
+    /** One transaction, so the response is never saved without its observations. */
+    submitWithObservations(response, observations, options) {
+        const entry = [createEntry(response), ...observations.map(createEntry)];
+        return this.fhir.batch({ resourceType: "Bundle", type: "transaction", entry }, options);
+    }
+    extract(questionnaireResponseId, options) {
+        return this.http.post(`fhir/QuestionnaireResponse/${(0, url_1.pathSegment)(questionnaireResponseId)}/$extract`, {}, options);
+    }
+}
+exports.QuestionnaireResponsesResource = QuestionnaireResponsesResource;
+const createEntry = (resource) => ({
+    fullUrl: resource.id,
+    request: { method: "POST", url: resource.resourceType },
+    resource,
+});

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,12 @@
+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);
+    get<T>(path: string, options?: RequestOptions): Promise<T>;
+    private share;
+    private start;
+    private forget;
+}