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

package/dist/next/http/http-client.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const credentials_1 = require("../auth/credentials");
+const error_from_response_1 = require("../errors/error-from-response");
+const ovok_errors_1 = require("../errors/ovok-errors");
+const retry_after_1 = require("./retry-after");
+const transmit_1 = require("./transmit");
+const url_1 = require("./url");
+const UNAUTHORIZED = 401;
+const JSON_TYPE = "application/json";
+class HttpClient {
+    constructor(context, basePath = "") {
+        this.context = context;
+        this.basePath = basePath;
+    }
+    under(path) {
+        return new HttpClient(this.context, (0, url_1.joinPath)(this.basePath, path));
+    }
+    anonymous() {
+        return new HttpClient({ ...this.context, credentials: credentials_1.noCredentials }, this.basePath);
+    }
+    withCredentials(credentials) {
+        return new HttpClient({ ...this.context, credentials }, this.basePath);
+    }
+    get(path, options) {
+        return this.send({ method: "GET", path }, options);
+    }
+    post(path, body, options) {
+        return this.send({ method: "POST", path, body }, options);
+    }
+    put(path, body, options) {
+        return this.send({ method: "PUT", path, body }, options);
+    }
+    patch(path, body, options) {
+        return this.send({ method: "PATCH", path, body }, options);
+    }
+    delete(path, options) {
+        return this.send({ method: "DELETE", path }, options);
+    }
+    async send(request, options = {}) {
+        const response = await this.sendAuthorized(request, options);
+        if (response.ok) {
+            return readJson(response);
+        }
+        throw await (0, error_from_response_1.errorFromResponse)(response);
+    }
+    async sendAuthorized(request, options) {
+        const response = await this.sendWithRetries(request, options);
+        const unauthorized = response.status === UNAUTHORIZED;
+        if (unauthorized && (await this.context.credentials.refresh())) {
+            return this.sendWithRetries(request, options);
+        }
+        return response;
+    }
+    async sendWithRetries(request, options) {
+        var _a, _b;
+        const { retryPolicy } = this.context;
+        for (let attempt = 0;; attempt += 1) {
+            const outcome = await this.attempt(request, options);
+            const retry = retryPolicy.allows(request, attempt) && this.isRetryable(outcome);
+            if (retry) {
+                await discard(outcome.response);
+                await retryPolicy.pause(attempt, (0, retry_after_1.retryAfterMs)((_b = (_a = outcome.response) === null || _a === void 0 ? void 0 : _a.headers.get("retry-after")) !== null && _b !== void 0 ? _b : null));
+                continue;
+            }
+            return unwrap(outcome);
+        }
+    }
+    async attempt(request, options) {
+        try {
+            const response = await (0, transmit_1.transmit)(this.context.settings, await this.toTransmit(request), options);
+            return { response };
+        }
+        catch (error) {
+            return { error };
+        }
+    }
+    isRetryable(outcome) {
+        return outcome.response
+            ? this.context.retryPolicy.isRetryableStatus(outcome.response.status)
+            : outcome.error instanceof ovok_errors_1.OvokConnectionError;
+    }
+    async toTransmit(request) {
+        const token = await this.context.credentials.accessToken();
+        const contentType = request.body === undefined ? {} : { "Content-Type": JSON_TYPE };
+        const authorization = token ? { Authorization: `Bearer ${token}` } : {};
+        return {
+            url: `${this.context.settings.baseUrl}${(0, url_1.joinPath)(this.basePath, request.path)}`,
+            method: request.method,
+            headers: { Accept: JSON_TYPE, ...contentType, ...request.headers, ...authorization },
+            body: encodeBody(request.body),
+        };
+    }
+}
+exports.HttpClient = HttpClient;
+const unwrap = (outcome) => {
+    if (outcome.response) {
+        return outcome.response;
+    }
+    throw outcome.error;
+};
+const discard = async (response) => {
+    var _a;
+    await ((_a = response === null || response === void 0 ? void 0 : response.body) === null || _a === void 0 ? void 0 : _a.cancel().catch(() => undefined));
+};
+const encodeBody = (body) => {
+    if (body === undefined) {
+        return undefined;
+    }
+    return typeof body === "string" ? body : JSON.stringify(body);
+};
+const readJson = async (response) => {
+    const text = await response.text();
+    return (text === "" ? undefined : JSON.parse(text));
+};

