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

package/dist/next/paging/page.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pagePromise = pagePromise;
+function pagePromise(loadFirst) {
+    const first = loadFirst();
+    const firstPage = first.then((loaded) => loaded.page);
+    // A caller that only iterates never awaits firstPage; its rejection still reaches them through first.
+    firstPage.catch(() => undefined);
+    return Object.assign(firstPage, { [Symbol.asyncIterator]: () => everyItem(first) });
+}
+async function* everyItem(first) {
+    let loaded = await first;
+    while (loaded !== null) {
+        yield* loaded.page.data;
+        loaded = loaded.next === null ? null : await loaded.next();
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { OvokAccount } from "../../../client/platform/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class AccountsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(options?: RequestOptions): Promise<OvokAccount[]>;
+}

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountsResource = void 0;
+const ACCOUNTS_PATH = "accounts";
+class AccountsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    list(options) {
+        return this.http.get(ACCOUNTS_PATH, options);
+    }
+}
+exports.AccountsResource = AccountsResource;

package/dist/next/resources/ai/ai-chat-resource.d.ts

@@ -0,0 +1,8 @@
+import { HttpClient } from "../../http/http-client";
+import { ChatMessagesResource } from "./chat-messages-resource";
+import { ChatSessionsResource } from "./chat-sessions-resource";
+export declare class AiChatResource {
+    readonly sessions: ChatSessionsResource;
+    readonly messages: ChatMessagesResource;
+    constructor(ai: HttpClient);
+}

package/dist/next/resources/ai/ai-chat-resource.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiChatResource = void 0;
+const chat_messages_resource_1 = require("./chat-messages-resource");
+const chat_sessions_resource_1 = require("./chat-sessions-resource");
+class AiChatResource {
+    constructor(ai) {
+        this.sessions = new chat_sessions_resource_1.ChatSessionsResource(ai);
+        this.messages = new chat_messages_resource_1.ChatMessagesResource(ai);
+    }
+}
+exports.AiChatResource = AiChatResource;

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

@@ -0,0 +1,16 @@
+import type { AIFhirRequest, AIFhirResponse } from "../../../client/ai-fhir/types";
+import type { OvokTranslationRequest, OvokTranslationResponse } from "../../../client/experience/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { AiChatResource } from "./ai-chat-resource";
+export type AiFhirSearchRequest = AIFhirRequest & {
+    fhirVersion?: "R4" | "R5";
+};
+export declare class AiResource {
+    readonly chat: AiChatResource;
+    private readonly ai;
+    constructor(http: HttpClient);
+    translate(body: OvokTranslationRequest, options?: RequestOptions): Promise<OvokTranslationResponse>;
+    /** An LLM plans and runs the FHIR queries, so the answer can be wrong or invented. */
+    fhirSearch(body: AiFhirSearchRequest, options?: RequestOptions): Promise<AIFhirResponse>;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiResource = void 0;
+const ai_chat_resource_1 = require("./ai-chat-resource");
+const AI_PATH = "ai";
+class AiResource {
+    constructor(http) {
+        this.ai = http.under(AI_PATH);
+        this.chat = new ai_chat_resource_1.AiChatResource(this.ai);
+    }
+    translate(body, options) {
+        return this.ai.post("translation", body, options);
+    }
+    /** An LLM plans and runs the FHIR queries, so the answer can be wrong or invented. */
+    fhirSearch(body, options) {
+        return this.ai.post("fhir/search", body, options);
+    }
+}
+exports.AiResource = AiResource;

package/dist/next/resources/ai/chat-messages-resource.d.ts

@@ -0,0 +1,9 @@
+import type { OvokChatMessage, OvokChatMessageInput, OvokChatMessageQuery, OvokChatMessagesResponse } from "../../../client/experience/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export declare class ChatMessagesResource {
+    private readonly ai;
+    constructor(ai: HttpClient);
+    list(sessionId: string, params?: OvokChatMessageQuery, options?: RequestOptions): Promise<OvokChatMessagesResponse>;
+    send(sessionId: string, body: OvokChatMessageInput, options?: RequestOptions): Promise<OvokChatMessage>;
+}

