@ovok/core 0.4.3 → 0.4.5

package/README.md

@@ -75,6 +75,57 @@ const features = await client.getProjectFeatures();
 const locales = await client.getLocales();
 ```
 
+The `values` property contains the six project text settings: `PATIENT_APP_URL`,
+`PRACTITIONER_APP_URL`, `PATIENT_SIGNUP_URL`, `CLINICIAN_DASHBOARD_URL`,
+`DEFAULT_PRACTITIONER_ACCESS_POLICY`, and `CLINICIAN_INVITE_ACCESS_POLICY`. Unset
+values are `null`. Set or clear one with `updateProjectTextSetting(key, value)`;
+pass `null` to clear it. `useUpdateProjectTextSetting()` exposes the same operation
+as a mutation. The `useProjectSettings()` request hook returns the current values.
+Mobile clients should configure `PATIENT_APP_URL` so password-reset and invite
+emails can link back to the patient app. Email links for each audience use that
+audience's configured app URL; they do not use a mobile request's `Origin` header.
+
+Any project practitioner can read settings; only a project admin can update text
+values. URL values are trimmed, limited to 2048 characters, and must use HTTPS
+(HTTP is allowed for localhost), an allowed origin, and no credentials, query,
+or fragment. Empty strings are invalid; pass `null` to clear a value. Access
+policies must be `AccessPolicy/<id>` references in the project. The older
+`PATIENT_SIGNUP_URL` and `CLINICIAN_DASHBOARD_URL` settings remain available as
+fallbacks; `PATIENT_SIGNUP_URL` can also be a full continuation link. For an
+audience's base URL, Core checks its project app URL, the parent project's app
+URL, the older setting, the request origin for self-service email only, then
+the configured environment fallback. It never uses a request origin to build a
+link for the other audience. An older Core server may omit `values` and return
+404 for the write route, so only rely on these methods after the matching Core
+release is deployed.
+The server can return `INVALID_SETTING_VALUE` (422), `APP_URL_NOT_ALLOWED`
+(400), or `UNKNOWN_SETTING` (400; the response lists accepted keys). A code-less
+409 means settings changed and the screen should reload before retrying. A 403
+means the caller is not a project admin. `readOvokError(error)` reads the status,
+code, user-facing message, and validation field errors from a Medplum error.
+`IOT_ENABLED` is not a supported project setting.
+
+The email-template catalog is available to authenticated project practitioners:
+
+```typescript
+const { data: templateCatalog, loading, error, reload } = useEmailTemplates();
+const templates = templateCatalog?.templates;
+```
+
+The equivalent client call is `client.getEmailTemplates()`, which reads
+`GET /v1/email/templates`. Each template includes its name, audience, parameter
+schema, full example, and provider syntax for SendGrid, Brevo, Resend, and SMTP.
+Use this catalog to explain template variables to administrators; it does not
+edit the project's email ConceptMap. Core validates the parameters when an email
+is sent. A send with invalid parameters is refused; SMTP uses strict Handlebars,
+Resend renders nulls as empty strings and lists as newline-delimited values.
+Every template also includes nullable `baseUrl`, `projectName`, and `tenantCode`
+params. The list can grow, so treat template names as strings. The older
+unversioned `/email/templates` route has a different response shape and is not
+used. An older server may return 404 until the matching Core release is
+deployed. The request requires a project practitioner (401 without a session,
+403 for a non-practitioner).
+
 All methods preserve the backend HTTP verbs and return the backend response shapes. Billing is
 not included until Ovok publishes a supported billing contract.
 
@@ -182,16 +233,59 @@ non-empty `reason`; the backend decides whether the caller has the required capa
 `shared` settings tenant is read-only. Signal errors are exposed as `SignalsError` values and can
 be checked with `isSignalsError`.
 
-Use `enableSignalsForPatient` to enroll an existing patient. It is idempotent and requires the caller to have
-`signals_config:update` and update access to that patient. A `signals_mint_failed` `SignalsError` is a retryable
-503. React applications can call `useEnableSignalsForPatient().mutate(patientId)`; the hook exposes the standard
-mutation `loading`, `error`, and `data` state.
+Use `enableSignalsForPatient` to enroll an existing patient. It is idempotent, always returns
+`enabled: true` on success, and requires the caller to have `signals_config:update` and update
+access to that patient. A 409 conflict and 503 failures (including `signals_mint_failed`) are
+retryable; use a bounded retry with backoff and do not retry other statuses automatically. The
+SDK maps backend responses to `SignalsError`; read the `code`, `status`, `fieldErrors`, and
+`message` properties rather than trying to infer a code from a reason phrase. React applications
+can call `useEnableSignalsForPatient().mutate(patientId)`; the hook exposes the standard mutation
+`loading`, `error`, and `data` state.
 
 `useSignalsAlerts` accumulates pages through `loadMore`. Check `hasMore` rather than the current
 item count: access filtering can produce a short or empty page with another cursor. Query changes
 and `reload` start again at the first page. The hook exposes `reload` so a screen can refresh its
 alert list after `useAcknowledgeSignalsAlert` succeeds.
 
+### Raw Signals alerts
+
+`listSignalsAlerts` reads episodes and needs the project's `episodicAlerts` (409
+`signals_episodes_disabled` otherwise). To work with individual alerts instead, whether or not
+`episodicAlerts` is on, use the raw alert methods:
+
+```ts
+const open = await client.listSignalsRawAlerts({
+  acknowledged: false,
+  codes: ["8867-4", "9279-1"],
+  since: "2026-10-01T00:00:00Z",
+  limit: 50,
+});
+const alert = await client.getSignalsRawAlert(open.items[0].id);
+const acked = await client.acknowledgeSignalsRawAlert(alert.id);
+// acked.acknowledgedAt and acked.acknowledgedActor record when and by whom.
+```
+
+Each `SignalsRawAlert` carries Signals' own `id`, `createdAt` and `resolvedAt`. `status` is Signals'
+state of the reading: `ACTIVE` while it breaches, `RESOLVED` once it recovered or the alert was
+acknowledged. An alert stays open for the practitioner until it is acknowledged, so list the
+worklist with `acknowledged: false` rather than `status: "ACTIVE"`. Acknowledging resolves the
+alert, and the next breaching reading opens a new one. It is idempotent: an acknowledged alert keeps
+its first `acknowledgedAt` and `acknowledgedActor`.
+
+Filters: `status`, `acknowledged`, `patientId` (a Medplum Patient id), `codes` (LOINC codes), and
+`since` (inclusive) and `until` (exclusive) on `createdAt`, as date-times with `Z` or an offset.
+Pages hold at most 50 alerts. As with episodes, a page can be short or empty and still have a
+`nextCursor`, because alerts of residents the caller can't read are left out; page until
+`nextCursor` is null, and pass it back unchanged: it is sealed to the project.
+
+Alerts raised before a project starts acknowledging are unacknowledged too, so a new worklist
+should bound its history with `since`. Each row also carries the breaching reading (`valueNumber`
+or `valueString`), the rule's `message` and the alert's `reason`. Acknowledging a raw alert does not
+acknowledge an episode: with `episodicAlerts` on, keep a screen to one of the two. Every request is scoped to the
+caller's project and the residents their access policy allows: an alert outside that scope answers
+404, and acknowledging needs `signals_alerts:update` and update access to the resident (403 when the
+caller can only read them).
+
 ## CareHub APIs
 
 CareHub methods cover the verified `/v1/slim/*` and `/v2/slim/*` application routes for
@@ -352,6 +446,129 @@ await client.register({ ...registerBody, continueAsPatientToken });
 The token is optional and is sent only when provided. An invalid or expired token is rejected
 with HTTP 400 and the message “The continue-as-patient link is invalid or has expired.”
 
+### Practitioner self-registration
+
+`registerPractitioner()` posts a new practitioner account to
+`POST /auth/tenant/Practitioner/register` and returns an `AuthResponse`. It checks
+`passwordConfirm` locally and never sends that confirmation field. Email is
+lowercased by Core and password must be 1–128 characters. The route is limited to
+five requests per minute, and validation failures return 422 field errors. The project
+must enable `PRACTITIONER_REGISTRATION_ENABLED` and configure a default
+practitioner access policy (prefer `DEFAULT_PRACTITIONER_ACCESS_POLICY`, falling
+back to `CLINICIAN_INVITE_ACCESS_POLICY`). Registration does not verify the
+email address and does not send an email; do not treat the address as verified.
+Core deliberately holds registration failures for at least a second, so a brief
+spinner while the request is pending is expected.
+
+```typescript
+const result = await client.registerPractitioner(registerBody);
+await client.setActiveLogin(result);
+```
+
+Both patient and practitioner registration intentionally return the same
+`400 Registration failed.` when an email already belongs to an account. Show a
+neutral form-level message with sign-in and password-reset links. Do not identify
+the email as taken or retry automatically. `isRegistrationFailed(error)` matches
+this exact response. The practitioner route can also return 403 when registration
+is disabled, 409 `practitioner_registration_not_configured` when no default
+policy is configured, 404 for an unknown tenant, 422 for invalid fields, and 429
+when its five-per-minute limit is reached. `readOvokError(error)` exposes the
+status/code/message and field errors for these responses.
+
+## Patient sharing and invitations
+
+Patient sharing settings are read and written through `getPatientSharingSettings()`
+and `updatePatientSharingSettings()`. The update always includes `enabled`; when
+changing only practitioner sharing, send the current `enabled` value too.
+`practitionerSharingEnabled` is a separate, off-by-default setting, not a
+`ProjectSettingKey`. It controls new practitioner invitations and acceptances;
+turning it off does not revoke existing shares. A project admin can toggle it
+through `PUT /v1/patient-sharing/settings`; concurrent settings changes return
+409 and should be reloaded, and non-admins receive 403. Do not enable it for a project
+whose practitioners use the Carehub dashboard. Map the email templates
+`PATIENT_INVITE`, `PATIENT_ASSIGNMENT_REQUEST`,
+`PRACTITIONER_INVITED_BY_PATIENT`, and `PRACTITIONER_PATIENT_SHARED` before
+turning the feature on; an unmapped email can still produce the uniform 202
+response without sending a message. `useUpdatePatientSharingSettings()` is the
+corresponding mutation hook.
+
+`listPatientSharing()` returns `outgoing`, `incoming`, and `practitioners`;
+the latter lists active shares of a patient's whole record with practitioners.
+For compatibility with older servers, the SDK defaults a missing `practitioners`
+array to `[]`. Listing is patient-only (403 for another profile).
+`revokePatientSharing(consentId)` uses the existing DELETE route
+to end a share immediately or decline a pending invite. It returns 204; 404
+(`Share not found.`) means the caller is not a party, and a code-less 409
+(`This share kept changing; try again.`) can be retried after reloading. A
+practitioner's whole-record share has no measurement-code list.
+
+Invitations use four client methods, all backed by `/v1/invites/*`:
+
+```typescript
+await client.invitePractitioner({ email, firstName, lastName }); // patient invites practitioner
+await client.invitePatient({ email, firstName, lastName }); // practitioner invites patient
+await client.acceptPractitionerInvite({ inviteId, code });
+await client.acceptPatientInvite({ inviteId, code });
+
+// Or dispatch acceptance using the signed-in profile:
+await client.acceptInvite({ inviteId, code });
+```
+
+`useInvitePractitioner()`, `useInvitePatient()`, and `useAcceptInvite()` provide
+React mutation states. The invite methods always return `{ status: "sent" }`
+(HTTP 202), whether or not an email is ultimately sent. Show only “If that
+address can be invited, an email is on its way”; the response must not reveal
+whether the address has an account. Both names are trimmed by Core, and email
+addresses are normalized there. A new address receives an account and a
+set-password link; an existing account receives an accept link. If sending the
+email fails, Core rolls back the invite. Email is limited to 254 characters;
+the trimmed first and last names must each be 1–200 characters.
+
+The project must enable `PRACTITIONER_SHARING_ENABLED` and the invitee's
+`PATIENT_INVITATION_ENABLED` or `PRACTITIONER_INVITATION_ENABLED` setting. An
+invite can also fail with 401 (no session), 403 (feature/role gate), 422 (invalid
+body), 409 `invitation_not_configured` (missing default policy),
+`app_url_not_configured` (missing audience app URL), or
+`practitioner_without_access_policy` (a full-access practitioner cannot be
+narrowed to a share policy). A code-less 409 means another invite for the same
+address or practitioner is still being written; offer retry. A 429 means the
+inviter has 20 pending invites. Use
+`readOvokError(error)` and `OVOK_INVITE_ERROR_CODES` to branch on stable codes.
+
+### Accept-invite page
+
+Every app that can receive invitations needs a page at
+`<app URL>/accept-invite?invite=<uuid>&code=<secret>`. Practitioner links use
+`PRACTITIONER_APP_URL`; patient links use `PATIENT_APP_URL`. The secret is valid
+for seven days. `parseAcceptInviteLink(url)` returns a body only when the UUID and
+16–128 character code are present and valid; otherwise show “This link is
+incomplete” and make no request. Once parsed, remove the code from the address
+bar/history and do not send it to logs or analytics.
+
+If the visitor is signed out, send them through sign-in and restore the link on
+return. There is no preview endpoint. Once signed in, call `acceptInvite()`; it
+chooses the route from the `Patient` or `Practitioner` profile and rejects other
+profile types. Never accept on page load. For a patient accepting, explain that
+their whole record will be shared and wait for an explicit Accept action. A
+patient can decline with `revokePatientSharing(inviteId)`; practitioners have no
+decline route and can ignore the link. After a successful acceptance, show who
+shares with whom (use a generic name when either is null), provide a way into the
+app, and refresh `/auth/me` because practitioner access may have changed.
+
+Render accept failures without attempting to distinguish private cases:
+
+- 404 `Invite not found.` means an unknown id, bad code, or invite for another
+  account. Say the invite is not for the signed-in account and offer sign-out.
+- 409 `This invite was already used.` means accepted or cancelled; the other
+  code-less 409 (`This invite kept changing; try again.`) can be retried.
+- 410 means expired; ask the sender for a new invite.
+- 409 `The patient who shared their record is no longer a member of this
+  project.`, `The practitioner who invited you is no longer a member of this
+  project.`, or `More than one account in this project acts as that practitioner.`
+  cannot be accepted; ask the sender to resolve it.
+- 401 requires sign-in; 403 means the wrong account type or a disabled gate;
+  422 means the link values are invalid.
+
 ## Large measurements
 
 `saveMeasurement` and `saveObservations` use conditional creates for idempotent saves. Medplum

package/dist/client/auth/errors.d.ts

@@ -0,0 +1,3 @@
+export declare const REGISTRATION_FAILED_MESSAGE = "Registration failed.";
+/** Returns true when signup was refused because the address already has an account. */
+export declare function isRegistrationFailed(error: unknown): boolean;