package/dist/next/http/retry-after.d.ts

@@ -0,0 +1 @@
+export declare const retryAfterMs: (header: string | null) => number | null;

package/dist/next/http/retry-after.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryAfterMs = void 0;
+const MS_PER_SECOND = 1000;
+const retryAfterMs = (header) => {
+    if (header === null) {
+        return null;
+    }
+    const seconds = Number(header);
+    if (Number.isFinite(seconds)) {
+        return seconds * MS_PER_SECOND;
+    }
+    const date = Date.parse(header);
+    return Number.isNaN(date) ? null : Math.max(0, date - Date.now());
+};
+exports.retryAfterMs = retryAfterMs;

package/dist/next/http/retry-policy.d.ts

@@ -0,0 +1,13 @@
+export type Sleep = (ms: number) => Promise<void>;
+export type RetryableRequest = {
+    method: string;
+    idempotent?: boolean;
+};
+export declare class RetryPolicy {
+    private readonly maxRetries;
+    private readonly wait;
+    constructor(maxRetries: number, wait?: Sleep);
+    allows(request: RetryableRequest, attempt: number): boolean;
+    isRetryableStatus(status: number): boolean;
+    pause(attempt: number, retryAfterMs: number | null): Promise<void>;
+}

package/dist/next/http/retry-policy.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryPolicy = void 0;
+const RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);
+const IDEMPOTENT_METHODS = new Set(["GET", "HEAD", "PUT", "DELETE"]);
+const BASE_DELAY_MS = 300;
+const MAX_DELAY_MS = 5000;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class RetryPolicy {
+    constructor(maxRetries, wait = sleep) {
+        this.maxRetries = maxRetries;
+        this.wait = wait;
+    }
+    allows(request, attempt) {
+        var _a;
+        const repeatable = (_a = request.idempotent) !== null && _a !== void 0 ? _a : IDEMPOTENT_METHODS.has(request.method);
+        return repeatable && attempt < this.maxRetries;
+    }
+    isRetryableStatus(status) {
+        return RETRYABLE_STATUSES.has(status);
+    }
+    pause(attempt, retryAfterMs) {
+        const backoffMs = BASE_DELAY_MS * 2 ** attempt;
+        return this.wait(Math.min(retryAfterMs !== null && retryAfterMs !== void 0 ? retryAfterMs : backoffMs, MAX_DELAY_MS));
+    }
+}
+exports.RetryPolicy = RetryPolicy;

package/dist/next/http/transmit.d.ts

@@ -0,0 +1,14 @@
+import { OvokSettings } from "../config/ovok-config";
+export type RequestOptions = {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+};
+export type TransmitRequest = {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: string | undefined;
+};
+type TransmitSettings = Pick<OvokSettings, "fetch" | "timeoutMs">;
+export declare function transmit(settings: TransmitSettings, request: TransmitRequest, options?: RequestOptions): Promise<Response>;
+export {};

