@learnorama/mozaik-sdk 0.1.0-staging.11.1

package/dist/react/cvs-documents.d.ts

@@ -0,0 +1,254 @@
+
+import { G as ReviewUpdateWrite, Gn as HTTPExceptionResponse, K as ReviewRead, M as SupplierGrantRead, Un as LastPositionWrite, ft as RatingUpdateWrite, hr as DocumentRead, mr as DocumentSearchWrite, t as ValidationErrorResponse, vr as DocumentPage } from "../chunks/index.js";
+import { a as ErrorType, c as request, n as BodyType } from "../chunks/client.js";
+import { DataTag, DefinedInitialDataOptions, DefinedUseQueryResult, QueryClient, QueryKey, UndefinedInitialDataOptions, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
+//#region src/react/cvs-documents/cvs-documents.d.ts
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+export declare const getSearchDocumentsUrl: () => string;
+/**
+ * Search the CVS catalogue.
+ *
+ * ``POST`` because the legacy put the query in the body and the mobile clients
+ * send it that way. It is a read, so it stays safe: nothing here writes.
+ *
+ * Same division as ``/search``: the index ranks, PostgreSQL authorises. An
+ * index outage degrades to no results rather than to an unfiltered catalogue.
+ * @summary Search Documents
+ */
+export declare const searchDocuments: (documentSearchWrite: DocumentSearchWrite, options?: Parameters<typeof request>[1]) => Promise<DocumentPage>;
+export declare const getSearchDocumentsMutationKey: () => readonly ['searchDocuments'];
+export declare const getSearchDocumentsMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof searchDocuments>>, TError, SearchDocumentsMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof searchDocuments>>, TError, SearchDocumentsMutationVariables, TContext>;
+export type SearchDocumentsMutationResult = NonNullable<Awaited<ReturnType<typeof searchDocuments>>>;
+export type SearchDocumentsMutationBody = BodyType<DocumentSearchWrite>;
+export type SearchDocumentsMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type SearchDocumentsMutationVariables = {
+  data: BodyType<DocumentSearchWrite>;
+};
+/**
+ * @summary Search Documents
+ */
+export declare const useSearchDocuments: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof searchDocuments>>, TError, SearchDocumentsMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof searchDocuments>>, TError, SearchDocumentsMutationVariables, TContext>;
+export declare const getReadDocumentUrl: (docId: number) => string;
+/**
+ * One work, if this caller's contract reaches it.
+ *
+ * Missing until now, which was an oversight rather than a decision: search,
+ * rating, review and position all existed and there was no way to fetch the
+ * thing they act on. The legacy has no equivalent either — the app assembles a
+ * document sheet from whatever the menu endpoint already returned, which is why
+ * a deep link into a title has never worked properly.
+ * @summary Read Document
+ */
+export declare const readDocument: (docId: number, options?: Parameters<typeof request>[1]) => Promise<DocumentRead>;
+export declare const getReadDocumentQueryKey: (docId: number) => readonly [`/cvs/documents/${number}`];
+export declare const getReadDocumentQueryOptions: <TData = Awaited<ReturnType<typeof readDocument>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(docId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readDocument>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof readDocument>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ReadDocumentQueryResult = NonNullable<Awaited<ReturnType<typeof readDocument>>>;
+export type ReadDocumentQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useReadDocument<TData = Awaited<ReturnType<typeof readDocument>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(docId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof readDocument>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof readDocument>>, TError, Awaited<ReturnType<typeof readDocument>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadDocument<TData = Awaited<ReturnType<typeof readDocument>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(docId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readDocument>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof readDocument>>, TError, Awaited<ReturnType<typeof readDocument>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadDocument<TData = Awaited<ReturnType<typeof readDocument>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(docId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readDocument>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getOpenAtSupplierUrl: (docId: number) => string;
+/**
+ * Authorise this patron to open one title at the supplier hosting it.
+ *
+ * Replaces the legacy ``wstoken``: 4,878 lines dispatching on
+ * ``frn.plate_forme`` through 57 near-identical arms. The signing schemes
+ * reduce to eight (:class:`~app.models.enums.TokenFormula`) and the platform
+ * map to a table, so what is left here is the order of operations.
+ *
+ * **Entitle, seat, then sign** — the same order the streaming route uses, and
+ * for the same reason. A signature is cheap to produce and impossible to
+ * recall once it has left; a seat can be released. Signing first would mean a
+ * refused request had already handed a patron something that works.
+ *
+ * ``404`` when the caller is not entitled or the title does not exist — the
+ * two are deliberately indistinguishable, as everywhere else in this API.
+ * ``409`` when every seat is taken: the caller *is* entitled and should be
+ * offered "try later", not "buy a subscription". ``409`` too when the supplier
+ * sits on a platform nobody implemented — four do, and the legacy cannot serve
+ * them either, so the honest answer is that this title is not openable rather
+ * than a 500 from a missing branch.
+ *
+ * The returned token is for the *supplier*, not for us. See
+ * :class:`~app.datamodels.cvs.downloads.SupplierGrantRead`.
+ * @summary Open At Supplier
+ */
+export declare const openAtSupplier: (docId: number, options?: Parameters<typeof request>[1]) => Promise<SupplierGrantRead>;
+export declare const getOpenAtSupplierMutationKey: () => readonly ['openAtSupplier'];
+export declare const getOpenAtSupplierMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof openAtSupplier>>, TError, OpenAtSupplierMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof openAtSupplier>>, TError, OpenAtSupplierMutationVariables, TContext>;
+export type OpenAtSupplierMutationResult = NonNullable<Awaited<ReturnType<typeof openAtSupplier>>>;
+export type OpenAtSupplierMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type OpenAtSupplierMutationVariables = {
+  docId: number;
+};
+/**
+ * @summary Open At Supplier
+ */
+export declare const useOpenAtSupplier: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof openAtSupplier>>, TError, OpenAtSupplierMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof openAtSupplier>>, TError, OpenAtSupplierMutationVariables, TContext>;
+export declare const getReadLastPositionUrl: (docId: number) => string;
+/**
+ * Where this patron got to, or ``0`` if they have not started.
+ *
+ * New: the legacy has no way to read the position back, so a client that lost
+ * its local state could never resume. Absent means not started, which is why
+ * the row is not created on read.
+ * @summary Read Last Position
+ */
+export declare const readLastPosition: (docId: number, options?: Parameters<typeof request>[1]) => Promise<LastPositionWrite>;
+export declare const getReadLastPositionQueryKey: (docId: number) => readonly [`/cvs/documents/${number}/position`];
+export declare const getReadLastPositionQueryOptions: <TData = Awaited<ReturnType<typeof readLastPosition>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(docId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readLastPosition>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof readLastPosition>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ReadLastPositionQueryResult = NonNullable<Awaited<ReturnType<typeof readLastPosition>>>;
+export type ReadLastPositionQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useReadLastPosition<TData = Awaited<ReturnType<typeof readLastPosition>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(docId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof readLastPosition>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof readLastPosition>>, TError, Awaited<ReturnType<typeof readLastPosition>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadLastPosition<TData = Awaited<ReturnType<typeof readLastPosition>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(docId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readLastPosition>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof readLastPosition>>, TError, Awaited<ReturnType<typeof readLastPosition>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadLastPosition<TData = Awaited<ReturnType<typeof readLastPosition>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(docId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readLastPosition>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getSetLastPositionUrl: (docId: number) => string;
+/**
+ * Record where this patron got to.
+ *
+ * A write, and the legacy declares it ``GET`` with the position in the query
+ * string — which makes resuming a book a cacheable idempotent read that mutates
+ * state, and puts it outside the CSRF layer for free.
+ *
+ * Stored in :class:`~app.models.activity.ReadingPosition`, which the products
+ * share — CVS and the partner reader today — so a member who reads across them
+ * keeps their place in one shape.
+ * @summary Set Last Position
+ */
+export declare const setLastPosition: (docId: number, lastPositionWrite: LastPositionWrite, options?: Parameters<typeof request>[1]) => Promise<void>;
+export declare const getSetLastPositionMutationKey: () => readonly ['setLastPosition'];
+export declare const getSetLastPositionMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof setLastPosition>>, TError, SetLastPositionMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof setLastPosition>>, TError, SetLastPositionMutationVariables, TContext>;
+export type SetLastPositionMutationResult = NonNullable<Awaited<ReturnType<typeof setLastPosition>>>;
+export type SetLastPositionMutationBody = BodyType<LastPositionWrite>;
+export type SetLastPositionMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type SetLastPositionMutationVariables = {
+  docId: number;
+  data: BodyType<LastPositionWrite>;
+};
+/**
+ * @summary Set Last Position
+ */
+export declare const useSetLastPosition: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof setLastPosition>>, TError, SetLastPositionMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof setLastPosition>>, TError, SetLastPositionMutationVariables, TContext>;
+export declare const getRateDocumentUrl: (docId: number) => string;
+/**
+ * Rate a document. Idempotent — rating again replaces the earlier score.
+ *
+ * ``PUT`` on the rating sub-resource rather than the legacy
+ * ``POST /document/rating/update`` with the id in the body: the identifier
+ * belongs in the path, and "update" in a path names an operation in a position
+ * reserved for a resource.
+ * @summary Rate Document
+ */
+export declare const rateDocument: (docId: number, ratingUpdateWrite: RatingUpdateWrite, options?: Parameters<typeof request>[1]) => Promise<void>;
+export declare const getRateDocumentMutationKey: () => readonly ['rateDocument'];
+export declare const getRateDocumentMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof rateDocument>>, TError, RateDocumentMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof rateDocument>>, TError, RateDocumentMutationVariables, TContext>;
+export type RateDocumentMutationResult = NonNullable<Awaited<ReturnType<typeof rateDocument>>>;
+export type RateDocumentMutationBody = BodyType<RatingUpdateWrite>;
+export type RateDocumentMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type RateDocumentMutationVariables = {
+  docId: number;
+  data: BodyType<RatingUpdateWrite>;
+};
+/**
+ * @summary Rate Document
+ */
+export declare const useRateDocument: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof rateDocument>>, TError, RateDocumentMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof rateDocument>>, TError, RateDocumentMutationVariables, TContext>;
+export declare const getWriteReviewUrl: (docId: number) => string;
+/**
+ * Write or replace this patron's review of a document.
+ *
+ * One review per person per document, so this is a ``PUT`` on a singular
+ * sub-resource rather than a ``POST`` to a collection. The legacy had two routes
+ * — with and without an ``avisId`` — for what is one row.
+ *
+ * Every write resets the review to unpublished. An edit after moderation is a
+ * new thing to moderate, and carrying the old approval forward is how an
+ * approved review becomes a different text.
+ * @summary Write Review
+ */
+export declare const writeReview: (docId: number, reviewUpdateWrite: ReviewUpdateWrite, options?: Parameters<typeof request>[1]) => Promise<ReviewRead>;
+export declare const getWriteReviewMutationKey: () => readonly ['writeReview'];
+export declare const getWriteReviewMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof writeReview>>, TError, WriteReviewMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof writeReview>>, TError, WriteReviewMutationVariables, TContext>;
+export type WriteReviewMutationResult = NonNullable<Awaited<ReturnType<typeof writeReview>>>;
+export type WriteReviewMutationBody = BodyType<ReviewUpdateWrite>;
+export type WriteReviewMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type WriteReviewMutationVariables = {
+  docId: number;
+  data: BodyType<ReviewUpdateWrite>;
+};
+/**
+ * @summary Write Review
+ */
+export declare const useWriteReview: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof writeReview>>, TError, WriteReviewMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof writeReview>>, TError, WriteReviewMutationVariables, TContext>;
+//#endregion
+//# sourceMappingURL=cvs-documents.d.ts.map

package/dist/react/cvs-documents.js

@@ -0,0 +1,418 @@
+"use client";
+import { r as request } from "../chunks/client.js";
+import { useMutation, useQuery } from "@tanstack/react-query";
+//#region src/react/cvs-documents/cvs-documents.ts
+/**
+* Generated by orval 🍺
+* Do not edit manually.
+* Mozaik backend
+* Four products behind one API — Biblio, Médiathèques, the partner catalogues (Nextory and YouScribe) and Prof Express. Authentication is Keycloak SSO only, once, for all of them: see the **auth** section below for the browser flow and the three failure modes.
+* OpenAPI spec version: 0.1.0
+*/
+const withQueryKey = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getSearchDocumentsUrl = () => {
+	return `/cvs/documents/search`;
+};
+/**
+* Search the CVS catalogue.
+*
+* ``POST`` because the legacy put the query in the body and the mobile clients
+* send it that way. It is a read, so it stays safe: nothing here writes.
+*
+* Same division as ``/search``: the index ranks, PostgreSQL authorises. An
+* index outage degrades to no results rather than to an unfiltered catalogue.
+* @summary Search Documents
+*/
+const searchDocuments = async (documentSearchWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getSearchDocumentsUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(documentSearchWrite)
+	});
+};
+const getSearchDocumentsMutationKey = () => ["searchDocuments"];
+const getSearchDocumentsMutationOptions = (options) => {
+	const mutationKey = getSearchDocumentsMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { data } = props ?? {};
+		return searchDocuments(data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Search Documents
+*/
+const useSearchDocuments = (options, queryClient) => {
+	return useMutation(getSearchDocumentsMutationOptions(options), queryClient);
+};
+const getReadDocumentUrl = (docId) => {
+	return `/cvs/documents/${docId}`;
+};
+/**
+* One work, if this caller's contract reaches it.
+*
+* Missing until now, which was an oversight rather than a decision: search,
+* rating, review and position all existed and there was no way to fetch the
+* thing they act on. The legacy has no equivalent either — the app assembles a
+* document sheet from whatever the menu endpoint already returned, which is why
+* a deep link into a title has never worked properly.
+* @summary Read Document
+*/
+const readDocument = async (docId, options) => {
+	return request(getReadDocumentUrl(docId), {
+		...options,
+		method: "GET"
+	});
+};
+const getReadDocumentQueryKey = (docId) => {
+	return [`/cvs/documents/${docId}`];
+};
+const getReadDocumentQueryOptions = (docId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getReadDocumentQueryKey(docId);
+	const queryFn = ({ signal }) => readDocument(docId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: docId !== null && docId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Read Document
+*/
+function useReadDocument(docId, options, queryClient) {
+	const queryOptions = getReadDocumentQueryOptions(docId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getOpenAtSupplierUrl = (docId) => {
+	return `/cvs/documents/${docId}/grant`;
+};
+/**
+* Authorise this patron to open one title at the supplier hosting it.
+*
+* Replaces the legacy ``wstoken``: 4,878 lines dispatching on
+* ``frn.plate_forme`` through 57 near-identical arms. The signing schemes
+* reduce to eight (:class:`~app.models.enums.TokenFormula`) and the platform
+* map to a table, so what is left here is the order of operations.
+*
+* **Entitle, seat, then sign** — the same order the streaming route uses, and
+* for the same reason. A signature is cheap to produce and impossible to
+* recall once it has left; a seat can be released. Signing first would mean a
+* refused request had already handed a patron something that works.
+*
+* ``404`` when the caller is not entitled or the title does not exist — the
+* two are deliberately indistinguishable, as everywhere else in this API.
+* ``409`` when every seat is taken: the caller *is* entitled and should be
+* offered "try later", not "buy a subscription". ``409`` too when the supplier
+* sits on a platform nobody implemented — four do, and the legacy cannot serve
+* them either, so the honest answer is that this title is not openable rather
+* than a 500 from a missing branch.
+*
+* The returned token is for the *supplier*, not for us. See
+* :class:`~app.datamodels.cvs.downloads.SupplierGrantRead`.
+* @summary Open At Supplier
+*/
+const openAtSupplier = async (docId, options) => {
+	return request(getOpenAtSupplierUrl(docId), {
+		...options,
+		method: "POST"
+	});
+};
+const getOpenAtSupplierMutationKey = () => ["openAtSupplier"];
+const getOpenAtSupplierMutationOptions = (options) => {
+	const mutationKey = getOpenAtSupplierMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { docId } = props ?? {};
+		return openAtSupplier(docId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Open At Supplier
+*/
+const useOpenAtSupplier = (options, queryClient) => {
+	return useMutation(getOpenAtSupplierMutationOptions(options), queryClient);
+};
+const getReadLastPositionUrl = (docId) => {
+	return `/cvs/documents/${docId}/position`;
+};
+/**
+* Where this patron got to, or ``0`` if they have not started.
+*
+* New: the legacy has no way to read the position back, so a client that lost
+* its local state could never resume. Absent means not started, which is why
+* the row is not created on read.
+* @summary Read Last Position
+*/
+const readLastPosition = async (docId, options) => {
+	return request(getReadLastPositionUrl(docId), {
+		...options,
+		method: "GET"
+	});
+};
+const getReadLastPositionQueryKey = (docId) => {
+	return [`/cvs/documents/${docId}/position`];
+};
+const getReadLastPositionQueryOptions = (docId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getReadLastPositionQueryKey(docId);
+	const queryFn = ({ signal }) => readLastPosition(docId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: docId !== null && docId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Read Last Position
+*/
+function useReadLastPosition(docId, options, queryClient) {
+	const queryOptions = getReadLastPositionQueryOptions(docId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getSetLastPositionUrl = (docId) => {
+	return `/cvs/documents/${docId}/position`;
+};
+/**
+* Record where this patron got to.
+*
+* A write, and the legacy declares it ``GET`` with the position in the query
+* string — which makes resuming a book a cacheable idempotent read that mutates
+* state, and puts it outside the CSRF layer for free.
+*
+* Stored in :class:`~app.models.activity.ReadingPosition`, which the products
+* share — CVS and the partner reader today — so a member who reads across them
+* keeps their place in one shape.
+* @summary Set Last Position
+*/
+const setLastPosition = async (docId, lastPositionWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getSetLastPositionUrl(docId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(lastPositionWrite)
+	});
+};
+const getSetLastPositionMutationKey = () => ["setLastPosition"];
+const getSetLastPositionMutationOptions = (options) => {
+	const mutationKey = getSetLastPositionMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { docId, data } = props ?? {};
+		return setLastPosition(docId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Set Last Position
+*/
+const useSetLastPosition = (options, queryClient) => {
+	return useMutation(getSetLastPositionMutationOptions(options), queryClient);
+};
+const getRateDocumentUrl = (docId) => {
+	return `/cvs/documents/${docId}/rating`;
+};
+/**
+* Rate a document. Idempotent — rating again replaces the earlier score.
+*
+* ``PUT`` on the rating sub-resource rather than the legacy
+* ``POST /document/rating/update`` with the id in the body: the identifier
+* belongs in the path, and "update" in a path names an operation in a position
+* reserved for a resource.
+* @summary Rate Document
+*/
+const rateDocument = async (docId, ratingUpdateWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getRateDocumentUrl(docId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(ratingUpdateWrite)
+	});
+};
+const getRateDocumentMutationKey = () => ["rateDocument"];
+const getRateDocumentMutationOptions = (options) => {
+	const mutationKey = getRateDocumentMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { docId, data } = props ?? {};
+		return rateDocument(docId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Rate Document
+*/
+const useRateDocument = (options, queryClient) => {
+	return useMutation(getRateDocumentMutationOptions(options), queryClient);
+};
+const getWriteReviewUrl = (docId) => {
+	return `/cvs/documents/${docId}/review`;
+};
+/**
+* Write or replace this patron's review of a document.
+*
+* One review per person per document, so this is a ``PUT`` on a singular
+* sub-resource rather than a ``POST`` to a collection. The legacy had two routes
+* — with and without an ``avisId`` — for what is one row.
+*
+* Every write resets the review to unpublished. An edit after moderation is a
+* new thing to moderate, and carrying the old approval forward is how an
+* approved review becomes a different text.
+* @summary Write Review
+*/
+const writeReview = async (docId, reviewUpdateWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getWriteReviewUrl(docId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(reviewUpdateWrite)
+	});
+};
+const getWriteReviewMutationKey = () => ["writeReview"];
+const getWriteReviewMutationOptions = (options) => {
+	const mutationKey = getWriteReviewMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { docId, data } = props ?? {};
+		return writeReview(docId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Write Review
+*/
+const useWriteReview = (options, queryClient) => {
+	return useMutation(getWriteReviewMutationOptions(options), queryClient);
+};
+//#endregion
+export { getOpenAtSupplierMutationKey, getOpenAtSupplierMutationOptions, getOpenAtSupplierUrl, getRateDocumentMutationKey, getRateDocumentMutationOptions, getRateDocumentUrl, getReadDocumentQueryKey, getReadDocumentQueryOptions, getReadDocumentUrl, getReadLastPositionQueryKey, getReadLastPositionQueryOptions, getReadLastPositionUrl, getSearchDocumentsMutationKey, getSearchDocumentsMutationOptions, getSearchDocumentsUrl, getSetLastPositionMutationKey, getSetLastPositionMutationOptions, getSetLastPositionUrl, getWriteReviewMutationKey, getWriteReviewMutationOptions, getWriteReviewUrl, openAtSupplier, rateDocument, readDocument, readLastPosition, searchDocuments, setLastPosition, useOpenAtSupplier, useRateDocument, useReadDocument, useReadLastPosition, useSearchDocuments, useSetLastPosition, useWriteReview, writeReview };
+
+//# sourceMappingURL=cvs-documents.js.map