package/dist/client/auth/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGISTRATION_FAILED_MESSAGE = void 0;
+exports.isRegistrationFailed = isRegistrationFailed;
+const ovok_error_1 = require("../errors/ovok-error");
+exports.REGISTRATION_FAILED_MESSAGE = "Registration failed.";
+/** Returns true when signup was refused because the address already has an account. */
+function isRegistrationFailed(error) {
+    const details = (0, ovok_error_1.readOvokError)(error);
+    return details.status === 400 && details.message === exports.REGISTRATION_FAILED_MESSAGE;
+}

package/dist/client/auth/methods/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./login";
 export * from "./register";
+export * from "./registerPractitioner";
 export * from "./refetchProfile";
 export * from "./changePassword";
 export * from "./requestDeleteUser";

package/dist/client/auth/methods/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./login"), exports);
 __exportStar(require("./register"), exports);
+__exportStar(require("./registerPractitioner"), exports);
 __exportStar(require("./refetchProfile"), exports);
 __exportStar(require("./changePassword"), exports);
 __exportStar(require("./requestDeleteUser"), exports);

package/dist/client/auth/methods/registerPractitioner.d.ts

@@ -0,0 +1,4 @@
+import { OvokClient } from "../../ovok-client";
+import { AuthResponse } from "../types/AuthResponse";
+import { RegisterPractitionerBody } from "../types/RegisterPractitionerBody";
+export declare function registerPractitioner(this: OvokClient, body: RegisterPractitionerBody): Promise<AuthResponse>;