package/dist/next/http/transmit.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transmit = transmit;
+const ovok_errors_1 = require("../errors/ovok-errors");
+async function transmit(settings, request, options = {}) {
+    var _a;
+    const deadline = new Deadline((_a = options.timeoutMs) !== null && _a !== void 0 ? _a : settings.timeoutMs, options.signal);
+    try {
+        return await settings.fetch(request.url, {
+            method: request.method,
+            headers: request.headers,
+            body: request.body,
+            signal: deadline.signal,
+        });
+    }
+    catch (error) {
+        throw deadline.explain(error);
+    }
+    finally {
+        deadline.clear();
+    }
+}
+class Deadline {
+    constructor(timeoutMs, callerSignal) {
+        this.timeoutMs = timeoutMs;
+        this.callerSignal = callerSignal;
+        this.controller = new AbortController();
+        this.followCaller = () => { var _a; return this.controller.abort((_a = this.callerSignal) === null || _a === void 0 ? void 0 : _a.reason); };
+        this.expired = false;
+        this.timer = setTimeout(() => this.expire(), timeoutMs);
+        callerSignal === null || callerSignal === void 0 ? void 0 : callerSignal.addEventListener("abort", this.followCaller, { once: true });
+        if (callerSignal === null || callerSignal === void 0 ? void 0 : callerSignal.aborted) {
+            this.followCaller();
+        }
+    }
+    get signal() {
+        return this.controller.signal;
+    }
+    /** A caller's own abort passes through untouched; everything else is a connection failure. */
+    explain(error) {
+        var _a, _b;
+        if ((_a = this.callerSignal) === null || _a === void 0 ? void 0 : _a.aborted) {
+            return (_b = this.callerSignal.reason) !== null && _b !== void 0 ? _b : error;
+        }
+        const message = this.expired ? `The request timed out after ${this.timeoutMs} ms.` : "Could not reach the Ovok API.";
+        return new ovok_errors_1.OvokConnectionError((0, ovok_errors_1.detailsFor)(message), error);
+    }
+    clear() {
+        var _a;
+        clearTimeout(this.timer);
+        (_a = this.callerSignal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", this.followCaller);
+    }
+    expire() {
+        this.expired = true;
+        this.controller.abort();
+    }
+}

package/dist/next/http/url.d.ts

@@ -0,0 +1,6 @@
+export type QueryValue = string | number | boolean | readonly string[] | undefined;
+export type QueryParams = Record<string, QueryValue>;
+export declare const joinPath: (...parts: string[]) => string;
+export declare const pathSegment: (value: string) => string;
+/** A list value repeats its key, so `date: ["ge1", "le2"]` is FHIR's AND; write "a,b" for OR. */
+export declare function toSearchQuery(params: QueryParams): string;

package/dist/next/http/url.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathSegment = exports.joinPath = void 0;
+exports.toSearchQuery = toSearchQuery;
+const joinPath = (...parts) => parts
+    .map((part) => part.replace(/^\/+|\/+$/g, ""))
+    .filter((part) => part !== "")
+    .join("/");
+exports.joinPath = joinPath;
+const pathSegment = (value) => encodeURIComponent(value);
+exports.pathSegment = pathSegment;
+/** A list value repeats its key, so `date: ["ge1", "le2"]` is FHIR's AND; write "a,b" for OR. */
+function toSearchQuery(params) {
+    const pairs = Object.entries(params).flatMap(([key, value]) => valuesOf(value).map((entry) => `${encodeURIComponent(key)}=${encodeURIComponent(entry)}`));
+    return pairs.length === 0 ? "" : `?${pairs.join("&")}`;
+}
+const valuesOf = (value) => {
+    if (value === undefined) {
+        return [];
+    }
+    return typeof value === "object" ? value.map(String) : [String(value)];
+};

package/dist/next/index.d.ts

@@ -0,0 +1,74 @@
+export { Ovok } from "./ovok";
+export type { OvokConfig, OvokFetch, OvokUnauthenticatedReason } from "./config/ovok-config";
+export { MemoryStorage } from "./storage/ovok-storage";
+export type { OvokStorage } from "./storage/ovok-storage";
+export { OvokAuthenticationError, OvokConfigError, OvokConflictError, OvokConnectionError, OvokError, OvokNotFoundError, OvokPermissionError, OvokRateLimitError, OvokServiceError, OvokValidationError, } from "./errors/ovok-errors";
+export { OvokAccountError } from "./errors/ovok-account-error";
+export type { OvokErrorDetails } from "./errors/ovok-errors";
+export type { RequestOptions } from "./http/transmit";
+export type { QueryParams, QueryValue } from "./http/url";
+export type { Page, PagePromise } from "./paging/page";
+export type { OvokReference, Session } from "./auth/session";
+export type { SavedAccount } from "./auth/saved-accounts-store";
+export type { SessionChangeListener } from "./auth/user-session";
+export type { LoginCredentials, LoginResult, MfaChallenge, ProfileType } from "./resources/auth-resource";
+export type { CreateOptions, PatchOperation } from "./resources/fhir-resource";
+export type { HealthCheck } from "./resources/health-resource";
+export type { PatientRegistration, PractitionerRegistration, RegisterResult } from "./resources/auth/registration";
+export type { SocialCredentials, SocialProvider } from "./resources/auth/social-login";
+export type { LastObservationsQuery, LatestObservationsParams, MeasurementCodeTypes, SaveObservationsOptions, SaveObservationsResult, } from "./resources/measurements/measurements-resource";
+export type { BuildObservationsParams } from "./resources/measurements/observation-builder";
+export type { SignalsDeliveryRepair, SignalsDeliveryRepairResult, SignalsUndeliverable, SignalsUndeliverableResident, } from "./resources/signals/undeliverable-resource";
+export type { ProjectListQuery } from "./resources/projects/projects-resource";
+export type { ProjectMemberListQuery } from "./resources/projects/project-members-resource";
+export type { LocalizationList } from "./resources/localization/localizations-resource";
+export type { PersonInviteFlow, RecordShareFlow } from "./resources/invites/invites-resource";
+export type { AiFhirSearchRequest } from "./resources/ai/ai-resource";
+export type { ChatSessionRetrieveParams } from "./resources/ai/chat-sessions-resource";
+export type { VideoCallAccessPermission } from "./resources/video-calls/video-call-access-resource";
+export type { ActiveCallNotification } from "./resources/video-calls/video-calls-resource";
+export type { CmsListParams, CmsReadParams } from "./resources/cms/cms-delivery";
+export type { DeletedDocument, DocumentDownloadParams } from "./resources/documents/documents-resource";
+export type { BotInput, BotOutput } from "./resources/bots/bots-resource";
+export type * from "./resources/slim/slim-queries";
+export type { AccountsResource } from "./resources/accounts/accounts-resource";
+export type { AiResource } from "./resources/ai/ai-resource";
+export type { AuthResource } from "./resources/auth-resource";
+export type { BotsResource } from "./resources/bots/bots-resource";
+export type { CmsResource } from "./resources/cms/cms-resource";
+export type { ConsentResource } from "./resources/consent/consent-resource";
+export type { ContentResource } from "./resources/content/content-resource";
+export type { DocumentsResource } from "./resources/documents/documents-resource";
+export type { EmailResource } from "./resources/email/email-resource";
+export type { FhirResource } from "./resources/fhir-resource";
+export type { HealthResource } from "./resources/health-resource";
+export type { InvitesResource } from "./resources/invites/invites-resource";
+export type { LocalesResource } from "./resources/localization/locales-resource";
+export type { LocalizationsResource } from "./resources/localization/localizations-resource";
+export type { MeasurementsResource } from "./resources/measurements/measurements-resource";
+export type { PatientResource } from "./resources/patient/patient-resource";
+export type { ProjectsResource } from "./resources/projects/projects-resource";
+export type { QuestionnaireResponsesResource, QuestionnairesResource, } from "./resources/questionnaires/questionnaires-resource";
+export type { SharingResource } from "./resources/sharing/sharing-resource";
+export type { SavedAccountsResource } from "./resources/session/saved-accounts-resource";
+export type { SessionResource } from "./resources/session/session-resource";
+export type { SignalsResource } from "./resources/signals/signals-resource";
+export type { SignalsGatewayRequest } from "./resources/signals/signals-gateway-resource";
+export type { SlimResource } from "./resources/slim/slim-resource";
+export type { VideoCallsResource } from "./resources/video-calls/video-calls-resource";
+export type { WearablesResource } from "./resources/wearables/wearables-resource";
+export * from "../types/MeasurementTypes";
+export type * from "../client/slim/types";
+export type * from "../client/notifications/types";
+export type * from "../client/change-history/types";
+export type * from "../client/experience/types";
+export type * from "../client/platform/types";
+export type * from "../client/consent/types";
+export type * from "../client/patient-sharing/types";
+export type * from "../client/invites/types";
+export type * from "../client/wearables/types";
+export type * from "../client/cms/types";
+export type * from "../client/email/types";
+export type * from "../client/patient/types";
+export type * from "../client/ai-fhir/types";
+export type { EnableSignalsResponse } from "../client/signals/types";

package/dist/next/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OvokAccountError = exports.OvokValidationError = exports.OvokServiceError = exports.OvokRateLimitError = exports.OvokPermissionError = exports.OvokNotFoundError = exports.OvokError = exports.OvokConnectionError = exports.OvokConflictError = exports.OvokConfigError = exports.OvokAuthenticationError = exports.MemoryStorage = exports.Ovok = void 0;
+var ovok_1 = require("./ovok");
+Object.defineProperty(exports, "Ovok", { enumerable: true, get: function () { return ovok_1.Ovok; } });
+var ovok_storage_1 = require("./storage/ovok-storage");
+Object.defineProperty(exports, "MemoryStorage", { enumerable: true, get: function () { return ovok_storage_1.MemoryStorage; } });
+var ovok_errors_1 = require("./errors/ovok-errors");
+Object.defineProperty(exports, "OvokAuthenticationError", { enumerable: true, get: function () { return ovok_errors_1.OvokAuthenticationError; } });
+Object.defineProperty(exports, "OvokConfigError", { enumerable: true, get: function () { return ovok_errors_1.OvokConfigError; } });
+Object.defineProperty(exports, "OvokConflictError", { enumerable: true, get: function () { return ovok_errors_1.OvokConflictError; } });
+Object.defineProperty(exports, "OvokConnectionError", { enumerable: true, get: function () { return ovok_errors_1.OvokConnectionError; } });
+Object.defineProperty(exports, "OvokError", { enumerable: true, get: function () { return ovok_errors_1.OvokError; } });
+Object.defineProperty(exports, "OvokNotFoundError", { enumerable: true, get: function () { return ovok_errors_1.OvokNotFoundError; } });
+Object.defineProperty(exports, "OvokPermissionError", { enumerable: true, get: function () { return ovok_errors_1.OvokPermissionError; } });
+Object.defineProperty(exports, "OvokRateLimitError", { enumerable: true, get: function () { return ovok_errors_1.OvokRateLimitError; } });
+Object.defineProperty(exports, "OvokServiceError", { enumerable: true, get: function () { return ovok_errors_1.OvokServiceError; } });
+Object.defineProperty(exports, "OvokValidationError", { enumerable: true, get: function () { return ovok_errors_1.OvokValidationError; } });
+var ovok_account_error_1 = require("./errors/ovok-account-error");
+Object.defineProperty(exports, "OvokAccountError", { enumerable: true, get: function () { return ovok_account_error_1.OvokAccountError; } });
+__exportStar(require("../types/MeasurementTypes"), exports);

package/dist/next/ovok.d.ts

@@ -0,0 +1,54 @@
+import { OvokConfig } from "./config/ovok-config";
+import { AccountsResource } from "./resources/accounts/accounts-resource";
+import { AiResource } from "./resources/ai/ai-resource";
+import { AuthResource } from "./resources/auth-resource";
+import { BotsResource } from "./resources/bots/bots-resource";
+import { CmsResource } from "./resources/cms/cms-resource";
+import { ConsentResource } from "./resources/consent/consent-resource";
+import { ContentResource } from "./resources/content/content-resource";
+import { DocumentsResource } from "./resources/documents/documents-resource";
+import { EmailResource } from "./resources/email/email-resource";
+import { FhirResource } from "./resources/fhir-resource";
+import { HealthResource } from "./resources/health-resource";
+import { InvitesResource } from "./resources/invites/invites-resource";
+import { LocalesResource } from "./resources/localization/locales-resource";
+import { LocalizationsResource } from "./resources/localization/localizations-resource";
+import { MeasurementsResource } from "./resources/measurements/measurements-resource";
+import { PatientResource } from "./resources/patient/patient-resource";
+import { ProjectsResource } from "./resources/projects/projects-resource";
+import { QuestionnaireResponsesResource, QuestionnairesResource } from "./resources/questionnaires/questionnaires-resource";
+import { SessionResource } from "./resources/session/session-resource";
+import { SharingResource } from "./resources/sharing/sharing-resource";
+import { SignalsResource } from "./resources/signals/signals-resource";
+import { SlimResource } from "./resources/slim/slim-resource";
+import { VideoCallsResource } from "./resources/video-calls/video-calls-resource";
+import { WearablesResource } from "./resources/wearables/wearables-resource";
+/** One client per tenant; each namespace mirrors an area of the Ovok API. */
+export declare class Ovok {
+    readonly auth: AuthResource;
+    readonly session: SessionResource;
+    readonly fhir: FhirResource;
+    readonly health: HealthResource;
+    readonly patient: PatientResource;
+    readonly measurements: MeasurementsResource;
+    readonly questionnaires: QuestionnairesResource;
+    readonly questionnaireResponses: QuestionnaireResponsesResource;
+    readonly consent: ConsentResource;
+    readonly invites: InvitesResource;
+    readonly sharing: SharingResource;
+    readonly signals: SignalsResource;
+    readonly slim: SlimResource;
+    readonly projects: ProjectsResource;
+    readonly accounts: AccountsResource;
+    readonly locales: LocalesResource;
+    readonly localizations: LocalizationsResource;
+    readonly cms: CmsResource;
+    readonly content: ContentResource;
+    readonly documents: DocumentsResource;
+    readonly videoCalls: VideoCallsResource;
+    readonly ai: AiResource;
+    readonly wearables: WearablesResource;
+    readonly email: EmailResource;
+    readonly bots: BotsResource;
+    constructor(config: OvokConfig);
+}

package/dist/next/ovok.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ovok = void 0;
+const client_credentials_1 = require("./auth/client-credentials");
+const saved_accounts_store_1 = require("./auth/saved-accounts-store");
+const session_store_1 = require("./auth/session-store");
+const token_endpoint_1 = require("./auth/token-endpoint");
+const user_session_1 = require("./auth/user-session");
+const settings_1 = require("./config/settings");
+const http_client_1 = require("./http/http-client");
+const retry_policy_1 = require("./http/retry-policy");
+const accounts_resource_1 = require("./resources/accounts/accounts-resource");
+const ai_resource_1 = require("./resources/ai/ai-resource");
+const auth_resource_1 = require("./resources/auth-resource");
+const bots_resource_1 = require("./resources/bots/bots-resource");
+const cms_resource_1 = require("./resources/cms/cms-resource");
+const consent_resource_1 = require("./resources/consent/consent-resource");
+const content_resource_1 = require("./resources/content/content-resource");
+const documents_resource_1 = require("./resources/documents/documents-resource");
+const email_resource_1 = require("./resources/email/email-resource");
+const fhir_resource_1 = require("./resources/fhir-resource");
+const health_resource_1 = require("./resources/health-resource");
+const invites_resource_1 = require("./resources/invites/invites-resource");
+const locales_resource_1 = require("./resources/localization/locales-resource");
+const localizations_resource_1 = require("./resources/localization/localizations-resource");
+const measurements_resource_1 = require("./resources/measurements/measurements-resource");
+const patient_resource_1 = require("./resources/patient/patient-resource");
+const projects_resource_1 = require("./resources/projects/projects-resource");
+const questionnaires_resource_1 = require("./resources/questionnaires/questionnaires-resource");
+const session_resource_1 = require("./resources/session/session-resource");
+const sharing_resource_1 = require("./resources/sharing/sharing-resource");
+const signals_resource_1 = require("./resources/signals/signals-resource");
+const slim_resource_1 = require("./resources/slim/slim-resource");
+const video_calls_resource_1 = require("./resources/video-calls/video-calls-resource");
+const wearables_resource_1 = require("./resources/wearables/wearables-resource");
+/** One client per tenant; each namespace mirrors an area of the Ovok API. */
+class Ovok {
+    constructor(config) {
+        const settings = (0, settings_1.readSettings)(config, (0, settings_1.currentEnvironment)());
+        const credentials = credentialsFor(settings);
+        const http = new http_client_1.HttpClient({ settings, credentials, retryPolicy: new retry_policy_1.RetryPolicy(settings.maxNetworkRetries) });
+        const session = credentials instanceof user_session_1.UserSession ? credentials : null;
+        const fhir = new fhir_resource_1.FhirResource(http.under(settings.fhirPath));
+        this.auth = new auth_resource_1.AuthResource(http, settings.tenantCode, session, settings.clientId);
+        this.session = new session_resource_1.SessionResource(http, session);
+        this.fhir = fhir;
+        this.health = new health_resource_1.HealthResource(http.anonymous());
+        this.patient = new patient_resource_1.PatientResource(http, fhir);
+        this.measurements = new measurements_resource_1.MeasurementsResource(http, fhir, session);
+        this.questionnaires = new questionnaires_resource_1.QuestionnairesResource(http);
+        this.questionnaireResponses = new questionnaires_resource_1.QuestionnaireResponsesResource(http, fhir);
+        this.consent = new consent_resource_1.ConsentResource(http);
+        this.invites = new invites_resource_1.InvitesResource(http, session);
+        this.sharing = new sharing_resource_1.SharingResource(http);
+        this.signals = new signals_resource_1.SignalsResource(http);
+        this.slim = new slim_resource_1.SlimResource(http, session);
+        this.projects = new projects_resource_1.ProjectsResource(http);
+        this.accounts = new accounts_resource_1.AccountsResource(http);
+        this.locales = new locales_resource_1.LocalesResource(http);
+        this.localizations = new localizations_resource_1.LocalizationsResource(http);
+        this.cms = new cms_resource_1.CmsResource(http, settings.tenantCode);
+        this.content = new content_resource_1.ContentResource(http);
+        this.documents = new documents_resource_1.DocumentsResource(http, settings.baseUrl);
+        this.videoCalls = new video_calls_resource_1.VideoCallsResource(http);
+        this.ai = new ai_resource_1.AiResource(http);
+        this.wearables = new wearables_resource_1.WearablesResource(http);
+        this.email = new email_resource_1.EmailResource(http);
+        this.bots = new bots_resource_1.BotsResource(http);
+    }
+}
+exports.Ovok = Ovok;
+const credentialsFor = (settings) => {
+    const tokenEndpoint = new token_endpoint_1.TokenEndpoint(settings);
+    return settings.machineClient
+        ? new client_credentials_1.ClientCredentials(tokenEndpoint, settings.machineClient)
+        : new user_session_1.UserSession((0, session_store_1.sessionStoreFor)(settings.storage, settings.tenantCode), tokenEndpoint, settings, Date.now, (0, saved_accounts_store_1.savedAccountsStoreFor)(settings.storage, settings.tenantCode));
+};

package/dist/next/paging/bundle-page.d.ts

@@ -0,0 +1,4 @@
+import type { Bundle, Resource } from "@medplum/fhirtypes";
+import { LoadedPage } from "./page";
+/** Follows the next link by its query only: Medplum writes its own host into the link, and Ovok is the only door. */
+export declare function bundlePage<T extends Resource>(bundle: Bundle<T>, loadNext: (query: string) => Promise<LoadedPage<T>>): LoadedPage<T>;

package/dist/next/paging/bundle-page.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundlePage = bundlePage;
+const NON_MATCH_SEARCH_MODES = new Set(["include", "outcome"]);
+/** Follows the next link by its query only: Medplum writes its own host into the link, and Ovok is the only door. */
+function bundlePage(bundle, loadNext) {
+    var _a, _b, _c;
+    const nextUrl = (_b = (_a = bundle.link) === null || _a === void 0 ? void 0 : _a.find((link) => link.relation === "next")) === null || _b === void 0 ? void 0 : _b.url;
+    return {
+        page: { data: matchesOf(bundle), hasMore: nextUrl !== undefined, total: (_c = bundle.total) !== null && _c !== void 0 ? _c : null },
+        next: nextUrl === undefined ? null : () => loadNext(queryOf(nextUrl)),
+    };
+}
+const matchesOf = (bundle) => {
+    var _a;
+    return ((_a = bundle.entry) !== null && _a !== void 0 ? _a : [])
+        .filter(isMatch)
+        .map((entry) => entry.resource)
+        .filter((resource) => resource !== undefined);
+};
+const isMatch = (entry) => { var _a, _b; return !NON_MATCH_SEARCH_MODES.has((_b = (_a = entry.search) === null || _a === void 0 ? void 0 : _a.mode) !== null && _b !== void 0 ? _b : "match"); };
+const queryOf = (url) => {
+    const start = url.indexOf("?");
+    return start === -1 ? "" : url.slice(start);
+};

package/dist/next/paging/cursor-pages.d.ts

@@ -0,0 +1,7 @@
+import { PagePromise } from "./page";
+/** Ovok's cursor list shape: pass `nextCursor` back unchanged for the next page. */
+export type CursorPage<T> = {
+    items: T[];
+    nextCursor: string | null;
+};
+export declare function cursorPages<T>(load: (cursor: string | undefined) => Promise<CursorPage<T>>): PagePromise<T>;

package/dist/next/paging/cursor-pages.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cursorPages = cursorPages;
+const page_1 = require("./page");
+function cursorPages(load) {
+    return (0, page_1.pagePromise)(() => loadCursor(load, undefined));
+}
+async function loadCursor(load, cursor) {
+    const { items, nextCursor } = await load(cursor);
+    return {
+        page: { data: items, hasMore: nextCursor !== null, total: null },
+        next: nextCursor === null ? null : () => loadCursor(load, nextCursor),
+    };
+}

package/dist/next/paging/numbered-pages.d.ts

@@ -0,0 +1,15 @@
+import { QueryValue } from "../http/url";
+import { PagePromise } from "./page";
+/** Ovok's page-numbered list shape: `page` is 0-based and `count` is the page size. */
+export type NumberedPage<T> = {
+    total: number;
+    page: number;
+    count: number;
+    resources: T[];
+};
+export declare function numberedPages<T>(load: (page: number) => Promise<NumberedPage<T>>, firstPage?: number): PagePromise<T>;
+export type NumberedPageQuery = Record<string, QueryValue> & {
+    page?: number;
+};
+/** Lists a page-numbered route with Ovok's query encoding; `query.page` is the first page loaded. */
+export declare const numberedRoutePages: <T>(read: (path: string) => Promise<NumberedPage<T>>, path: string, query: NumberedPageQuery) => PagePromise<T>;

package/dist/next/paging/numbered-pages.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberedRoutePages = void 0;
+exports.numberedPages = numberedPages;
+const query_string_1 = require("../../client/query-string");
+const page_1 = require("./page");
+function numberedPages(load, firstPage = 0) {
+    return (0, page_1.pagePromise)(() => loadNumbered(load, firstPage));
+}
+async function loadNumbered(load, page) {
+    const result = await load(page);
+    const hasMore = (result.page + 1) * result.count < result.total;
+    return {
+        page: { data: result.resources, hasMore, total: result.total },
+        next: hasMore ? () => loadNumbered(load, result.page + 1) : null,
+    };
+}
+/** Lists a page-numbered route with Ovok's query encoding; `query.page` is the first page loaded. */
+const numberedRoutePages = (read, path, query) => numberedPages((page) => read(`${path}${(0, query_string_1.toQueryString)({ ...query, page })}`), query.page);
+exports.numberedRoutePages = numberedRoutePages;

package/dist/next/paging/page.d.ts

@@ -0,0 +1,12 @@
+export type Page<T> = {
+    data: T[];
+    hasMore: boolean;
+    total: number | null;
+};
+/** Await it for the first page, or `for await` over it to walk every page. */
+export type PagePromise<T> = Promise<Page<T>> & AsyncIterable<T>;
+export type LoadedPage<T> = {
+    page: Page<T>;
+    next: (() => Promise<LoadedPage<T>>) | null;
+};
+export declare function pagePromise<T>(loadFirst: () => Promise<LoadedPage<T>>): PagePromise<T>;