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

package/dist/conformance/capability-requirements.js

@@ -48,7 +48,7 @@ exports.OVOK_CORE_REQUIREMENTS = {
     description: "The FHIR surface a server must provide for the @ovok/core client library's own methods to function.",
     software: {
         name: "@ovok/core",
-        version: "0.4.49-dev.496+c48b1bd",
+        version: "0.4.49-dev.497+7201066",
     },
     fhirVersion: "4.0.1",
     format: ["json"],

package/dist/next/auth/saved-accounts-store.d.ts

@@ -0,0 +1,26 @@
+import { OvokStorage } from "../storage/ovok-storage";
+import { OvokReference, Session } from "./session";
+export type SavedAccount = {
+    id: string;
+    profile: OvokReference;
+    project: OvokReference;
+    active: boolean;
+    expired: boolean;
+};
+export type StoredSavedAccount = {
+    session: Session;
+    expired: boolean;
+};
+export declare class SavedAccountsStore {
+    private readonly storage;
+    private readonly key;
+    constructor(storage: OvokStorage, key: string);
+    list(activeAccountId: string | null): Promise<SavedAccount[]>;
+    get(accountId: string): Promise<StoredSavedAccount | null>;
+    save(session: Session): Promise<void>;
+    markExpired(accountId: string): Promise<void>;
+    remove(accountId: string): Promise<void>;
+    private read;
+    private write;
+}
+export declare const savedAccountsStoreFor: (storage: OvokStorage, tenantCode: string) => SavedAccountsStore;

package/dist/next/auth/saved-accounts-store.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.savedAccountsStoreFor = exports.SavedAccountsStore = void 0;
+class SavedAccountsStore {
+    constructor(storage, key) {
+        this.storage = storage;
+        this.key = key;
+    }
+    async list(activeAccountId) {
+        return (await this.read()).map(({ session, expired }) => ({
+            id: session.profile.reference,
+            profile: session.profile,
+            project: session.project,
+            active: session.profile.reference === activeAccountId,
+            expired,
+        }));
+    }
+    async get(accountId) {
+        var _a;
+        return (_a = (await this.read()).find(({ session }) => session.profile.reference === accountId)) !== null && _a !== void 0 ? _a : null;
+    }
+    async save(session) {
+        const accounts = await this.read();
+        const saved = { session, expired: false };
+        const existingIndex = accounts.findIndex((account) => account.session.profile.reference === session.profile.reference);
+        if (existingIndex === -1) {
+            accounts.unshift(saved);
+        }
+        else {
+            accounts[existingIndex] = saved;
+        }
+        await this.write(accounts);
+    }
+    async markExpired(accountId) {
+        const accounts = await this.read();
+        const account = accounts.find(({ session }) => session.profile.reference === accountId);
+        if (!account) {
+            return;
+        }
+        account.session = { ...account.session, accessToken: "", refreshToken: null };
+        account.expired = true;
+        await this.write(accounts);
+    }
+    async remove(accountId) {
+        const accounts = await this.read();
+        await this.write(accounts.filter(({ session }) => session.profile.reference !== accountId));
+    }
+    async read() {
+        const raw = await this.storage.getItem(this.key);
+        if (raw === null) {
+            return [];
+        }
+        try {
+            const value = JSON.parse(raw);
+            return Array.isArray(value) ? value.filter(isStoredSavedAccount) : [];
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    async write(accounts) {
+        if (accounts.length === 0) {
+            await this.storage.removeItem(this.key);
+            return;
+        }
+        await this.storage.setItem(this.key, JSON.stringify(accounts));
+    }
+}
+exports.SavedAccountsStore = SavedAccountsStore;
+const savedAccountsStoreFor = (storage, tenantCode) => new SavedAccountsStore(storage, `ovok:${tenantCode}:saved-accounts`);
+exports.savedAccountsStoreFor = savedAccountsStoreFor;
+const isStoredSavedAccount = (value) => {
+    if (typeof value !== "object" || value === null || !("session" in value)) {
+        return false;
+    }
+    const record = value;
+    const session = record.session;
+    if (typeof session !== "object" || session === null || typeof record.expired !== "boolean") {
+        return false;
+    }
+    const candidate = session;
+    return (typeof candidate.accessToken === "string" &&
+        (candidate.refreshToken === null || typeof candidate.refreshToken === "string") &&
+        typeof candidate.expiresAt === "number" &&
+        isReference(candidate.profile) &&
+        isReference(candidate.project));
+};
+const isReference = (value) => typeof value === "object" &&
+    value !== null &&
+    "reference" in value &&
+    typeof value.reference === "string" &&
+    "display" in value &&
+    (typeof value.display === "string" || value.display === null);

package/dist/next/auth/user-session.d.ts

@@ -1,21 +1,32 @@
 import { OvokSettings } from "../config/ovok-config";
 import { Clock } from "./access-token";
 import { Credentials } from "./credentials";
+import { SavedAccount, SavedAccountsStore, StoredSavedAccount } from "./saved-accounts-store";
 import { LoginTokens, Session } from "./session";
 import { SessionStore } from "./session-store";
 import { TokenEndpoint } from "./token-endpoint";
 type SessionSettings = Pick<OvokSettings, "clientId" | "onUnauthenticated">;
+export type SessionChangeListener = (session: Session | null) => void;
 export declare class UserSession implements Credentials {
     private readonly store;
     private readonly endpoint;
     private readonly settings;
     private readonly now;
+    private readonly savedAccounts;
     private loaded;
     private pendingRefresh;
-    constructor(store: SessionStore, endpoint: TokenEndpoint, settings: SessionSettings, now?: Clock);
+    private readonly changeListeners;
+    constructor(store: SessionStore, endpoint: TokenEndpoint, settings: SessionSettings, now?: Clock, savedAccounts?: SavedAccountsStore | null);
     current(): Promise<Session | null>;
+    onChange(listener: SessionChangeListener): () => void;
     begin(tokens: LoginTokens): Promise<Session>;
     end(): Promise<void>;
+    listSavedAccounts(): Promise<SavedAccount[]>;
+    getSavedAccount(accountId: string): Promise<StoredSavedAccount | null>;
+    switchSavedAccount(accountId: string): Promise<void>;
+    removeSavedAccount(accountId: string): Promise<void>;
+    markSavedAccountExpired(accountId: string): Promise<void>;
+    forSavedAccount(session: Session): UserSession;
     accessToken(): Promise<string | null>;
     refresh(): Promise<boolean>;
     private exchangeRefreshToken;
@@ -23,5 +34,6 @@ export declare class UserSession implements Credentials {
     private signOutIfRejected;
     private refreshForm;
     private save;
+    private notifyChange;
 }
 export {};

package/dist/next/auth/user-session.js

@@ -1,31 +1,120 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserSession = void 0;
+const ovok_account_error_1 = require("../errors/ovok-account-error");
 const ovok_errors_1 = require("../errors/ovok-errors");
+const ovok_storage_1 = require("../storage/ovok-storage");
 const session_1 = require("./session");
+const session_store_1 = require("./session-store");
 const REJECTED_REFRESH_STATUSES = new Set([400, 401, 403]);
 class UserSession {
-    constructor(store, endpoint, settings, now = Date.now) {
+    constructor(store, endpoint, settings, now = Date.now, savedAccounts = null) {
         this.store = store;
         this.endpoint = endpoint;
         this.settings = settings;
         this.now = now;
+        this.savedAccounts = savedAccounts;
         this.loaded = null;
         this.pendingRefresh = null;
+        this.changeListeners = new Set();
     }
     current() {
-        var _a;
-        (_a = this.loaded) !== null && _a !== void 0 ? _a : (this.loaded = this.store.load());
+        if (this.loaded === null) {
+            const pending = this.store.load().catch((error) => {
+                if (this.loaded === pending) {
+                    this.loaded = null;
+                }
+                throw error;
+            });
+            this.loaded = pending;
+        }
         return this.loaded;
     }
+    onChange(listener) {
+        this.changeListeners.add(listener);
+        return () => this.changeListeners.delete(listener);
+    }
     async begin(tokens) {
         const session = (0, session_1.sessionFromLogin)(tokens, this.now());
         await this.save(session);
+        this.notifyChange(session);
         return session;
     }
     async end() {
+        var _a;
+        const current = await this.current().catch(() => null);
         this.loaded = Promise.resolve(null);
         await this.store.clear();
+        if (current) {
+            await ((_a = this.savedAccounts) === null || _a === void 0 ? void 0 : _a.remove(current.profile.reference));
+        }
+        this.notifyChange(null);
+    }
+    async listSavedAccounts() {
+        var _a;
+        const current = await this.current();
+        const currentAccountId = (_a = current === null || current === void 0 ? void 0 : current.profile.reference) !== null && _a !== void 0 ? _a : null;
+        if (this.savedAccounts === null) {
+            return [];
+        }
+        const accounts = await this.savedAccounts.list(currentAccountId);
+        if (current && !accounts.some((account) => account.active)) {
+            await this.savedAccounts.save(current);
+            return this.savedAccounts.list(currentAccountId);
+        }
+        return accounts;
+    }
+    async getSavedAccount(accountId) {
+        var _a, _b;
+        return (_b = (_a = this.savedAccounts) === null || _a === void 0 ? void 0 : _a.get(accountId)) !== null && _b !== void 0 ? _b : null;
+    }
+    async switchSavedAccount(accountId) {
+        const account = await this.getSavedAccount(accountId);
+        if (account === null) {
+            throw new ovok_account_error_1.OvokAccountError("account_not_found");
+        }
+        if (account.expired) {
+            throw new ovok_account_error_1.OvokAccountError("account_expired");
+        }
+        const current = await this.current();
+        if ((current === null || current === void 0 ? void 0 : current.profile.reference) === accountId) {
+            return;
+        }
+        await this.store.save(account.session);
+        this.loaded = Promise.resolve(account.session);
+        this.notifyChange(account.session);
+    }
+    async removeSavedAccount(accountId) {
+        var _a, _b, _c;
+        const account = await this.getSavedAccount(accountId);
+        if (account === null) {
+            throw new ovok_account_error_1.OvokAccountError("account_not_found");
+        }
+        const current = await this.current();
+        const wasActive = (current === null || current === void 0 ? void 0 : current.profile.reference) === accountId;
+        if (wasActive) {
+            await this.store.clear();
+            this.loaded = Promise.resolve(null);
+        }
+        await ((_a = this.savedAccounts) === null || _a === void 0 ? void 0 : _a.remove(accountId));
+        if (wasActive) {
+            const nextAccount = ((_c = await ((_b = this.savedAccounts) === null || _b === void 0 ? void 0 : _b.list(null))) !== null && _c !== void 0 ? _c : []).find((saved) => !saved.expired);
+            if (nextAccount) {
+                await this.switchSavedAccount(nextAccount.id);
+            }
+            else {
+                this.notifyChange(null);
+            }
+        }
+    }
+    async markSavedAccountExpired(accountId) {
+        var _a;
+        await ((_a = this.savedAccounts) === null || _a === void 0 ? void 0 : _a.markExpired(accountId));
+    }
+    forSavedAccount(session) {
+        const isolated = new UserSession(new session_store_1.SessionStore(new ovok_storage_1.MemoryStorage(), "ovok:isolated-session"), this.endpoint, { ...this.settings, onUnauthenticated: () => undefined }, this.now);
+        isolated.loaded = Promise.resolve(session);
+        return isolated;
     }
     async accessToken() {
         var _a, _b;
@@ -61,10 +150,17 @@ class UserSession {
     }
     /** Only a refused refresh token signs the user out; an outage keeps the session for a later retry. */
     async signOutIfRejected(error) {
+        var _a;
         const status = error instanceof ovok_errors_1.OvokError ? error.status : null;
         const rejected = status !== null && REJECTED_REFRESH_STATUSES.has(status);
         if (rejected) {
-            await this.end();
+            const current = await this.current();
+            if (current) {
+                await ((_a = this.savedAccounts) === null || _a === void 0 ? void 0 : _a.markExpired(current.profile.reference));
+            }
+            this.loaded = Promise.resolve(null);
+            await this.store.clear();
+            this.notifyChange(null);
             this.settings.onUnauthenticated({ type: "refresh-rejected", status });
             return false;
         }
@@ -75,8 +171,13 @@ class UserSession {
         return { grant_type: "refresh_token", refresh_token: refreshToken, ...client };
     }
     async save(session) {
-        this.loaded = Promise.resolve(session);
+        var _a;
         await this.store.save(session);
+        await ((_a = this.savedAccounts) === null || _a === void 0 ? void 0 : _a.save(session));
+        this.loaded = Promise.resolve(session);
+    }
+    notifyChange(session) {
+        this.changeListeners.forEach((listener) => listener(session));
     }
 }
 exports.UserSession = UserSession;

package/dist/next/errors/ovok-account-error.d.ts

@@ -0,0 +1,5 @@
+export type OvokAccountErrorCode = "account_not_found" | "account_expired";
+export declare class OvokAccountError extends Error {
+    readonly code: OvokAccountErrorCode;
+    constructor(code: OvokAccountErrorCode);
+}

package/dist/next/errors/ovok-account-error.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OvokAccountError = void 0;
+class OvokAccountError extends Error {
+    constructor(code) {
+        super(code === "account_not_found"
+            ? "Saved account was not found."
+            : "This account's session has expired. Sign in again.");
+        this.code = code;
+        this.name = "OvokAccountError";
+    }
+}
+exports.OvokAccountError = OvokAccountError;

package/dist/next/http/http-client.d.ts

@@ -21,6 +21,7 @@ export declare class HttpClient {
     constructor(context: HttpContext, basePath?: string);
     under(path: string): HttpClient;
     anonymous(): HttpClient;
+    withCredentials(credentials: Credentials): HttpClient;
     get<T>(path: string, options?: RequestOptions): Promise<T>;
     post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
     put<T>(path: string, body: unknown, options?: RequestOptions): Promise<T>;

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

@@ -20,6 +20,9 @@ class HttpClient {
     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);
     }

package/dist/next/index.d.ts

@@ -3,11 +3,14 @@ export type { OvokConfig, OvokFetch, OvokUnauthenticatedReason } from "./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";
@@ -47,6 +50,8 @@ 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";

package/dist/next/index.js

@@ -14,7 +14,7 @@ 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.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;
+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");
@@ -30,4 +30,6 @@ Object.defineProperty(exports, "OvokPermissionError", { enumerable: true, get: f
 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

@@ -17,6 +17,7 @@ import { MeasurementsResource } from "./resources/measurements/measurements-reso
 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";
@@ -25,6 +26,7 @@ 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;

package/dist/next/ovok.js

@@ -2,6 +2,7 @@
 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");
@@ -26,6 +27,7 @@ const measurements_resource_1 = require("./resources/measurements/measurements-r
 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");
@@ -40,6 +42,7 @@ class Ovok {
         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);
@@ -47,10 +50,10 @@ class Ovok {
         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);
+        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);
+        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);
@@ -70,5 +73,5 @@ 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);
+        : 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/resources/invites/invites-resource.d.ts

@@ -1,10 +1,13 @@
 import type { AcceptInviteBody, AcceptRecordShareBody, InviteBody, RecordShareAccepted, RecordShareBody } from "../../../client/invites/types";
 import type { PatientSharingPractitionerShare } from "../../../client/patient-sharing/types";
+import type { UserSession } from "../../auth/user-session";
 import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
 import { InviteFlowResource } from "./invite-flow-resource";
 export type RecordShareFlow = InviteFlowResource<RecordShareBody, AcceptRecordShareBody, RecordShareAccepted>;
 export type PersonInviteFlow = InviteFlowResource<InviteBody, AcceptInviteBody, PatientSharingPractitionerShare>;
 export declare class InvitesResource {
+    private readonly session;
     /** A patient shares their record with a practitioner, or some codes with a carer. */
     readonly recordShares: RecordShareFlow;
     /** A practitioner invites a patient into their care. */
@@ -13,5 +16,7 @@ export declare class InvitesResource {
     readonly practitioners: PersonInviteFlow;
     /** @deprecated Use `care`; the route sunsets on 2026-12-01. */
     readonly patients: PersonInviteFlow;
-    constructor(http: HttpClient);
+    constructor(http: HttpClient, session?: UserSession | null);
+    /** Accepts a record share as a practitioner or a care invite as a patient. */
+    accept(body: AcceptInviteBody, options?: RequestOptions): Promise<PatientSharingPractitionerShare>;
 }

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

@@ -1,14 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvitesResource = void 0;
+const ovok_errors_1 = require("../../errors/ovok-errors");
 const invite_flow_resource_1 = require("./invite-flow-resource");
 const INVITES_PATH = "v1/invites";
 class InvitesResource {
-    constructor(http) {
+    constructor(http, session = null) {
+        this.session = session;
         this.recordShares = new invite_flow_resource_1.InviteFlowResource(http, `${INVITES_PATH}/record-share`);
         this.care = new invite_flow_resource_1.InviteFlowResource(http, `${INVITES_PATH}/care`);
         this.practitioners = new invite_flow_resource_1.InviteFlowResource(http, `${INVITES_PATH}/practitioner`);
         this.patients = new invite_flow_resource_1.InviteFlowResource(http, `${INVITES_PATH}/patient`);
     }
+    /** Accepts a record share as a practitioner or a care invite as a patient. */
+    async accept(body, options) {
+        var _a, _b;
+        const profileReference = (_b = (await ((_a = this.session) === null || _a === void 0 ? void 0 : _a.current()))) === null || _b === void 0 ? void 0 : _b.profile.reference;
+        const profileType = profileReference === null || profileReference === void 0 ? void 0 : profileReference.split("/", 1)[0];
+        if (profileType === "Practitioner") {
+            return this.recordShares.accept(body, options);
+        }
+        if (profileType === "Patient") {
+            return this.care.accept(body, options);
+        }
+        throw new ovok_errors_1.OvokConfigError((0, ovok_errors_1.detailsFor)("Accepting an invite requires a signed-in Patient or Practitioner profile."));
+    }
 }
 exports.InvitesResource = InvitesResource;

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

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

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

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

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

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

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

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

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

@@ -5,6 +5,7 @@ export declare class LiveReads {
     private readonly http;
     private readonly inFlight;
     constructor(http: HttpClient);
+    clear(): void;
     get<T>(path: string, options?: RequestOptions): Promise<T>;
     private share;
     private start;

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

@@ -20,11 +20,17 @@ class SharedRead {
         this.subscribers -= 1;
         const abandoned = this.pending && this.subscribers === 0;
         if (abandoned) {
-            this.finish();
-            this.controller.abort();
+            this.abort();
         }
     }
+    abort() {
+        this.finish();
+        this.controller.abort();
+    }
     finish() {
+        if (!this.pending) {
+            return;
+        }
         this.pending = false;
         this.onDone();
     }
@@ -35,6 +41,11 @@ class LiveReads {
         this.http = http;
         this.inFlight = new Map();
     }
+    clear() {
+        const reads = [...this.inFlight.values()];
+        this.inFlight.clear();
+        reads.forEach((read) => read.abort());
+    }
     get(path, options = {}) {
         const shareable = Object.keys(options).every((key) => key === SIGNAL_OPTION);
         return shareable ? this.share(path, options.signal) : this.http.get(path, options);

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

@@ -1,4 +1,5 @@
 import type { SlimAssignDevice, SlimCreateDevice, SlimDevice, SlimDeviceListItem, SlimDeviceListQuery, SlimDeviceTelemetry, SlimLiveQuery, SlimLiveTelemetry, SlimObservationIds, SlimUpdateDevice } from "../../../client/slim/types";
+import type { UserSession } from "../../auth/user-session";
 import { HttpClient } from "../../http/http-client";
 import { RequestOptions } from "../../http/transmit";
 import { PagePromise } from "../../paging/page";
@@ -8,7 +9,7 @@ export type SlimObservationIdsByDevice = Record<string, SlimObservationIds>;
 export declare class SlimDevicesResource {
     private readonly http;
     private readonly liveReads;
-    constructor(http: HttpClient);
+    constructor(http: HttpClient, session?: UserSession | null);
     list(params?: SlimDeviceListQuery, options?: RequestOptions): PagePromise<SlimDeviceListItem>;
     retrieve(deviceId: string, options?: RequestOptions): Promise<SlimDevice>;
     /** 409 when another customer holds the serial; 422 when this project already uses it. */

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

@@ -20,9 +20,10 @@ const LIVE_COUNT_MESSAGE = `count must be an integer from ${MIN_LIVE_COUNT} to $
 const devicePath = (deviceId) => `${DEVICES_PATH}/${(0, url_1.pathSegment)(deviceId)}`;
 const telemetryPath = (deviceId) => `${TELEMETRY_PATH}/${(0, url_1.pathSegment)(deviceId)}`;
 class SlimDevicesResource {
-    constructor(http) {
+    constructor(http, session = null) {
         this.http = http;
         this.liveReads = new live_reads_1.LiveReads(http);
+        session === null || session === void 0 ? void 0 : session.onChange(() => this.liveReads.clear());
     }
     list(params = {}, options) {
         return (0, numbered_pages_1.numberedRoutePages)((path) => this.http.get(path, options), DEVICES_PATH, params);

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

@@ -1,4 +1,5 @@
 import type { SlimHealth } from "../../../client/slim/types";
+import type { UserSession } from "../../auth/user-session";
 import { HttpClient } from "../../http/http-client";
 import { RequestOptions } from "../../http/transmit";
 import { SlimChangeHistoryResource } from "./slim-change-history-resource";
@@ -33,6 +34,6 @@ export declare class SlimResource {
     readonly organizations: SlimOrganizationsResource;
     readonly practitioners: SlimPractitionersResource;
     readonly users: SlimUsersResource;
-    constructor(http: HttpClient);
+    constructor(http: HttpClient, session?: UserSession | null);
     health(options?: RequestOptions): Promise<SlimHealth>;
 }

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

@@ -19,10 +19,10 @@ const slim_users_resource_1 = require("./slim-users-resource");
 const slim_zones_resource_1 = require("./slim-zones-resource");
 const HEALTH_PATH = `${slim_paths_1.SLIM_PATH}/health`;
 class SlimResource {
-    constructor(http) {
+    constructor(http, session = null) {
         this.http = http;
         this.patients = new slim_patients_resource_1.SlimPatientsResource(http);
-        this.devices = new slim_devices_resource_1.SlimDevicesResource(http);
+        this.devices = new slim_devices_resource_1.SlimDevicesResource(http, session);
         this.notifications = new slim_notifications_resource_1.SlimNotificationsResource(http);
         this.thresholds = new slim_thresholds_resource_1.SlimThresholdsResource(http);
         this.trends = new slim_trends_resource_1.SlimTrendsResource(http);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ovok/core",
-  "version": "0.4.49-dev.496+c48b1bd",
+  "version": "0.4.49-dev.497+7201066",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",