package/dist/client/auth/methods/registerPractitioner.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPractitioner = registerPractitioner;
+async function registerPractitioner(body) {
+    if (body.password !== body.passwordConfirm) {
+        throw new Error("Password and password confirm do not match");
+    }
+    return this.post("auth/tenant/Practitioner/register", {
+        email: body.email,
+        password: body.password,
+        name: body.name,
+        surname: body.surname,
+        tenantCode: body.tenantCode,
+    }, "application/json");
+}

package/dist/client/auth/types/RegisterPractitionerBody.d.ts

@@ -0,0 +1,2 @@
+import { RegisterBody } from "./RegisterBody";
+export type RegisterPractitionerBody = Omit<RegisterBody, "continueAsPatientToken">;

package/dist/client/auth/types/RegisterPractitionerBody.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/client/email/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./methods";
+export * from "./types";

package/dist/client/email/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./methods"), exports);
+__exportStar(require("./types"), exports);

package/dist/client/email/methods.d.ts

@@ -0,0 +1,3 @@
+import { OvokClient } from "../ovok-client";
+import { OvokEmailTemplates } from "./types";
+export declare function getEmailTemplates(this: OvokClient): Promise<OvokEmailTemplates>;

package/dist/client/email/methods.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmailTemplates = getEmailTemplates;
+function getEmailTemplates() {
+    return this.get("/v1/email/templates");
+}

