@learnorama/mozaik-sdk 0.1.0-staging.11.1

package/dist/react/biblio-catalogue.d.ts

@@ -0,0 +1,374 @@
+
+import { An as LikeRead, Gn as HTTPExceptionResponse, Or as ContentRead, Rr as CatalogRead, Vn as LearningPathDetailRead, Wt as PackDetailRead, X as RecommendationsRead, Z as ReadRecommendationsParams, dt as ReadCatalogParams, et as ReadPackParams, fr as EditorDetailRead, lr as EditorListRead, lt as ReadEditorParams, t as ValidationErrorResponse, ut as ReadCatalogThemeParams, wn as ListEditorsParams } from "../chunks/index.js";
+import { a as ErrorType, c as request } from "../chunks/client.js";
+import { DataTag, DefinedInitialDataOptions, DefinedUseQueryResult, QueryClient, QueryKey, UndefinedInitialDataOptions, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
+//#region src/react/biblio-catalogue/biblio-catalogue.d.ts
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+export declare const getReadContentUrl: (contentId: number) => string;
+/**
+ * One content item, with this caller's own state on it (E34).
+ *
+ * ``liked`` and ``favorited`` are why this is not just the summary shape: they
+ * are per-caller and therefore uncacheable across users, which is worth knowing
+ * before anyone puts a shared cache in front of it.
+ * @summary Read Content
+ */
+export declare const readContent: (contentId: number, options?: Parameters<typeof request>[1]) => Promise<ContentRead>;
+export declare const getReadContentQueryKey: (contentId: number) => readonly [`/biblio/contents/${number}`];
+export declare const getReadContentQueryOptions: <TData = Awaited<ReturnType<typeof readContent>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(contentId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readContent>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof readContent>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ReadContentQueryResult = NonNullable<Awaited<ReturnType<typeof readContent>>>;
+export type ReadContentQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useReadContent<TData = Awaited<ReturnType<typeof readContent>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(contentId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof readContent>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof readContent>>, TError, Awaited<ReturnType<typeof readContent>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadContent<TData = Awaited<ReturnType<typeof readContent>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(contentId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readContent>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof readContent>>, TError, Awaited<ReturnType<typeof readContent>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadContent<TData = Awaited<ReturnType<typeof readContent>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(contentId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readContent>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getUnlikeContentUrl: (contentId: number) => string;
+/**
+ * Withdraw a like (E37). Idempotent — not liked is already the desired state.
+ * @summary Unlike Content
+ */
+export declare const unlikeContent: (contentId: number, options?: Parameters<typeof request>[1]) => Promise<LikeRead>;
+export declare const getUnlikeContentMutationKey: () => readonly ['unlikeContent'];
+export declare const getUnlikeContentMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof unlikeContent>>, TError, UnlikeContentMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof unlikeContent>>, TError, UnlikeContentMutationVariables, TContext>;
+export type UnlikeContentMutationResult = NonNullable<Awaited<ReturnType<typeof unlikeContent>>>;
+export type UnlikeContentMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type UnlikeContentMutationVariables = {
+  contentId: number;
+};
+/**
+ * @summary Unlike Content
+ */
+export declare const useUnlikeContent: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof unlikeContent>>, TError, UnlikeContentMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof unlikeContent>>, TError, UnlikeContentMutationVariables, TContext>;
+export declare const getLikeContentUrl: (contentId: number) => string;
+/**
+ * Record a like (E36). Idempotent.
+ *
+ * This and :func:`unlike_content` replace one non-idempotent
+ * ``POST /content/{id}/toggle-like``. A retried toggle reverses the user's
+ * intent; a repeated ``PUT`` cannot (§4, consequence 3).
+ *
+ * ``like_count`` is recomputed from ``content_rating`` rather than incremented,
+ * because an increment beside an upsert double-counts the second time the same
+ * person likes the same thing.
+ * @summary Like Content
+ */
+export declare const likeContent: (contentId: number, options?: Parameters<typeof request>[1]) => Promise<LikeRead>;
+export declare const getLikeContentMutationKey: () => readonly ['likeContent'];
+export declare const getLikeContentMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof likeContent>>, TError, LikeContentMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof likeContent>>, TError, LikeContentMutationVariables, TContext>;
+export type LikeContentMutationResult = NonNullable<Awaited<ReturnType<typeof likeContent>>>;
+export type LikeContentMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LikeContentMutationVariables = {
+  contentId: number;
+};
+/**
+ * @summary Like Content
+ */
+export declare const useLikeContent: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof likeContent>>, TError, LikeContentMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof likeContent>>, TError, LikeContentMutationVariables, TContext>;
+export declare const getReadRecommendationsUrl: (contentId: number, params?: ReadRecommendationsParams) => string;
+/**
+ * Related content the caller can also reach (E35).
+ *
+ * Recommending something the account cannot open is worse than recommending
+ * nothing, so the candidate set is entitlement-filtered before ranking rather
+ * than after — filtering afterwards silently shortens the list instead.
+ *
+ * Keyword overlap for now, over the GIN index on ``content.keywords``.
+ * @summary Read Recommendations
+ */
+export declare const readRecommendations: (contentId: number, params?: ReadRecommendationsParams, options?: Parameters<typeof request>[1]) => Promise<RecommendationsRead>;
+export declare const getReadRecommendationsQueryKey: (contentId: number, params?: ReadRecommendationsParams) => readonly [`/biblio/contents/${number}/recommendations`, ...ReadRecommendationsParams[]];
+export declare const getReadRecommendationsQueryOptions: <TData = Awaited<ReturnType<typeof readRecommendations>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(contentId: number, params?: ReadRecommendationsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readRecommendations>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof readRecommendations>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ReadRecommendationsQueryResult = NonNullable<Awaited<ReturnType<typeof readRecommendations>>>;
+export type ReadRecommendationsQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useReadRecommendations<TData = Awaited<ReturnType<typeof readRecommendations>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(contentId: number, params: undefined | ReadRecommendationsParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof readRecommendations>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof readRecommendations>>, TError, Awaited<ReturnType<typeof readRecommendations>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadRecommendations<TData = Awaited<ReturnType<typeof readRecommendations>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(contentId: number, params?: ReadRecommendationsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readRecommendations>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof readRecommendations>>, TError, Awaited<ReturnType<typeof readRecommendations>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadRecommendations<TData = Awaited<ReturnType<typeof readRecommendations>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(contentId: number, params?: ReadRecommendationsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readRecommendations>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getListEditorsUrl: (params?: ListEditorsParams) => string;
+/**
+ * Active editors (E44).
+ *
+ * ``order`` and ``sort`` are resolved against a whitelist and never
+ * interpolated. The legacy passed both straight to the query layer (defect
+ * D17); an unrecognised value is ``422`` rather than a surprise ordering.
+ *
+ * The collection is not wrapped in a single-element array. The legacy
+ * ``GET /api/v1/editors/`` was (§2.1).
+ *
+ * Authenticated even though the answer does not depend on who is asking. Which
+ * publishers a platform carries is commercial information, and an endpoint that
+ * enumerates them for anyone is a competitor's first request. The sibling
+ * ``/editors/{id}`` was already authenticated; this one was not, which is how
+ * the inconsistency was found.
+ * @summary List Editors
+ */
+export declare const listEditors: (params?: ListEditorsParams, options?: Parameters<typeof request>[1]) => Promise<EditorListRead>;
+export declare const getListEditorsQueryKey: (params?: ListEditorsParams) => readonly ["/biblio/editors", ...ListEditorsParams[]];
+export declare const getListEditorsQueryOptions: <TData = Awaited<ReturnType<typeof listEditors>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListEditorsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listEditors>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof listEditors>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ListEditorsQueryResult = NonNullable<Awaited<ReturnType<typeof listEditors>>>;
+export type ListEditorsQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useListEditors<TData = Awaited<ReturnType<typeof listEditors>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params: undefined | ListEditorsParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof listEditors>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof listEditors>>, TError, Awaited<ReturnType<typeof listEditors>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListEditors<TData = Awaited<ReturnType<typeof listEditors>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListEditorsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listEditors>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof listEditors>>, TError, Awaited<ReturnType<typeof listEditors>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListEditors<TData = Awaited<ReturnType<typeof listEditors>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: ListEditorsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listEditors>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getReadEditorUrl: (editorId: number, params?: ReadEditorParams) => string;
+/**
+ * One editor and the content of theirs this caller can reach (E45).
+ *
+ * One endpoint replaces two — a page and a JSON route that used ``pageSize``
+ * instead of ``limit`` and wrapped the object in an array. Same entity, two
+ * conventions, one codebase (§4, consequence 5).
+ * @summary Read Editor
+ */
+export declare const readEditor: (editorId: number, params?: ReadEditorParams, options?: Parameters<typeof request>[1]) => Promise<EditorDetailRead>;
+export declare const getReadEditorQueryKey: (editorId: number, params?: ReadEditorParams) => readonly [`/biblio/editors/${number}`, ...ReadEditorParams[]];
+export declare const getReadEditorQueryOptions: <TData = Awaited<ReturnType<typeof readEditor>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(editorId: number, params?: ReadEditorParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readEditor>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof readEditor>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ReadEditorQueryResult = NonNullable<Awaited<ReturnType<typeof readEditor>>>;
+export type ReadEditorQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useReadEditor<TData = Awaited<ReturnType<typeof readEditor>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(editorId: number, params: undefined | ReadEditorParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof readEditor>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof readEditor>>, TError, Awaited<ReturnType<typeof readEditor>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadEditor<TData = Awaited<ReturnType<typeof readEditor>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(editorId: number, params?: ReadEditorParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readEditor>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof readEditor>>, TError, Awaited<ReturnType<typeof readEditor>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadEditor<TData = Awaited<ReturnType<typeof readEditor>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(editorId: number, params?: ReadEditorParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readEditor>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getReadLearningPathUrl: (learningPathId: number) => string;
+/**
+ * A ``parcours`` and the content it walks through, in order.
+ *
+ * The other end of the ``parcours`` array on a pack, which named paths a client
+ * then had no way to open.
+ *
+ * Steps the caller is not entitled to are **dropped, not hidden behind a
+ * padlock**: the same category test every listing uses decides what appears, so
+ * a path cannot become a way to learn that an item exists. That does mean a
+ * path can come back with fewer steps than the library curated, and with gaps
+ * in ``stepOrder`` — which is why the order is a field rather than the array
+ * index.
+ *
+ * An inactive path is ``404`` rather than an empty one: it was withdrawn, and
+ * an empty sequence would read as "we have nothing for you" instead.
+ * @summary Read Learning Path
+ */
+export declare const readLearningPath: (learningPathId: number, options?: Parameters<typeof request>[1]) => Promise<LearningPathDetailRead>;
+export declare const getReadLearningPathQueryKey: (learningPathId: number) => readonly [`/biblio/learning-paths/${number}`];
+export declare const getReadLearningPathQueryOptions: <TData = Awaited<ReturnType<typeof readLearningPath>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(learningPathId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readLearningPath>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof readLearningPath>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ReadLearningPathQueryResult = NonNullable<Awaited<ReturnType<typeof readLearningPath>>>;
+export type ReadLearningPathQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useReadLearningPath<TData = Awaited<ReturnType<typeof readLearningPath>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(learningPathId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof readLearningPath>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof readLearningPath>>, TError, Awaited<ReturnType<typeof readLearningPath>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadLearningPath<TData = Awaited<ReturnType<typeof readLearningPath>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(learningPathId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readLearningPath>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof readLearningPath>>, TError, Awaited<ReturnType<typeof readLearningPath>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadLearningPath<TData = Awaited<ReturnType<typeof readLearningPath>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(learningPathId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readLearningPath>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getReadPackUrl: (packId: number, params?: ReadPackParams) => string;
+/**
+ * A pack with its catalogs, latest additions and learning paths (E38).
+ *
+ * ``canonical`` is how the redirect dies. When a pack resolves to a single
+ * catalog the legacy answered ``302``; here the response is ``200`` and
+ * ``canonical`` names the resolved catalog, leaving the client to decide whether
+ * to follow it (§5.1).
+ *
+ * A pack the caller has no entitlement to is ``404``. The legacy dereferenced
+ * ``null`` and returned ``500`` (defect D12).
+ * @summary Read Pack
+ */
+export declare const readPack: (packId: number, params?: ReadPackParams, options?: Parameters<typeof request>[1]) => Promise<PackDetailRead>;
+export declare const getReadPackQueryKey: (packId: number, params?: ReadPackParams) => readonly [`/biblio/packs/${number}`, ...ReadPackParams[]];
+export declare const getReadPackQueryOptions: <TData = Awaited<ReturnType<typeof readPack>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(packId: number, params?: ReadPackParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readPack>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof readPack>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ReadPackQueryResult = NonNullable<Awaited<ReturnType<typeof readPack>>>;
+export type ReadPackQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useReadPack<TData = Awaited<ReturnType<typeof readPack>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(packId: number, params: undefined | ReadPackParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof readPack>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof readPack>>, TError, Awaited<ReturnType<typeof readPack>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadPack<TData = Awaited<ReturnType<typeof readPack>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(packId: number, params?: ReadPackParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readPack>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof readPack>>, TError, Awaited<ReturnType<typeof readPack>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadPack<TData = Awaited<ReturnType<typeof readPack>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(packId: number, params?: ReadPackParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readPack>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getReadCatalogUrl: (packId: number, catalogId: number, params?: ReadCatalogParams) => string;
+/**
+ * One catalog inside a pack (E39).
+ * @summary Read Catalog
+ */
+export declare const readCatalog: (packId: number, catalogId: number, params?: ReadCatalogParams, options?: Parameters<typeof request>[1]) => Promise<CatalogRead>;
+export declare const getReadCatalogQueryKey: (packId: number, catalogId: number, params?: ReadCatalogParams) => readonly [`/biblio/packs/${number}/catalogs/${number}`, ...ReadCatalogParams[]];
+export declare const getReadCatalogQueryOptions: <TData = Awaited<ReturnType<typeof readCatalog>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(packId: number, catalogId: number, params?: ReadCatalogParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readCatalog>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof readCatalog>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ReadCatalogQueryResult = NonNullable<Awaited<ReturnType<typeof readCatalog>>>;
+export type ReadCatalogQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useReadCatalog<TData = Awaited<ReturnType<typeof readCatalog>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(packId: number, catalogId: number, params: undefined | ReadCatalogParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof readCatalog>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof readCatalog>>, TError, Awaited<ReturnType<typeof readCatalog>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadCatalog<TData = Awaited<ReturnType<typeof readCatalog>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(packId: number, catalogId: number, params?: ReadCatalogParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readCatalog>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof readCatalog>>, TError, Awaited<ReturnType<typeof readCatalog>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadCatalog<TData = Awaited<ReturnType<typeof readCatalog>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(packId: number, catalogId: number, params?: ReadCatalogParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readCatalog>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getReadCatalogThemeUrl: (packId: number, catalogId: number, themeId: number, params?: ReadCatalogThemeParams) => string;
+/**
+ * The same catalog, narrowed to one theme (E40).
+ * @summary Read Catalog Theme
+ */
+export declare const readCatalogTheme: (packId: number, catalogId: number, themeId: number, params?: ReadCatalogThemeParams, options?: Parameters<typeof request>[1]) => Promise<CatalogRead>;
+export declare const getReadCatalogThemeQueryKey: (packId: number, catalogId: number, themeId: number, params?: ReadCatalogThemeParams) => readonly [`/biblio/packs/${number}/catalogs/${number}/themes/${number}`, ...ReadCatalogThemeParams[]];
+export declare const getReadCatalogThemeQueryOptions: <TData = Awaited<ReturnType<typeof readCatalogTheme>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(packId: number, catalogId: number, themeId: number, params?: ReadCatalogThemeParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readCatalogTheme>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof readCatalogTheme>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ReadCatalogThemeQueryResult = NonNullable<Awaited<ReturnType<typeof readCatalogTheme>>>;
+export type ReadCatalogThemeQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useReadCatalogTheme<TData = Awaited<ReturnType<typeof readCatalogTheme>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(packId: number, catalogId: number, themeId: number, params: undefined | ReadCatalogThemeParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof readCatalogTheme>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof readCatalogTheme>>, TError, Awaited<ReturnType<typeof readCatalogTheme>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadCatalogTheme<TData = Awaited<ReturnType<typeof readCatalogTheme>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(packId: number, catalogId: number, themeId: number, params?: ReadCatalogThemeParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readCatalogTheme>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof readCatalogTheme>>, TError, Awaited<ReturnType<typeof readCatalogTheme>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useReadCatalogTheme<TData = Awaited<ReturnType<typeof readCatalogTheme>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(packId: number, catalogId: number, themeId: number, params?: ReadCatalogThemeParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof readCatalogTheme>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+//#endregion
+//# sourceMappingURL=biblio-catalogue.d.ts.map