package/dist/next/resources/ai/chat-messages-resource.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatMessagesResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const chat_sessions_resource_1 = require("./chat-sessions-resource");
+const messagesPath = (sessionId) => `${(0, chat_sessions_resource_1.sessionPath)(sessionId)}/message`;
+class ChatMessagesResource {
+    constructor(ai) {
+        this.ai = ai;
+    }
+    list(sessionId, params = {}, options) {
+        return this.ai.get(`${messagesPath(sessionId)}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    send(sessionId, body, options) {
+        return this.ai.post(messagesPath(sessionId), body, options);
+    }
+}
+exports.ChatMessagesResource = ChatMessagesResource;

package/dist/next/resources/ai/chat-sessions-resource.d.ts

@@ -0,0 +1,14 @@
+import type { OvokChatSession, OvokChatSessionQuery, OvokChatSessionsResponse, OvokCreateChatSession } from "../../../client/experience/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export type ChatSessionRetrieveParams = {
+    messageCount?: number;
+};
+export declare const sessionPath: (sessionId: string) => string;
+export declare class ChatSessionsResource {
+    private readonly ai;
+    constructor(ai: HttpClient);
+    create(body: OvokCreateChatSession, options?: RequestOptions): Promise<OvokChatSession>;
+    list(params?: OvokChatSessionQuery, options?: RequestOptions): Promise<OvokChatSessionsResponse>;
+    retrieve(sessionId: string, params?: ChatSessionRetrieveParams, options?: RequestOptions): Promise<OvokChatSession>;
+}

package/dist/next/resources/ai/chat-sessions-resource.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatSessionsResource = exports.sessionPath = void 0;
+const query_string_1 = require("../../../client/query-string");
+const url_1 = require("../../http/url");
+const SESSION_PATH = "session";
+const sessionPath = (sessionId) => `${SESSION_PATH}/${(0, url_1.pathSegment)(sessionId)}`;
+exports.sessionPath = sessionPath;
+class ChatSessionsResource {
+    constructor(ai) {
+        this.ai = ai;
+    }
+    create(body, options) {
+        return this.ai.post(SESSION_PATH, body, options);
+    }
+    list(params = {}, options) {
+        return this.ai.get(`${SESSION_PATH}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+    retrieve(sessionId, params = {}, options) {
+        return this.ai.get(`${(0, exports.sessionPath)(sessionId)}${(0, query_string_1.toQueryString)(params)}`, options);
+    }
+}
+exports.ChatSessionsResource = ChatSessionsResource;

package/dist/next/resources/auth/auth-sessions-resource.d.ts

@@ -0,0 +1,13 @@
+import type { OvokSession, SessionRevokeOption } from "../../../client/auth/types/Session";
+import { UserSession } from "../../auth/user-session";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+/** The account's sessions on the server. */
+export declare class AuthSessionsResource {
+    private readonly http;
+    private readonly session;
+    constructor(http: HttpClient, session: UserSession | null);
+    list(options?: RequestOptions): Promise<OvokSession[]>;
+    /** Revoking the current session also ends it here. */
+    revoke(option: SessionRevokeOption, options?: RequestOptions): Promise<void>;
+}

package/dist/next/resources/auth/auth-sessions-resource.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthSessionsResource = void 0;
+const url_1 = require("../../http/url");
+const SESSIONS_PATH = "auth/session";
+const CURRENT_SESSION = "current";
+/** The account's sessions on the server. */
+class AuthSessionsResource {
+    constructor(http, session) {
+        this.http = http;
+        this.session = session;
+    }
+    list(options) {
+        return this.http.get(SESSIONS_PATH, options);
+    }
+    /** Revoking the current session also ends it here. */
+    async revoke(option, options) {
+        var _a;
+        await this.http.delete(`${SESSIONS_PATH}/${(0, url_1.pathSegment)(option)}`, options);
+        if (option === CURRENT_SESSION) {
+            await ((_a = this.session) === null || _a === void 0 ? void 0 : _a.end());
+        }
+    }
+}
+exports.AuthSessionsResource = AuthSessionsResource;

package/dist/next/resources/auth/registration.d.ts

@@ -0,0 +1,35 @@
+import type { RegisterBody } from "../../../client/auth/types/RegisterBody";
+import type { RegisterPractitionerBody } from "../../../client/auth/types/RegisterPractitionerBody";
+import type { ClinicianInviteStep } from "../../../client/auth/types/RegisterResponse";
+import { LoginTokens, Session } from "../../auth/session";
+/** The tenant comes from the client's config, as it does for login. */
+export type PatientRegistration = Omit<RegisterBody, "tenantCode">;
+export type PractitionerRegistration = Omit<RegisterPractitionerBody, "tenantCode">;
+export type RegisterResult = {
+    status: "signed-in";
+    session: Session;
+} | {
+    status: "clinician-invite";
+};
+export type RegisterResponse = LoginTokens | ClinicianInviteStep;
+export declare const REGISTER_PATHS: {
+    readonly patient: "auth/tenant/Patient/register";
+    readonly practitioner: "auth/tenant/Practitioner/register";
+};
+export declare const isClinicianInvite: (response: RegisterResponse) => response is ClinicianInviteStep;
+/** The confirmation is checked here and never sent. */
+export declare function practitionerRegistrationBody(details: PractitionerRegistration, tenantCode: string): {
+    email: string;
+    password: string;
+    name: string;
+    surname: string;
+    tenantCode: string;
+};
+export declare const patientRegistrationBody: (details: PatientRegistration, tenantCode: string) => {
+    continueAsPatientToken: string | undefined;
+    email: string;
+    password: string;
+    name: string;
+    surname: string;
+    tenantCode: string;
+};

package/dist/next/resources/auth/registration.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patientRegistrationBody = exports.isClinicianInvite = exports.REGISTER_PATHS = void 0;
+exports.practitionerRegistrationBody = practitionerRegistrationBody;
+const ovok_errors_1 = require("../../errors/ovok-errors");
+exports.REGISTER_PATHS = {
+    patient: "auth/tenant/Patient/register",
+    practitioner: "auth/tenant/Practitioner/register",
+};
+const isClinicianInvite = (response) => "nextStep" in response && response.nextStep === "clinician-invite";
+exports.isClinicianInvite = isClinicianInvite;
+/** The confirmation is checked here and never sent. */
+function practitionerRegistrationBody(details, tenantCode) {
+    if (details.password !== details.passwordConfirm) {
+        throw new ovok_errors_1.OvokValidationError((0, ovok_errors_1.detailsFor)("Password and password confirm do not match."));
+    }
+    const { email, password, name, surname } = details;
+    return { email, password, name, surname, tenantCode };
+}
+const patientRegistrationBody = (details, tenantCode) => ({
+    ...practitionerRegistrationBody(details, tenantCode),
+    continueAsPatientToken: details.continueAsPatientToken,
+});
+exports.patientRegistrationBody = patientRegistrationBody;

package/dist/next/resources/auth/social-login.d.ts

@@ -0,0 +1,8 @@
+import type { AppleLoginBody } from "../../../client/auth/types/AppleLoginBody";
+import type { GoogleLoginBody } from "../../../client/auth/types/GoogleLoginBody";
+export type SocialCredentials = {
+    apple: AppleLoginBody;
+    google: GoogleLoginBody;
+};
+export type SocialProvider = keyof SocialCredentials;
+export declare const socialLoginPath: (provider: SocialProvider, clientId: string, internalId: string) => string;

package/dist/next/resources/auth/social-login.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.socialLoginPath = void 0;
+const query_string_1 = require("../../../client/query-string");
+const url_1 = require("../../http/url");
+const socialLoginPath = (provider, clientId, internalId) => `auth/external/${(0, url_1.pathSegment)(provider)}${(0, query_string_1.toQueryString)({ client: `ClientApplication/${clientId}`, internalId })}`;
+exports.socialLoginPath = socialLoginPath;

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

@@ -0,0 +1,63 @@
+import type { ChangePasswordBody } from "../../client/auth/types/ChangePasswordBody";
+import type { ChangePasswordResponse } from "../../client/auth/types/ChangePasswordResponse";
+import type { CompletePasswordResetBody } from "../../client/auth/types/CompletePasswordResetBody";
+import type { RequestDeleteUserBody } from "../../client/auth/types/RequestDeleteUserBody";
+import type { RequestDeleteUserResponse } from "../../client/auth/types/RequestDeleteUserResponse";
+import type { ResetPasswordBody } from "../../client/auth/types/ResetPasswordBody";
+import type { OvokCurrentPatientProfile } from "../../client/patient/types";
+import type { OperationOutcome } from "@medplum/fhirtypes";
+import { Session } from "../auth/session";
+import { UserSession } from "../auth/user-session";
+import { HttpClient } from "../http/http-client";
+import { RequestOptions } from "../http/transmit";
+import { AuthSessionsResource } from "./auth/auth-sessions-resource";
+import { PatientRegistration, PractitionerRegistration, RegisterResult } from "./auth/registration";
+import { SocialCredentials, SocialProvider } from "./auth/social-login";
+export type ProfileType = "Patient" | "Practitioner" | "RelatedPerson";
+export type LoginCredentials = {
+    profileType: ProfileType;
+    email: string;
+    password: string;
+};
+/** Hand it back to `verifyMfa`: it carries the PKCE verifier the token exchange needs. */
+export type MfaChallenge = {
+    profileType: ProfileType;
+    loginId: string;
+    codeVerifier: string;
+};
+export type LoginResult = {
+    status: "signed-in";
+    session: Session;
+} | {
+    status: "mfa-required";
+    challenge: MfaChallenge;
+};
+export declare const ME_PATH = "auth/me";
+export declare class AuthResource {
+    private readonly http;
+    private readonly tenantCode;
+    private readonly session;
+    private readonly clientId;
+    readonly sessions: AuthSessionsResource;
+    /** `clientId` is the ClientApplication social sign-in and password resets go through. */
+    constructor(http: HttpClient, tenantCode: string, session: UserSession | null, clientId?: string | null);
+    login(credentials: LoginCredentials, options?: RequestOptions): Promise<LoginResult>;
+    verifyMfa(challenge: MfaChallenge, code: string, options?: RequestOptions): Promise<LoginResult>;
+    /** A project that routes the email to a clinician invitation signs no one in. */
+    register(details: PatientRegistration, options?: RequestOptions): Promise<RegisterResult>;
+    registerPractitioner(details: PractitionerRegistration, options?: RequestOptions): Promise<Session>;
+    socialLogin<P extends SocialProvider>(provider: P, credential: SocialCredentials[P], options?: RequestOptions): Promise<Session>;
+    current(): Promise<Session | null>;
+    me(options?: RequestOptions): Promise<OvokCurrentPatientProfile>;
+    /** The confirmation is the app's to check; Ovok Core never receives it. */
+    changePassword(change: ChangePasswordBody, options?: RequestOptions): Promise<ChangePasswordResponse>;
+    resetPassword(request: ResetPasswordBody, options?: RequestOptions): Promise<OperationOutcome>;
+    completePasswordReset(body: CompletePasswordResetBody, options?: RequestOptions): Promise<OperationOutcome>;
+    /** Schedules the deletion; the account stays signed in until then. */
+    deleteAccount(request: RequestDeleteUserBody, options?: RequestOptions): Promise<RequestDeleteUserResponse>;
+    /** Ends the session on the server, and always locally, even when the server cannot be reached. */
+    logout(options?: RequestOptions): Promise<void>;
+    private exchange;
+    private userSession;
+    private socialLoginClientId;
+}

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

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthResource = exports.ME_PATH = void 0;
+const generate_code_challenge_and_verifier_1 = require("../../client/auth/generate-code-challenge-and-verifier");
+const ovok_errors_1 = require("../errors/ovok-errors");
+const auth_sessions_resource_1 = require("./auth/auth-sessions-resource");
+const registration_1 = require("./auth/registration");
+const social_login_1 = require("./auth/social-login");
+exports.ME_PATH = "auth/me";
+const LOGOUT_PATH = "auth/session/current";
+const CHANGE_PASSWORD_PATH = "v2/auth/change-password";
+const RESET_PASSWORD_PATH = "v2/auth/reset-password";
+const COMPLETE_PASSWORD_RESET_PATH = "v2/auth/reset-password/process";
+const DELETE_ACCOUNT_PATH = "auth/delete";
+class AuthResource {
+    /** `clientId` is the ClientApplication social sign-in and password resets go through. */
+    constructor(http, tenantCode, session, clientId = null) {
+        this.http = http;
+        this.tenantCode = tenantCode;
+        this.session = session;
+        this.clientId = clientId;
+        this.sessions = new auth_sessions_resource_1.AuthSessionsResource(http, session);
+    }
+    async login(credentials, options) {
+        const session = this.userSession();
+        const { codeVerifier, codeChallenge } = (0, generate_code_challenge_and_verifier_1.generateCodeChallengeAndVerifier)();
+        const { profileType, email, password } = credentials;
+        const step = await this.http
+            .anonymous()
+            .post(loginPath(profileType, "start"), { email, password, codeChallenge }, options);
+        if (step.nextStep === "mfa") {
+            return { status: "mfa-required", challenge: { profileType, loginId: step.loginId, codeVerifier } };
+        }
+        return this.exchange(session, { profileType, sessionCode: step.sessionCode, codeVerifier }, options);
+    }
+    async verifyMfa(challenge, code, options) {
+        const session = this.userSession();
+        const { profileType, loginId, codeVerifier } = challenge;
+        const step = await this.http
+            .anonymous()
+            .post(loginPath(profileType, "mfa"), { loginId, mfaToken: code }, options);
+        return this.exchange(session, { profileType, sessionCode: step.sessionCode, codeVerifier }, options);
+    }
+    /** A project that routes the email to a clinician invitation signs no one in. */
+    async register(details, options) {
+        const session = this.userSession();
+        const body = (0, registration_1.patientRegistrationBody)(details, this.tenantCode);
+        const response = await this.http.anonymous().post(registration_1.REGISTER_PATHS.patient, body, options);
+        if ((0, registration_1.isClinicianInvite)(response)) {
+            return { status: "clinician-invite" };
+        }
+        return { status: "signed-in", session: await session.begin(response) };
+    }
+    async registerPractitioner(details, options) {
+        const session = this.userSession();
+        const body = (0, registration_1.practitionerRegistrationBody)(details, this.tenantCode);
+        return session.begin(await this.http.anonymous().post(registration_1.REGISTER_PATHS.practitioner, body, options));
+    }
+    async socialLogin(provider, credential, options) {
+        const session = this.userSession();
+        const { internalId, ...providerResult } = credential;
+        const path = (0, social_login_1.socialLoginPath)(provider, this.socialLoginClientId(), internalId);
+        return session.begin(await this.http.anonymous().post(path, providerResult, options));
+    }
+    async current() {
+        return this.session === null ? null : this.session.current();
+    }
+    me(options) {
+        return this.http.get(exports.ME_PATH, options);
+    }
+    /** The confirmation is the app's to check; Ovok Core never receives it. */
+    changePassword(change, options) {
+        const { oldPassword, newPassword } = change;
+        return this.http.patch(CHANGE_PASSWORD_PATH, { oldPassword, newPassword }, options);
+    }
+    resetPassword(request, options) {
+        var _a, _b;
+        const body = { ...request, clientId: (_b = (_a = request.clientId) !== null && _a !== void 0 ? _a : this.clientId) !== null && _b !== void 0 ? _b : undefined };
+        return this.http.anonymous().post(RESET_PASSWORD_PATH, body, options);
+    }
+    completePasswordReset(body, options) {
+        return this.http.anonymous().post(COMPLETE_PASSWORD_RESET_PATH, body, options);
+    }
+    /** Schedules the deletion; the account stays signed in until then. */
+    deleteAccount(request, options) {
+        return this.http.send({ method: "DELETE", path: DELETE_ACCOUNT_PATH, body: request }, options);
+    }
+    /** Ends the session on the server, and always locally, even when the server cannot be reached. */
+    async logout(options) {
+        const session = this.userSession();
+        try {
+            await this.http.delete(LOGOUT_PATH, options);
+        }
+        finally {
+            await session.end();
+        }
+    }
+    async exchange(session, exchange, options) {
+        const { profileType, sessionCode, codeVerifier } = exchange;
+        const tokens = await this.http
+            .anonymous()
+            .post(loginPath(profileType, "token"), { sessionCode, codeVerifier, tenantCode: this.tenantCode }, options);
+        return { status: "signed-in", session: await session.begin(tokens) };
+    }
+    userSession() {
+        if (this.session === null) {
+            throw new ovok_errors_1.OvokConfigError((0, ovok_errors_1.detailsFor)("This client signs in with clientSecret; user sign-in needs a client without one."));
+        }
+        return this.session;
+    }
+    socialLoginClientId() {
+        if (this.clientId === null) {
+            throw new ovok_errors_1.OvokConfigError((0, ovok_errors_1.detailsFor)("Social sign-in needs clientId in the Ovok config."));
+        }
+        return this.clientId;
+    }
+}
+exports.AuthResource = AuthResource;
+const loginPath = (profileType, step) => `auth/tenant/${profileType}/login/${step}`;

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

@@ -0,0 +1,10 @@
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+export type BotInput = Record<string, unknown>;
+export type BotOutput = Record<string, unknown>;
+export declare class BotsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** `identifier` is the bot's "system|value" identifier. */
+    execute(identifier: string, input: BotInput, options?: RequestOptions): Promise<BotOutput>;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotsResource = void 0;
+const query_string_1 = require("../../../client/query-string");
+const BOTS_PATH = "bots";
+class BotsResource {
+    constructor(http) {
+        this.http = http;
+    }
+    /** `identifier` is the bot's "system|value" identifier. */
+    execute(identifier, input, options) {
+        return this.http.post(`${BOTS_PATH}${(0, query_string_1.toQueryString)({ identifier })}`, input, options);
+    }
+}
+exports.BotsResource = BotsResource;

package/dist/next/resources/cms/cms-delivery.d.ts

@@ -0,0 +1,22 @@
+import type { OvokCmsPage } from "../../../client/cms/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+/** `locale` takes an app language ("de-DE") or a CMS locale ("de"); omitted, the CMS answers in its default. */
+export type CmsReadParams = {
+    locale?: string;
+};
+/** `limit` is at most 50; `sort` is a top-level field, "-" for descending. */
+export type CmsListParams = CmsReadParams & {
+    page?: number;
+    limit?: number;
+    sort?: string;
+};
+/** Published documents, always read as the client's tenant: signed out, the CMS knows it only from `?tenant=`. */
+export declare class CmsDelivery {
+    private readonly http;
+    private readonly tenantCode;
+    constructor(http: HttpClient, tenantCode: string);
+    listPage<T extends object>(collection: string, params: CmsListParams, options?: RequestOptions): Promise<OvokCmsPage<T>>;
+    retrieve<T extends object>(collection: string, slug: string, params: CmsReadParams, options?: RequestOptions): Promise<T>;
+    private queryFor;
+}

package/dist/next/resources/cms/cms-delivery.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CmsDelivery = void 0;
+const locale_1 = require("../../../client/cms/locale");
+const query_string_1 = require("../../../client/query-string");
+const ovok_errors_1 = require("../../errors/ovok-errors");
+const url_1 = require("../../http/url");
+const COLLECTIONS_PATH = "v1/public/cms/collections";
+const itemsPath = (collection) => `${COLLECTIONS_PATH}/${(0, url_1.pathSegment)(collection)}/items`;
+/** Published documents, always read as the client's tenant: signed out, the CMS knows it only from `?tenant=`. */
+class CmsDelivery {
+    constructor(http, tenantCode) {
+        this.http = http;
+        this.tenantCode = tenantCode;
+    }
+    listPage(collection, params, options) {
+        return this.http.get(`${itemsPath(collection)}${this.queryFor(params)}`, options);
+    }
+    async retrieve(collection, slug, params, options) {
+        if (slug === "") {
+            throw new ovok_errors_1.OvokValidationError((0, ovok_errors_1.detailsFor)("A CMS document read needs a slug."));
+        }
+        return this.http.get(`${itemsPath(collection)}/${(0, url_1.pathSegment)(slug)}${this.queryFor(params)}`, options);
+    }
+    // An empty locale or sort counts as absent.
+    queryFor({ locale, page, limit, sort }) {
+        return (0, query_string_1.toQueryString)({
+            locale: locale ? (0, locale_1.toCmsLocale)(locale) : undefined,
+            tenant: this.tenantCode,
+            page,
+            limit,
+            sort: sort || undefined,
+        });
+    }
+}
+exports.CmsDelivery = CmsDelivery;

package/dist/next/resources/cms/cms-documents-resource.d.ts

@@ -0,0 +1,11 @@
+import type { OvokCmsDocument } from "../../../client/cms/types";
+import { RequestOptions } from "../../http/transmit";
+import { PagePromise } from "../../paging/page";
+import { CmsDelivery, CmsListParams, CmsReadParams } from "./cms-delivery";
+/** Published documents of any collection, merged with the shared tenant's. */
+export declare class CmsDocumentsResource {
+    private readonly delivery;
+    constructor(delivery: CmsDelivery);
+    list<T extends object = OvokCmsDocument>(collection: string, params?: CmsListParams, options?: RequestOptions): PagePromise<T>;
+    retrieve<T extends object = OvokCmsDocument>(collection: string, slug: string, params?: CmsReadParams, options?: RequestOptions): Promise<T>;
+}

package/dist/next/resources/cms/cms-documents-resource.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CmsDocumentsResource = void 0;
+const payload_pages_1 = require("./payload-pages");
+/** Published documents of any collection, merged with the shared tenant's. */
+class CmsDocumentsResource {
+    constructor(delivery) {
+        this.delivery = delivery;
+    }
+    list(collection, params = {}, options) {
+        return (0, payload_pages_1.payloadPages)((page) => this.delivery.listPage(collection, { ...params, page }, options), params.page);
+    }
+    retrieve(collection, slug, params = {}, options) {
+        return this.delivery.retrieve(collection, slug, params, options);
+    }
+}
+exports.CmsDocumentsResource = CmsDocumentsResource;

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

@@ -0,0 +1,17 @@
+import type { OvokCmsDocument, OvokTranslations } from "../../../client/cms/types";
+import { HttpClient } from "../../http/http-client";
+import { RequestOptions } from "../../http/transmit";
+import { CmsReadParams } from "./cms-delivery";
+import { CmsDocumentsResource } from "./cms-documents-resource";
+import { ReleaseNotesResource } from "./release-notes-resource";
+export declare class CmsResource {
+    readonly documents: CmsDocumentsResource;
+    readonly releaseNotes: ReleaseNotesResource;
+    private readonly delivery;
+    constructor(http: HttpClient, tenantCode: string);
+    /** "terms-and-conditions", "data-privacy", …: readable before sign-in. */
+    legalPage(slug: string, params?: CmsReadParams, options?: RequestOptions): Promise<OvokCmsDocument>;
+    /** The `translations` collection as one tree, readable before sign-in; nothing is kept on the device. */
+    translations(locale?: string, options?: RequestOptions): Promise<OvokTranslations>;
+    private translationDocuments;
+}