package/dist/client/email/types.d.ts

@@ -0,0 +1,21 @@
+export type OvokEmailAudience = "patient" | "practitioner";
+export type OvokEmailTemplateParam = {
+    name: string;
+    type: string;
+    nullable: boolean;
+};
+export type OvokEmailTemplate = {
+    name: string;
+    audience: OvokEmailAudience;
+    params: OvokEmailTemplateParam[];
+    example: Record<string, unknown>;
+    syntax: {
+        sendgrid: string;
+        brevo: string;
+        resend: string;
+        smtp: string;
+    };
+};
+export type OvokEmailTemplates = {
+    templates: OvokEmailTemplate[];
+};

package/dist/client/email/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/client/errors/ovok-error.d.ts

@@ -3,5 +3,11 @@ export type ParsedOvokError = {
     message: string;
     fieldErrors: ValidationError[];
 };
+export type OvokErrorDetails = ParsedOvokError & {
+    status: number | undefined;
+    code: string | undefined;
+};
+/** Reads the error details Medplum preserves from Ovok's non-FHIR responses. */
+export declare const readOvokError: (error: unknown) => OvokErrorDetails;
 /** Normalizes Ovok's Nest and FHIR error envelopes without exposing transport details. */
 export declare const parseOvokError: (error: unknown) => ParsedOvokError;

package/dist/client/errors/ovok-error.js

@@ -1,34 +1,166 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOvokError = void 0;
-const isValidationError = (value) => !!value &&
-    typeof value === "object" &&
-    typeof value.code === "string" &&
-    typeof value.message === "string" &&
-    Array.isArray(value.path);
+exports.parseOvokError = exports.readOvokError = void 0;
+const STATUS_BY_BARE_CODE = {
+    INVALID_SETTING_VALUE: 422,
+    APP_URL_NOT_ALLOWED: 400,
+    UNKNOWN_SETTING: 400,
+    app_url_not_configured: 409,
+};
+const HTTP_REASON_PHRASES = new Set([
+    "bad request",
+    "unauthorized",
+    "forbidden",
+    "not found",
+    "conflict",
+    "too many requests",
+    "internal server error",
+    "service unavailable",
+]);
 const asRecord = (value) => value && typeof value === "object" ? value : undefined;
-/** Normalizes Ovok's Nest and FHIR error envelopes without exposing transport details. */
-const parseOvokError = (error) => {
-    var _a, _b;
-    const parsed = typeof error === "string"
-        ? (() => {
-            try {
-                return JSON.parse(error);
-            }
-            catch (_a) {
-                return undefined;
-            }
-        })()
-        : error;
-    const root = (_a = asRecord(parsed)) !== null && _a !== void 0 ? _a : {};
-    const nested = (_b = asRecord(root.error)) !== null && _b !== void 0 ? _b : root;
-    const rawErrors = nested.errors;
-    const fieldErrors = Array.isArray(rawErrors) ? rawErrors.filter(isValidationError) : [];
+/** Reads the error details Medplum preserves from Ovok's non-FHIR responses. */
+const readOvokError = (error) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+    const root = asRecord(error);
+    const response = asRecord(root === null || root === void 0 ? void 0 : root.response);
+    const messagePayload = error instanceof Error
+        ? parseJson(error.message)
+        : parseJson(error);
+    const payload = (_f = (_e = (_d = (_c = (_b = (_a = asRecord(messagePayload)) !== null && _a !== void 0 ? _a : asRecord(root === null || root === void 0 ? void 0 : root.body)) !== null && _b !== void 0 ? _b : asRecord(root === null || root === void 0 ? void 0 : root.data)) !== null && _c !== void 0 ? _c : asRecord(response === null || response === void 0 ? void 0 : response.data)) !== null && _d !== void 0 ? _d : asRecord(response === null || response === void 0 ? void 0 : response.body)) !== null && _e !== void 0 ? _e : asRecord(root === null || root === void 0 ? void 0 : root.outcome)) !== null && _f !== void 0 ? _f : root;
+    const nestedError = asRecord(payload === null || payload === void 0 ? void 0 : payload.error);
+    const bareMessage = typeof error === "string"
+        ? error
+        : error instanceof Error
+            ? error.message
+            : undefined;
+    const bareCode = bareMessage && /^[A-Za-z][A-Za-z0-9_]*$/.test(bareMessage)
+        && !HTTP_REASON_PHRASES.has(bareMessage.toLowerCase())
+        ? bareMessage
+        : undefined;
+    const code = (_k = (_j = (_h = (_g = stringValue(payload === null || payload === void 0 ? void 0 : payload.code)) !== null && _g !== void 0 ? _g : stringValue(nestedError === null || nestedError === void 0 ? void 0 : nestedError.code)) !== null && _h !== void 0 ? _h : codeValue(payload === null || payload === void 0 ? void 0 : payload.error)) !== null && _j !== void 0 ? _j : bareCode) !== null && _k !== void 0 ? _k : codeFromOutcome((_l = payload === null || payload === void 0 ? void 0 : payload.outcome) !== null && _l !== void 0 ? _l : payload);
+    const status = (_t = (_r = (_q = (_p = (_o = (_m = numberValue(root === null || root === void 0 ? void 0 : root.status)) !== null && _m !== void 0 ? _m : numberValue(root === null || root === void 0 ? void 0 : root.statusCode)) !== null && _o !== void 0 ? _o : numberValue(response === null || response === void 0 ? void 0 : response.status)) !== null && _p !== void 0 ? _p : numberValue(payload === null || payload === void 0 ? void 0 : payload.status)) !== null && _q !== void 0 ? _q : numberValue(payload === null || payload === void 0 ? void 0 : payload.statusCode)) !== null && _r !== void 0 ? _r : statusFromOutcome((_s = payload === null || payload === void 0 ? void 0 : payload.outcome) !== null && _s !== void 0 ? _s : payload)) !== null && _t !== void 0 ? _t : (code ? STATUS_BY_BARE_CODE[code] : undefined);
+    const fieldErrors = readFieldErrors(payload);
     return {
-        message: (typeof nested.message === "string" && nested.message) ||
-            (typeof root.message === "string" && root.message) ||
-            (error instanceof Error ? error.message : String(error)),
+        status,
+        code,
+        message: readMessage(payload, error),
         fieldErrors,
     };
 };
+exports.readOvokError = readOvokError;
+/** Normalizes Ovok's Nest and FHIR error envelopes without exposing transport details. */
+const parseOvokError = (error) => {
+    const { message, fieldErrors } = (0, exports.readOvokError)(error);
+    return { message, fieldErrors };
+};
 exports.parseOvokError = parseOvokError;
+function readMessage(payload, error) {
+    var _a, _b, _c;
+    const nestedMessage = stringValue((_a = asRecord(payload === null || payload === void 0 ? void 0 : payload.error)) === null || _a === void 0 ? void 0 : _a.message);
+    const message = (_c = (_b = stringValue(payload === null || payload === void 0 ? void 0 : payload.message)) !== null && _b !== void 0 ? _b : nestedMessage) !== null && _c !== void 0 ? _c : payload === null || payload === void 0 ? void 0 : payload.message;
+    if (typeof message === "string" && message.length > 0) {
+        return message;
+    }
+    if (Array.isArray(message)) {
+        const messages = message
+            .map((entry) => { var _a; return stringValue((_a = asRecord(entry)) === null || _a === void 0 ? void 0 : _a.message); })
+            .filter((entry) => entry !== undefined);
+        if (messages.length > 0) {
+            return messages.join("; ");
+        }
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return typeof error === "string" ? error : String(error);
+}
+function readFieldErrors(payload) {
+    const messageErrors = Array.isArray(payload === null || payload === void 0 ? void 0 : payload.message) ? payload.message : [];
+    const nested = asRecord(payload === null || payload === void 0 ? void 0 : payload.error);
+    const rawErrors = Array.isArray(nested === null || nested === void 0 ? void 0 : nested.errors)
+        ? nested.errors
+        : Array.isArray(payload === null || payload === void 0 ? void 0 : payload.errors)
+            ? payload.errors
+            : messageErrors;
+    return rawErrors.flatMap((value) => {
+        const record = asRecord(value);
+        if (!record || typeof record.message !== "string") {
+            return [];
+        }
+        const path = Array.isArray(record.path)
+            ? record.path.map((segment) => String(segment))
+            : [];
+        return [{
+                ...(stringValue(record.code) ? { code: stringValue(record.code) } : {}),
+                message: record.message,
+                path,
+                ...(stringValue(record.validation)
+                    ? { validation: stringValue(record.validation) }
+                    : {}),
+            }];
+    });
+}
+function codeValue(value) {
+    return typeof value === "string" && /^[a-z][a-z0-9_]+$/.test(value)
+        ? value
+        : undefined;
+}
+function codeFromOutcome(value) {
+    var _a, _b;
+    const outcome = asRecord(value);
+    const issues = Array.isArray(outcome === null || outcome === void 0 ? void 0 : outcome.issue) ? outcome.issue : [];
+    for (const issue of issues) {
+        const record = asRecord(issue);
+        const details = asRecord(record === null || record === void 0 ? void 0 : record.details);
+        const coding = Array.isArray(details === null || details === void 0 ? void 0 : details.coding) ? details.coding : [];
+        for (const entry of coding) {
+            const code = codeValue((_a = asRecord(entry)) === null || _a === void 0 ? void 0 : _a.code);
+            if (code === null || code === void 0 ? void 0 : code.startsWith("signals_")) {
+                return code;
+            }
+        }
+        const diagnostics = parseJson(record === null || record === void 0 ? void 0 : record.diagnostics);
+        const diagnostic = asRecord(diagnostics);
+        const code = (_b = codeValue(diagnostic === null || diagnostic === void 0 ? void 0 : diagnostic.error)) !== null && _b !== void 0 ? _b : codeValue(diagnostic === null || diagnostic === void 0 ? void 0 : diagnostic.code);
+        if (code) {
+            return code;
+        }
+    }
+    return undefined;
+}
+function statusFromOutcome(value) {
+    var _a, _b;
+    const outcome = asRecord(value);
+    const issues = Array.isArray(outcome === null || outcome === void 0 ? void 0 : outcome.issue) ? outcome.issue : [];
+    const statusByIssue = {
+        conflict: 409,
+        forbidden: 403,
+        "not-found": 404,
+        "too-many-requests": 429,
+        throttled: 429,
+    };
+    for (const issue of issues) {
+        const status = statusByIssue[String((_b = (_a = asRecord(issue)) === null || _a === void 0 ? void 0 : _a.code) !== null && _b !== void 0 ? _b : "")];
+        if (status) {
+            return status;
+        }
+    }
+    return undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function parseJson(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}

package/dist/client/errors/rate-limit-error.js

@@ -4,6 +4,7 @@ exports.RateLimitError = void 0;
 exports.isRateLimitError = isRateLimitError;
 exports.mapRateLimitError = mapRateLimitError;
 const core_1 = require("@medplum/core");
+const ovok_error_1 = require("./ovok-error");
 const RATE_LIMIT_RESET_EXTENSION_URL = "https://medplum.com/fhir/StructureDefinition/rate-limit-reset";
 /** A typed error returned when the server asks the client to slow down. */
 class RateLimitError extends Error {
@@ -34,6 +35,9 @@ function mapRateLimitError(error) {
     if (error instanceof core_1.OperationOutcomeError && isRateLimitOutcome(error.outcome)) {
         return new RateLimitError(rateLimitResetFromOutcome(error.outcome), { cause: error });
     }
+    if ((0, ovok_error_1.readOvokError)(error).status === 429) {
+        return new RateLimitError(undefined, { cause: error });
+    }
     return error;
 }
 function rateLimitResetFromOutcome(outcome) {

package/dist/client/invites/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./methods";
+export * from "./parse-accept-invite-link";
+export * from "./types";

package/dist/client/invites/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./methods"), exports);
+__exportStar(require("./parse-accept-invite-link"), exports);
+__exportStar(require("./types"), exports);

package/dist/client/invites/methods.d.ts

@@ -0,0 +1,8 @@
+import { OvokClient } from "../ovok-client";
+import { PatientSharingPractitionerShare } from "../patient-sharing/types";
+import { AcceptInviteBody, InviteBody, InviteSent } from "./types";
+export declare function invitePractitioner(this: OvokClient, body: InviteBody): Promise<InviteSent>;
+export declare function invitePatient(this: OvokClient, body: InviteBody): Promise<InviteSent>;
+export declare function acceptPractitionerInvite(this: OvokClient, body: AcceptInviteBody): Promise<PatientSharingPractitionerShare>;
+export declare function acceptPatientInvite(this: OvokClient, body: AcceptInviteBody): Promise<PatientSharingPractitionerShare>;
+export declare function acceptInvite(this: OvokClient, body: AcceptInviteBody): Promise<PatientSharingPractitionerShare>;