@learnorama/mozaik-sdk 0.12.4-staging.47.1 → 0.13.0-staging.48.1

package/dist/react/biblio-learning-finance.d.ts

@@ -0,0 +1,868 @@
+
+import { $i as LearningRoyaltyAdjustmentWrite, Bi as LearningRoyaltyPaidWrite, Fi as LearningRoyaltySettlementRead, Ga as LearningListPayeesParams, Gi as LearningRoyaltyBudgetRead, Go as LearningChannelListRead, Ha as LearningListRoyaltyPeriodsParams, Hi as LearningRoyaltyInvoiceRead, Ii as LearningRoyaltyPeriodWrite, Ji as LearningRoyaltyAllocationPage, Ka as LearningListPayeeSettlementsParams, Ko as LearningChannelRead, Li as LearningRoyaltyPeriodPage, Ni as LearningRoyaltySettlementWrite, Ns as LearningAssetRead, Pi as LearningRoyaltySettlementPage, Qi as LearningRoyaltyAgreementEndWrite, Ri as LearningRoyaltyPeriodRead, Ua as LearningListRoyaltyAllocationsParams, Ui as LearningRoyaltyBudgetWrite, Uo as LearningContractChannelWrite, Vi as LearningRoyaltyInvoiceWrite, Wi as LearningRoyaltyBudgetListRead, Wo as LearningChannelWrite, Xi as LearningRoyaltyAgreementWrite, Zi as LearningRoyaltyAgreementRead, a as ValidationErrorResponse, ca as LearningPayeeRead, da as LearningPayeeDocumentsParams, fa as LearningPayeeDocumentPage, fc as HTTPExceptionResponse, la as LearningPayeeDocumentUploadWrite, oa as LearningPayeeWrite, qa as LearningListPayeeAllocationsParams, qi as LearningRoyaltyApprovalWrite, sa as LearningPayeePage, ui as LearningUploadRead } 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/biblio-learning-finance/biblio-learning-finance.d.ts
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+export declare const getLearningEndRoyaltyAgreementUrl: (agreementId: number) => string;
+/**
+ * Set the inclusive final month using first-of-month dates. expectedEndsMonth must match the current end unless this exact end is already applied. The change cannot precede the start, overlap other terms, or invalidate approved accounting. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Set an agreement’s final covered month
+ */
+export declare const learningEndRoyaltyAgreement: (agreementId: number, learningRoyaltyAgreementEndWrite: LearningRoyaltyAgreementEndWrite, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyAgreementRead>;
+export declare const getLearningEndRoyaltyAgreementMutationKey: () => readonly ['learningEndRoyaltyAgreement'];
+export declare const getLearningEndRoyaltyAgreementMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningEndRoyaltyAgreement>>, TError, LearningEndRoyaltyAgreementMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningEndRoyaltyAgreement>>, TError, LearningEndRoyaltyAgreementMutationVariables, TContext>;
+export type LearningEndRoyaltyAgreementMutationResult = NonNullable<Awaited<ReturnType<typeof learningEndRoyaltyAgreement>>>;
+export type LearningEndRoyaltyAgreementMutationBody = BodyType<LearningRoyaltyAgreementEndWrite>;
+export type LearningEndRoyaltyAgreementMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningEndRoyaltyAgreementMutationVariables = {
+  agreementId: number;
+  data: BodyType<LearningRoyaltyAgreementEndWrite>;
+};
+/**
+ * @summary Set an agreement’s final covered month
+ */
+export declare const useLearningEndRoyaltyAgreement: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningEndRoyaltyAgreement>>, TError, LearningEndRoyaltyAgreementMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningEndRoyaltyAgreement>>, TError, LearningEndRoyaltyAgreementMutationVariables, TContext>;
+export declare const getLearningListDistributionChannelsUrl: (catalogueId: number) => string;
+/**
+ * List every channel in the catalogue, including inactive channels, ordered by channel ID. Organic identifies the direct distribution pool; a channel does not grant course access. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused.
+ * @summary List catalogue distribution channels
+ */
+export declare const learningListDistributionChannels: (catalogueId: number, options?: Parameters<typeof request>[1]) => Promise<LearningChannelListRead>;
+export declare const getLearningListDistributionChannelsQueryKey: (catalogueId: number) => readonly [`/learning/finance/catalogues/${number}/channels`];
+export declare const getLearningListDistributionChannelsQueryOptions: <TData = Awaited<ReturnType<typeof learningListDistributionChannels>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(catalogueId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListDistributionChannels>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningListDistributionChannels>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningListDistributionChannelsQueryResult = NonNullable<Awaited<ReturnType<typeof learningListDistributionChannels>>>;
+export type LearningListDistributionChannelsQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningListDistributionChannels<TData = Awaited<ReturnType<typeof learningListDistributionChannels>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(catalogueId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListDistributionChannels>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningListDistributionChannels>>, TError, Awaited<ReturnType<typeof learningListDistributionChannels>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListDistributionChannels<TData = Awaited<ReturnType<typeof learningListDistributionChannels>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(catalogueId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListDistributionChannels>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningListDistributionChannels>>, TError, Awaited<ReturnType<typeof learningListDistributionChannels>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListDistributionChannels<TData = Awaited<ReturnType<typeof learningListDistributionChannels>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(catalogueId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListDistributionChannels>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningCreateDistributionChannelUrl: (catalogueId: number) => string;
+/**
+ * Create an active organic or promotional accounting channel. At most one active organic channel is permitted per catalogue. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Create a distribution channel
+ */
+export declare const learningCreateDistributionChannel: (catalogueId: number, learningChannelWrite: LearningChannelWrite, options?: Parameters<typeof request>[1]) => Promise<LearningChannelRead>;
+export declare const getLearningCreateDistributionChannelMutationKey: () => readonly ['learningCreateDistributionChannel'];
+export declare const getLearningCreateDistributionChannelMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningCreateDistributionChannel>>, TError, LearningCreateDistributionChannelMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningCreateDistributionChannel>>, TError, LearningCreateDistributionChannelMutationVariables, TContext>;
+export type LearningCreateDistributionChannelMutationResult = NonNullable<Awaited<ReturnType<typeof learningCreateDistributionChannel>>>;
+export type LearningCreateDistributionChannelMutationBody = BodyType<LearningChannelWrite>;
+export type LearningCreateDistributionChannelMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningCreateDistributionChannelMutationVariables = {
+  catalogueId: number;
+  data: BodyType<LearningChannelWrite>;
+};
+/**
+ * @summary Create a distribution channel
+ */
+export declare const useLearningCreateDistributionChannel: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningCreateDistributionChannel>>, TError, LearningCreateDistributionChannelMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningCreateDistributionChannel>>, TError, LearningCreateDistributionChannelMutationVariables, TContext>;
+export declare const getLearningCreatePayeeUrl: (catalogueId: number) => string;
+/**
+ * Link an active independent account to one catalogue’s billing profile. The (catalogue, user) pair must be unique. expectedUpdatedAt is ignored on creation; optional legal details may be completed before invoicing. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Create a rightsholder billing profile
+ */
+export declare const learningCreatePayee: (catalogueId: number, learningPayeeWrite: LearningPayeeWrite, options?: Parameters<typeof request>[1]) => Promise<LearningPayeeRead>;
+export declare const getLearningCreatePayeeMutationKey: () => readonly ['learningCreatePayee'];
+export declare const getLearningCreatePayeeMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningCreatePayee>>, TError, LearningCreatePayeeMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningCreatePayee>>, TError, LearningCreatePayeeMutationVariables, TContext>;
+export type LearningCreatePayeeMutationResult = NonNullable<Awaited<ReturnType<typeof learningCreatePayee>>>;
+export type LearningCreatePayeeMutationBody = BodyType<LearningPayeeWrite>;
+export type LearningCreatePayeeMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningCreatePayeeMutationVariables = {
+  catalogueId: number;
+  data: BodyType<LearningPayeeWrite>;
+};
+/**
+ * @summary Create a rightsholder billing profile
+ */
+export declare const useLearningCreatePayee: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningCreatePayee>>, TError, LearningCreatePayeeMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningCreatePayee>>, TError, LearningCreatePayeeMutationVariables, TContext>;
+export declare const getLearningListRoyaltyPeriodsUrl: (catalogueId: number, params?: LearningListRoyaltyPeriodsParams) => string;
+/**
+ * List accounting periods for the catalogue, newest month then ID first. State and generation identify which inputs/results are current; historical accounting remains readable even when a catalogue closes. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused.
+ * @summary List catalogue accounting months
+ */
+export declare const learningListRoyaltyPeriods: (catalogueId: number, params?: LearningListRoyaltyPeriodsParams, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyPeriodPage>;
+export declare const getLearningListRoyaltyPeriodsQueryKey: (catalogueId: number, params?: LearningListRoyaltyPeriodsParams) => readonly [`/learning/finance/catalogues/${number}/periods`, ...LearningListRoyaltyPeriodsParams[]];
+export declare const getLearningListRoyaltyPeriodsQueryOptions: <TData = Awaited<ReturnType<typeof learningListRoyaltyPeriods>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(catalogueId: number, params?: LearningListRoyaltyPeriodsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyPeriods>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyPeriods>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningListRoyaltyPeriodsQueryResult = NonNullable<Awaited<ReturnType<typeof learningListRoyaltyPeriods>>>;
+export type LearningListRoyaltyPeriodsQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningListRoyaltyPeriods<TData = Awaited<ReturnType<typeof learningListRoyaltyPeriods>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(catalogueId: number, params: undefined | LearningListRoyaltyPeriodsParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyPeriods>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningListRoyaltyPeriods>>, TError, Awaited<ReturnType<typeof learningListRoyaltyPeriods>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListRoyaltyPeriods<TData = Awaited<ReturnType<typeof learningListRoyaltyPeriods>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(catalogueId: number, params?: LearningListRoyaltyPeriodsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyPeriods>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningListRoyaltyPeriods>>, TError, Awaited<ReturnType<typeof learningListRoyaltyPeriods>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListRoyaltyPeriods<TData = Awaited<ReturnType<typeof learningListRoyaltyPeriods>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(catalogueId: number, params?: LearningListRoyaltyPeriodsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyPeriods>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningCreateRoyaltyPeriodUrl: (catalogueId: number) => string;
+/**
+ * Create a draft period for one catalogue, calendar month and currency. month must be the first day; currency is three uppercase letters. A period may be opened before the month closes, but calculation must wait for its Europe/Paris month boundary. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Open a monthly royalty period
+ */
+export declare const learningCreateRoyaltyPeriod: (catalogueId: number, learningRoyaltyPeriodWrite: LearningRoyaltyPeriodWrite, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyPeriodRead>;
+export declare const getLearningCreateRoyaltyPeriodMutationKey: () => readonly ['learningCreateRoyaltyPeriod'];
+export declare const getLearningCreateRoyaltyPeriodMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningCreateRoyaltyPeriod>>, TError, LearningCreateRoyaltyPeriodMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningCreateRoyaltyPeriod>>, TError, LearningCreateRoyaltyPeriodMutationVariables, TContext>;
+export type LearningCreateRoyaltyPeriodMutationResult = NonNullable<Awaited<ReturnType<typeof learningCreateRoyaltyPeriod>>>;
+export type LearningCreateRoyaltyPeriodMutationBody = BodyType<LearningRoyaltyPeriodWrite>;
+export type LearningCreateRoyaltyPeriodMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningCreateRoyaltyPeriodMutationVariables = {
+  catalogueId: number;
+  data: BodyType<LearningRoyaltyPeriodWrite>;
+};
+/**
+ * @summary Open a monthly royalty period
+ */
+export declare const useLearningCreateRoyaltyPeriod: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningCreateRoyaltyPeriod>>, TError, LearningCreateRoyaltyPeriodMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningCreateRoyaltyPeriod>>, TError, LearningCreateRoyaltyPeriodMutationVariables, TContext>;
+export declare const getLearningSetContractChannelUrl: (contractId: number) => string;
+/**
+ * Replace the contract’s distribution mapping and eligibility flag. The channel must be active; this mapping controls royalty attribution and does not grant reader access. Global commercial authority is required in addition to the channel catalogue scope. Success returns no body. Mutations require high authentication assurance.
+ * @summary Assign a contract’s royalty channel
+ */
+export declare const learningSetContractChannel: (contractId: number, learningContractChannelWrite: LearningContractChannelWrite, options?: Parameters<typeof request>[1]) => Promise<void>;
+export declare const getLearningSetContractChannelMutationKey: () => readonly ['learningSetContractChannel'];
+export declare const getLearningSetContractChannelMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningSetContractChannel>>, TError, LearningSetContractChannelMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningSetContractChannel>>, TError, LearningSetContractChannelMutationVariables, TContext>;
+export type LearningSetContractChannelMutationResult = NonNullable<Awaited<ReturnType<typeof learningSetContractChannel>>>;
+export type LearningSetContractChannelMutationBody = BodyType<LearningContractChannelWrite>;
+export type LearningSetContractChannelMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningSetContractChannelMutationVariables = {
+  contractId: number;
+  data: BodyType<LearningContractChannelWrite>;
+};
+/**
+ * @summary Assign a contract’s royalty channel
+ */
+export declare const useLearningSetContractChannel: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningSetContractChannel>>, TError, LearningSetContractChannelMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningSetContractChannel>>, TError, LearningSetContractChannelMutationVariables, TContext>;
+export declare const getLearningCreateRoyaltyAgreementUrl: (courseId: number) => string;
+/**
+ * Create terms for an active rightsholder in the course’s financial catalogue. First-of-month bounds are inclusive; null endsMonth leaves the agreement open. Overlapping terms for the same course/payee are refused. share is a fraction; coefficients are negotiated multipliers. Calculation requires the course’s applicable shares to sum to one. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Create monthly rightsholder terms
+ */
+export declare const learningCreateRoyaltyAgreement: (courseId: number, learningRoyaltyAgreementWrite: LearningRoyaltyAgreementWrite, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyAgreementRead>;
+export declare const getLearningCreateRoyaltyAgreementMutationKey: () => readonly ['learningCreateRoyaltyAgreement'];
+export declare const getLearningCreateRoyaltyAgreementMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningCreateRoyaltyAgreement>>, TError, LearningCreateRoyaltyAgreementMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningCreateRoyaltyAgreement>>, TError, LearningCreateRoyaltyAgreementMutationVariables, TContext>;
+export type LearningCreateRoyaltyAgreementMutationResult = NonNullable<Awaited<ReturnType<typeof learningCreateRoyaltyAgreement>>>;
+export type LearningCreateRoyaltyAgreementMutationBody = BodyType<LearningRoyaltyAgreementWrite>;
+export type LearningCreateRoyaltyAgreementMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningCreateRoyaltyAgreementMutationVariables = {
+  courseId: number;
+  data: BodyType<LearningRoyaltyAgreementWrite>;
+};
+/**
+ * @summary Create monthly rightsholder terms
+ */
+export declare const useLearningCreateRoyaltyAgreement: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningCreateRoyaltyAgreement>>, TError, LearningCreateRoyaltyAgreementMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningCreateRoyaltyAgreement>>, TError, LearningCreateRoyaltyAgreementMutationVariables, TContext>;
+export declare const getLearningReadRoyaltyInvoiceUrl: (invoiceId: number) => string;
+/**
+ * Read immutable issuance facts and the authenticated document endpoint. number is the native sequence; sourceNumber preserves an imported reference. Historical missing net/tax facts stay null and must not be reconstructed from current legal details. A source invoice without a settlement requires catalogue finance authority. Available to the linked independent rightsholder or catalogue finance/global commercial authority; support impersonation is refused.
+ * @summary Read native or source invoice facts
+ */
+export declare const learningReadRoyaltyInvoice: (invoiceId: number, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyInvoiceRead>;
+export declare const getLearningReadRoyaltyInvoiceQueryKey: (invoiceId: number) => readonly [`/learning/finance/invoices/${number}`];
+export declare const getLearningReadRoyaltyInvoiceQueryOptions: <TData = Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(invoiceId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningReadRoyaltyInvoiceQueryResult = NonNullable<Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>>;
+export type LearningReadRoyaltyInvoiceQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningReadRoyaltyInvoice<TData = Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(invoiceId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>, TError, Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningReadRoyaltyInvoice<TData = Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(invoiceId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>, TError, Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningReadRoyaltyInvoice<TData = Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(invoiceId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltyInvoice>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningDownloadRoyaltyInvoiceUrl: (invoiceId: number) => string;
+/**
+ * Render the stored issuance snapshots as binary application/pdf. Returns Cache-Control: private, no-store and an attachment filename invoice-{invoice_id}.pdf. Missing original parties, amount, tax rate or supported layout prevents rendering; current billing details are never substituted into old invoices. A source invoice without a settlement requires catalogue finance authority. Available to the linked independent rightsholder or catalogue finance/global commercial authority; support impersonation is refused.
+ * @summary Download a private invoice PDF
+ */
+export declare const learningDownloadRoyaltyInvoice: (invoiceId: number, options?: Parameters<typeof request>[1]) => Promise<Blob>;
+export declare const getLearningDownloadRoyaltyInvoiceQueryKey: (invoiceId: number) => readonly [`/learning/finance/invoices/${number}/document`];
+export declare const getLearningDownloadRoyaltyInvoiceQueryOptions: <TData = Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(invoiceId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningDownloadRoyaltyInvoiceQueryResult = NonNullable<Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>>;
+export type LearningDownloadRoyaltyInvoiceQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningDownloadRoyaltyInvoice<TData = Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(invoiceId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>, TError, Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningDownloadRoyaltyInvoice<TData = Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(invoiceId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>, TError, Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningDownloadRoyaltyInvoice<TData = Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(invoiceId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningDownloadRoyaltyInvoice>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningListPayeesUrl: (params?: LearningListPayeesParams) => string;
+/**
+ * List the caller’s linked rightsholders plus profiles in catalogues where they hold a finance grant; global commercial operators see all. Includes inactive and historical rows, ordered by ID. Public author attribution alone grants no finance access. Dependent profiles and support impersonation are refused.
+ * @summary List accessible rightsholder billing profiles
+ */
+export declare const learningListPayees: (params?: LearningListPayeesParams, options?: Parameters<typeof request>[1]) => Promise<LearningPayeePage>;
+export declare const getLearningListPayeesQueryKey: (params?: LearningListPayeesParams) => readonly ["/learning/finance/payees", ...LearningListPayeesParams[]];
+export declare const getLearningListPayeesQueryOptions: <TData = Awaited<ReturnType<typeof learningListPayees>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: LearningListPayeesParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListPayees>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningListPayees>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningListPayeesQueryResult = NonNullable<Awaited<ReturnType<typeof learningListPayees>>>;
+export type LearningListPayeesQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningListPayees<TData = Awaited<ReturnType<typeof learningListPayees>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params: undefined | LearningListPayeesParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListPayees>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningListPayees>>, TError, Awaited<ReturnType<typeof learningListPayees>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListPayees<TData = Awaited<ReturnType<typeof learningListPayees>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: LearningListPayeesParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListPayees>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningListPayees>>, TError, Awaited<ReturnType<typeof learningListPayees>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListPayees<TData = Awaited<ReturnType<typeof learningListPayees>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(params?: LearningListPayeesParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListPayees>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningReadPayeeUrl: (payeeId: number) => string;
+/**
+ * Read current legal details and the updatedAt concurrency value needed for replacement. Historical null values remain unknown. Available to the linked independent rightsholder or catalogue finance/global commercial authority; support impersonation is refused.
+ * @summary Read a rightsholder billing profile
+ */
+export declare const learningReadPayee: (payeeId: number, options?: Parameters<typeof request>[1]) => Promise<LearningPayeeRead>;
+export declare const getLearningReadPayeeQueryKey: (payeeId: number) => readonly [`/learning/finance/payees/${number}`];
+export declare const getLearningReadPayeeQueryOptions: <TData = Awaited<ReturnType<typeof learningReadPayee>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadPayee>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningReadPayee>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningReadPayeeQueryResult = NonNullable<Awaited<ReturnType<typeof learningReadPayee>>>;
+export type LearningReadPayeeQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningReadPayee<TData = Awaited<ReturnType<typeof learningReadPayee>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadPayee>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningReadPayee>>, TError, Awaited<ReturnType<typeof learningReadPayee>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningReadPayee<TData = Awaited<ReturnType<typeof learningReadPayee>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadPayee>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningReadPayee>>, TError, Awaited<ReturnType<typeof learningReadPayee>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningReadPayee<TData = Awaited<ReturnType<typeof learningReadPayee>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadPayee>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningUpdatePayeeUrl: (payeeId: number) => string;
+/**
+ * Replace all editable billing fields; omitted optional fields become null. Send the current updatedAt as expectedUpdatedAt and keep userId unchanged. Returns the new concurrency timestamp. Available to the linked independent rightsholder or catalogue finance/global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Replace a rightsholder’s legal details
+ */
+export declare const learningUpdatePayee: (payeeId: number, learningPayeeWrite: LearningPayeeWrite, options?: Parameters<typeof request>[1]) => Promise<LearningPayeeRead>;
+export declare const getLearningUpdatePayeeMutationKey: () => readonly ['learningUpdatePayee'];
+export declare const getLearningUpdatePayeeMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningUpdatePayee>>, TError, LearningUpdatePayeeMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningUpdatePayee>>, TError, LearningUpdatePayeeMutationVariables, TContext>;
+export type LearningUpdatePayeeMutationResult = NonNullable<Awaited<ReturnType<typeof learningUpdatePayee>>>;
+export type LearningUpdatePayeeMutationBody = BodyType<LearningPayeeWrite>;
+export type LearningUpdatePayeeMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningUpdatePayeeMutationVariables = {
+  payeeId: number;
+  data: BodyType<LearningPayeeWrite>;
+};
+/**
+ * @summary Replace a rightsholder’s legal details
+ */
+export declare const useLearningUpdatePayee: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningUpdatePayee>>, TError, LearningUpdatePayeeMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningUpdatePayee>>, TError, LearningUpdatePayeeMutationVariables, TContext>;
+export declare const getLearningListPayeeAllocationsUrl: (payeeId: number, params?: LearningListPayeeAllocationsParams) => string;
+/**
+ * Page only this rightsholder’s allocations from approved months and each month’s current generation, newest month then allocation ID. Unapproved calculation output stays in the catalogue finance review endpoint. Amounts are decimal major currency units, not integer cents. Available to the linked independent rightsholder or catalogue finance/global commercial authority; support impersonation is refused.
+ * @summary List approved rightsholder allocations
+ */
+export declare const learningListPayeeAllocations: (payeeId: number, params?: LearningListPayeeAllocationsParams, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyAllocationPage>;
+export declare const getLearningListPayeeAllocationsQueryKey: (payeeId: number, params?: LearningListPayeeAllocationsParams) => readonly [`/learning/finance/payees/${number}/allocations`, ...LearningListPayeeAllocationsParams[]];
+export declare const getLearningListPayeeAllocationsQueryOptions: <TData = Awaited<ReturnType<typeof learningListPayeeAllocations>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, params?: LearningListPayeeAllocationsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListPayeeAllocations>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningListPayeeAllocations>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningListPayeeAllocationsQueryResult = NonNullable<Awaited<ReturnType<typeof learningListPayeeAllocations>>>;
+export type LearningListPayeeAllocationsQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningListPayeeAllocations<TData = Awaited<ReturnType<typeof learningListPayeeAllocations>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, params: undefined | LearningListPayeeAllocationsParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListPayeeAllocations>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningListPayeeAllocations>>, TError, Awaited<ReturnType<typeof learningListPayeeAllocations>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListPayeeAllocations<TData = Awaited<ReturnType<typeof learningListPayeeAllocations>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, params?: LearningListPayeeAllocationsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListPayeeAllocations>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningListPayeeAllocations>>, TError, Awaited<ReturnType<typeof learningListPayeeAllocations>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListPayeeAllocations<TData = Awaited<ReturnType<typeof learningListPayeeAllocations>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, params?: LearningListPayeeAllocationsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListPayeeAllocations>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningReservePayeeDocumentUrl: (payeeId: number) => string;
+/**
+ * Reserve legal evidence, then PUT exactly sizeBytes raw bytes to uploadUrl with the declared Content-Type. For this purpose only PDF, JPEG and PNG are accepted, with a 10 MiB (10,485,760 byte) maximum despite the broader shared upload schema. Reservation alone does not create a completed legal document; completion validates the bytes. At most ten unexpired pending uploads are allowed per profile. Available to the linked independent rightsholder or catalogue finance/global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Reserve a private rightsholder document upload
+ */
+export declare const learningReservePayeeDocument: (payeeId: number, learningPayeeDocumentUploadWrite: LearningPayeeDocumentUploadWrite, options?: Parameters<typeof request>[1]) => Promise<LearningUploadRead>;
+export declare const getLearningReservePayeeDocumentMutationKey: () => readonly ['learningReservePayeeDocument'];
+export declare const getLearningReservePayeeDocumentMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningReservePayeeDocument>>, TError, LearningReservePayeeDocumentMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningReservePayeeDocument>>, TError, LearningReservePayeeDocumentMutationVariables, TContext>;
+export type LearningReservePayeeDocumentMutationResult = NonNullable<Awaited<ReturnType<typeof learningReservePayeeDocument>>>;
+export type LearningReservePayeeDocumentMutationBody = BodyType<LearningPayeeDocumentUploadWrite>;
+export type LearningReservePayeeDocumentMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningReservePayeeDocumentMutationVariables = {
+  payeeId: number;
+  data: BodyType<LearningPayeeDocumentUploadWrite>;
+};
+/**
+ * @summary Reserve a private rightsholder document upload
+ */
+export declare const useLearningReservePayeeDocument: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningReservePayeeDocument>>, TError, LearningReservePayeeDocumentMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningReservePayeeDocument>>, TError, LearningReservePayeeDocumentMutationVariables, TContext>;
+export declare const getLearningPayeeDocumentsUrl: (payeeId: number, params?: LearningPayeeDocumentsParams) => string;
+/**
+ * List completed document metadata, newest ID first. No file bytes or storage keys appear here; use the scoped document endpoint for delivery. Source creation dates may be unknown. This read also requires high authentication assurance. Available to the linked independent rightsholder or catalogue finance/global commercial authority; support impersonation is refused.
+ * @summary List private rightsholder legal documents
+ */
+export declare const learningPayeeDocuments: (payeeId: number, params?: LearningPayeeDocumentsParams, options?: Parameters<typeof request>[1]) => Promise<LearningPayeeDocumentPage>;
+export declare const getLearningPayeeDocumentsQueryKey: (payeeId: number, params?: LearningPayeeDocumentsParams) => readonly [`/learning/finance/payees/${number}/documents`, ...LearningPayeeDocumentsParams[]];
+export declare const getLearningPayeeDocumentsQueryOptions: <TData = Awaited<ReturnType<typeof learningPayeeDocuments>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, params?: LearningPayeeDocumentsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningPayeeDocuments>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningPayeeDocuments>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningPayeeDocumentsQueryResult = NonNullable<Awaited<ReturnType<typeof learningPayeeDocuments>>>;
+export type LearningPayeeDocumentsQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningPayeeDocuments<TData = Awaited<ReturnType<typeof learningPayeeDocuments>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, params: undefined | LearningPayeeDocumentsParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningPayeeDocuments>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningPayeeDocuments>>, TError, Awaited<ReturnType<typeof learningPayeeDocuments>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningPayeeDocuments<TData = Awaited<ReturnType<typeof learningPayeeDocuments>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, params?: LearningPayeeDocumentsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningPayeeDocuments>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningPayeeDocuments>>, TError, Awaited<ReturnType<typeof learningPayeeDocuments>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningPayeeDocuments<TData = Awaited<ReturnType<typeof learningPayeeDocuments>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, params?: LearningPayeeDocumentsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningPayeeDocuments>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningDownloadPayeeDocumentUrl: (payeeId: number, documentId: number) => string;
+/**
+ * Authorize both the payee and its document, then return a JSON asset descriptor. Follow its url to retrieve PDF/image bytes; this operation itself does not return a binary file. Treat temporary signed delivery URLs as private capabilities. This read requires high authentication assurance. Available to the linked independent rightsholder or catalogue finance/global commercial authority; support impersonation is refused.
+ * @summary Get delivery for a private legal document
+ */
+export declare const learningDownloadPayeeDocument: (payeeId: number, documentId: number, options?: Parameters<typeof request>[1]) => Promise<LearningAssetRead>;
+export declare const getLearningDownloadPayeeDocumentQueryKey: (payeeId: number, documentId: number) => readonly [`/learning/finance/payees/${number}/documents/${number}`];
+export declare const getLearningDownloadPayeeDocumentQueryOptions: <TData = Awaited<ReturnType<typeof learningDownloadPayeeDocument>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, documentId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningDownloadPayeeDocument>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningDownloadPayeeDocument>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningDownloadPayeeDocumentQueryResult = NonNullable<Awaited<ReturnType<typeof learningDownloadPayeeDocument>>>;
+export type LearningDownloadPayeeDocumentQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningDownloadPayeeDocument<TData = Awaited<ReturnType<typeof learningDownloadPayeeDocument>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, documentId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningDownloadPayeeDocument>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningDownloadPayeeDocument>>, TError, Awaited<ReturnType<typeof learningDownloadPayeeDocument>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningDownloadPayeeDocument<TData = Awaited<ReturnType<typeof learningDownloadPayeeDocument>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, documentId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningDownloadPayeeDocument>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningDownloadPayeeDocument>>, TError, Awaited<ReturnType<typeof learningDownloadPayeeDocument>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningDownloadPayeeDocument<TData = Awaited<ReturnType<typeof learningDownloadPayeeDocument>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, documentId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningDownloadPayeeDocument>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningListPayeeSettlementsUrl: (payeeId: number, params?: LearningListPayeeSettlementsParams) => string;
+/**
+ * Page all settlements for this rightsholder, newest year/period/ID first. Each period covers two calendar months. Source component nulls remain unknown even when the displayed payable total applies zero-for-missing arithmetic; an unpaid flag alone is not complete source payment evidence. Available to the linked independent rightsholder or catalogue finance/global commercial authority; support impersonation is refused.
+ * @summary List a rightsholder’s settlements
+ */
+export declare const learningListPayeeSettlements: (payeeId: number, params?: LearningListPayeeSettlementsParams, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltySettlementPage>;
+export declare const getLearningListPayeeSettlementsQueryKey: (payeeId: number, params?: LearningListPayeeSettlementsParams) => readonly [`/learning/finance/payees/${number}/settlements`, ...LearningListPayeeSettlementsParams[]];
+export declare const getLearningListPayeeSettlementsQueryOptions: <TData = Awaited<ReturnType<typeof learningListPayeeSettlements>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, params?: LearningListPayeeSettlementsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListPayeeSettlements>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningListPayeeSettlements>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningListPayeeSettlementsQueryResult = NonNullable<Awaited<ReturnType<typeof learningListPayeeSettlements>>>;
+export type LearningListPayeeSettlementsQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningListPayeeSettlements<TData = Awaited<ReturnType<typeof learningListPayeeSettlements>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, params: undefined | LearningListPayeeSettlementsParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListPayeeSettlements>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningListPayeeSettlements>>, TError, Awaited<ReturnType<typeof learningListPayeeSettlements>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListPayeeSettlements<TData = Awaited<ReturnType<typeof learningListPayeeSettlements>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, params?: LearningListPayeeSettlementsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListPayeeSettlements>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningListPayeeSettlements>>, TError, Awaited<ReturnType<typeof learningListPayeeSettlements>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListPayeeSettlements<TData = Awaited<ReturnType<typeof learningListPayeeSettlements>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(payeeId: number, params?: LearningListPayeeSettlementsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListPayeeSettlements>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningCreatePayeeSettlementUrl: (payeeId: number) => string;
+/**
+ * Require both monthly periods in the same currency to be approved. period 1 means January–February and period 5 means September–October. Organic totals include slices, sales and bonuses; promotional totals include slices. Payable is max(0, organic + promotional + affiliate - advance), rounded half up to two decimals. Matching retries return the existing native settlement; source or conflicting settlements require review. Creation records accounting and initiates no transfer. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Create a two-month rightsholder settlement
+ */
+export declare const learningCreatePayeeSettlement: (payeeId: number, learningRoyaltySettlementWrite: LearningRoyaltySettlementWrite, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltySettlementRead>;
+export declare const getLearningCreatePayeeSettlementMutationKey: () => readonly ['learningCreatePayeeSettlement'];
+export declare const getLearningCreatePayeeSettlementMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningCreatePayeeSettlement>>, TError, LearningCreatePayeeSettlementMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningCreatePayeeSettlement>>, TError, LearningCreatePayeeSettlementMutationVariables, TContext>;
+export type LearningCreatePayeeSettlementMutationResult = NonNullable<Awaited<ReturnType<typeof learningCreatePayeeSettlement>>>;
+export type LearningCreatePayeeSettlementMutationBody = BodyType<LearningRoyaltySettlementWrite>;
+export type LearningCreatePayeeSettlementMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningCreatePayeeSettlementMutationVariables = {
+  payeeId: number;
+  data: BodyType<LearningRoyaltySettlementWrite>;
+};
+/**
+ * @summary Create a two-month rightsholder settlement
+ */
+export declare const useLearningCreatePayeeSettlement: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningCreatePayeeSettlement>>, TError, LearningCreatePayeeSettlementMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningCreatePayeeSettlement>>, TError, LearningCreatePayeeSettlementMutationVariables, TContext>;
+export declare const getLearningReadRoyaltyPeriodUrl: (periodId: number) => string;
+/**
+ * Poll state, inputState and generation after requesting calculation. draft → calculating → calculated → approved; failed input preparation is reported by inputState and inputErrorCode. Read channel budgets for channel-specific failures. Approval requires complete inputs and all current budgets. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused.
+ * @summary Read calculation and approval state
+ */
+export declare const learningReadRoyaltyPeriod: (periodId: number, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyPeriodRead>;
+export declare const getLearningReadRoyaltyPeriodQueryKey: (periodId: number) => readonly [`/learning/finance/periods/${number}`];
+export declare const getLearningReadRoyaltyPeriodQueryOptions: <TData = Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(periodId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningReadRoyaltyPeriodQueryResult = NonNullable<Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>>;
+export type LearningReadRoyaltyPeriodQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningReadRoyaltyPeriod<TData = Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(periodId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>, TError, Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningReadRoyaltyPeriod<TData = Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(periodId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>, TError, Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningReadRoyaltyPeriod<TData = Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(periodId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltyPeriod>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningSetRoyaltyAdjustmentUrl: (periodId: number) => string;
+/**
+ * Replace the signed sale and bonus amounts for one course/payee in this period’s catalogue. Adjustments are attached only to the organic channel during calculation, which requires exactly one organic budget when adjustments exist. Historical, approved and running calculations cannot be edited. Success returns no body. Amounts are decimal major currency units, not integer cents. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Set monthly sales and bonus adjustments
+ */
+export declare const learningSetRoyaltyAdjustment: (periodId: number, learningRoyaltyAdjustmentWrite: LearningRoyaltyAdjustmentWrite, options?: Parameters<typeof request>[1]) => Promise<void>;
+export declare const getLearningSetRoyaltyAdjustmentMutationKey: () => readonly ['learningSetRoyaltyAdjustment'];
+export declare const getLearningSetRoyaltyAdjustmentMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningSetRoyaltyAdjustment>>, TError, LearningSetRoyaltyAdjustmentMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningSetRoyaltyAdjustment>>, TError, LearningSetRoyaltyAdjustmentMutationVariables, TContext>;
+export type LearningSetRoyaltyAdjustmentMutationResult = NonNullable<Awaited<ReturnType<typeof learningSetRoyaltyAdjustment>>>;
+export type LearningSetRoyaltyAdjustmentMutationBody = BodyType<LearningRoyaltyAdjustmentWrite>;
+export type LearningSetRoyaltyAdjustmentMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningSetRoyaltyAdjustmentMutationVariables = {
+  periodId: number;
+  data: BodyType<LearningRoyaltyAdjustmentWrite>;
+};
+/**
+ * @summary Set monthly sales and bonus adjustments
+ */
+export declare const useLearningSetRoyaltyAdjustment: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningSetRoyaltyAdjustment>>, TError, LearningSetRoyaltyAdjustmentMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningSetRoyaltyAdjustment>>, TError, LearningSetRoyaltyAdjustmentMutationVariables, TContext>;
+export declare const getLearningListRoyaltyAllocationsUrl: (periodId: number, params?: LearningListRoyaltyAllocationsParams) => string;
+/**
+ * Page allocations for the period’s current generation, ordered by allocation ID, including unapproved calculation output for review. Within a channel, each subject contributes one unit split across courses in proportion to eligible seconds; course weight sums those fractions. Native percentage is that weight divided by the budget’s subject count times 100. sliceAmount additionally applies rightsholder share and channel coefficient; sales/bonuses are separate organic adjustments. Imported unknown percentages remain null. Amounts are decimal major currency units, not integer cents. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused.
+ * @summary Inspect the month’s current allocations
+ */
+export declare const learningListRoyaltyAllocations: (periodId: number, params?: LearningListRoyaltyAllocationsParams, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyAllocationPage>;
+export declare const getLearningListRoyaltyAllocationsQueryKey: (periodId: number, params?: LearningListRoyaltyAllocationsParams) => readonly [`/learning/finance/periods/${number}/allocations`, ...LearningListRoyaltyAllocationsParams[]];
+export declare const getLearningListRoyaltyAllocationsQueryOptions: <TData = Awaited<ReturnType<typeof learningListRoyaltyAllocations>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(periodId: number, params?: LearningListRoyaltyAllocationsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyAllocations>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyAllocations>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningListRoyaltyAllocationsQueryResult = NonNullable<Awaited<ReturnType<typeof learningListRoyaltyAllocations>>>;
+export type LearningListRoyaltyAllocationsQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningListRoyaltyAllocations<TData = Awaited<ReturnType<typeof learningListRoyaltyAllocations>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(periodId: number, params: undefined | LearningListRoyaltyAllocationsParams, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyAllocations>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningListRoyaltyAllocations>>, TError, Awaited<ReturnType<typeof learningListRoyaltyAllocations>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListRoyaltyAllocations<TData = Awaited<ReturnType<typeof learningListRoyaltyAllocations>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(periodId: number, params?: LearningListRoyaltyAllocationsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyAllocations>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningListRoyaltyAllocations>>, TError, Awaited<ReturnType<typeof learningListRoyaltyAllocations>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListRoyaltyAllocations<TData = Awaited<ReturnType<typeof learningListRoyaltyAllocations>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(periodId: number, params?: LearningListRoyaltyAllocationsParams, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyAllocations>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningApproveRoyaltyCalculationUrl: (periodId: number) => string;
+/**
+ * Make a native month immutable after the input snapshot and every channel budget complete in expectedGeneration. Repeating approval of that same generation returns its approved state. Only approved allocations are visible through payee allocation history and eligible for settlement. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Approve a completed royalty generation
+ */
+export declare const learningApproveRoyaltyCalculation: (periodId: number, learningRoyaltyApprovalWrite: LearningRoyaltyApprovalWrite, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyPeriodRead>;
+export declare const getLearningApproveRoyaltyCalculationMutationKey: () => readonly ['learningApproveRoyaltyCalculation'];
+export declare const getLearningApproveRoyaltyCalculationMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningApproveRoyaltyCalculation>>, TError, LearningApproveRoyaltyCalculationMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningApproveRoyaltyCalculation>>, TError, LearningApproveRoyaltyCalculationMutationVariables, TContext>;
+export type LearningApproveRoyaltyCalculationMutationResult = NonNullable<Awaited<ReturnType<typeof learningApproveRoyaltyCalculation>>>;
+export type LearningApproveRoyaltyCalculationMutationBody = BodyType<LearningRoyaltyApprovalWrite>;
+export type LearningApproveRoyaltyCalculationMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningApproveRoyaltyCalculationMutationVariables = {
+  periodId: number;
+  data: BodyType<LearningRoyaltyApprovalWrite>;
+};
+/**
+ * @summary Approve a completed royalty generation
+ */
+export declare const useLearningApproveRoyaltyCalculation: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningApproveRoyaltyCalculation>>, TError, LearningApproveRoyaltyCalculationMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningApproveRoyaltyCalculation>>, TError, LearningApproveRoyaltyCalculationMutationVariables, TContext>;
+export declare const getLearningListRoyaltyBudgetsUrl: (periodId: number) => string;
+/**
+ * List every budget for the month, ordered by ID. Compare each budget generation with its period before reviewing results. inputSubjectCount is the distinct subject denominator of the frozen activity population, not minutes or lesson counts. Amounts are decimal major currency units, not integer cents. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused.
+ * @summary List channel budgets and calculation results
+ */
+export declare const learningListRoyaltyBudgets: (periodId: number, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyBudgetListRead>;
+export declare const getLearningListRoyaltyBudgetsQueryKey: (periodId: number) => readonly [`/learning/finance/periods/${number}/budgets`];
+export declare const getLearningListRoyaltyBudgetsQueryOptions: <TData = Awaited<ReturnType<typeof learningListRoyaltyBudgets>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(periodId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyBudgets>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyBudgets>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningListRoyaltyBudgetsQueryResult = NonNullable<Awaited<ReturnType<typeof learningListRoyaltyBudgets>>>;
+export type LearningListRoyaltyBudgetsQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningListRoyaltyBudgets<TData = Awaited<ReturnType<typeof learningListRoyaltyBudgets>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(periodId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyBudgets>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningListRoyaltyBudgets>>, TError, Awaited<ReturnType<typeof learningListRoyaltyBudgets>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListRoyaltyBudgets<TData = Awaited<ReturnType<typeof learningListRoyaltyBudgets>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(periodId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyBudgets>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningListRoyaltyBudgets>>, TError, Awaited<ReturnType<typeof learningListRoyaltyBudgets>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningListRoyaltyBudgets<TData = Awaited<ReturnType<typeof learningListRoyaltyBudgets>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(periodId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningListRoyaltyBudgets>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningSetRoyaltyBudgetUrl: (periodId: number) => string;
+/**
+ * Create or replace the channel budget for an editable period. amount is nonnegative with at most eight decimal places and 24 total digits, in the period’s currency. Editing calculated inputs advances the period generation and returns it to draft; historical, approved and running calculations cannot be edited. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Set a channel’s monthly royalty pool
+ */
+export declare const learningSetRoyaltyBudget: (periodId: number, learningRoyaltyBudgetWrite: LearningRoyaltyBudgetWrite, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyBudgetRead>;
+export declare const getLearningSetRoyaltyBudgetMutationKey: () => readonly ['learningSetRoyaltyBudget'];
+export declare const getLearningSetRoyaltyBudgetMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningSetRoyaltyBudget>>, TError, LearningSetRoyaltyBudgetMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningSetRoyaltyBudget>>, TError, LearningSetRoyaltyBudgetMutationVariables, TContext>;
+export type LearningSetRoyaltyBudgetMutationResult = NonNullable<Awaited<ReturnType<typeof learningSetRoyaltyBudget>>>;
+export type LearningSetRoyaltyBudgetMutationBody = BodyType<LearningRoyaltyBudgetWrite>;
+export type LearningSetRoyaltyBudgetMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningSetRoyaltyBudgetMutationVariables = {
+  periodId: number;
+  data: BodyType<LearningRoyaltyBudgetWrite>;
+};
+/**
+ * @summary Set a channel’s monthly royalty pool
+ */
+export declare const useLearningSetRoyaltyBudget: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningSetRoyaltyBudget>>, TError, LearningSetRoyaltyBudgetMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningSetRoyaltyBudget>>, TError, LearningSetRoyaltyBudgetMutationVariables, TContext>;
+export declare const getLearningRequestRoyaltyCalculationUrl: (periodId: number) => string;
+/**
+ * Freeze applicable agreements, channels, adjustments and activity cutoff, then queue input and channel processing. The month must have closed in Europe/Paris and have at least one active channel budget. Poll the period and budgets. Repeating while calculating requeues failed work without replacing frozen facts; an already calculated period returns its current result. HTTP 202 is acceptance, not approval or payment. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Queue a closed month’s royalty calculation
+ */
+export declare const learningRequestRoyaltyCalculation: (periodId: number, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyPeriodRead>;
+export declare const getLearningRequestRoyaltyCalculationMutationKey: () => readonly ['learningRequestRoyaltyCalculation'];
+export declare const getLearningRequestRoyaltyCalculationMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningRequestRoyaltyCalculation>>, TError, LearningRequestRoyaltyCalculationMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningRequestRoyaltyCalculation>>, TError, LearningRequestRoyaltyCalculationMutationVariables, TContext>;
+export type LearningRequestRoyaltyCalculationMutationResult = NonNullable<Awaited<ReturnType<typeof learningRequestRoyaltyCalculation>>>;
+export type LearningRequestRoyaltyCalculationMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningRequestRoyaltyCalculationMutationVariables = {
+  periodId: number;
+};
+/**
+ * @summary Queue a closed month’s royalty calculation
+ */
+export declare const useLearningRequestRoyaltyCalculation: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningRequestRoyaltyCalculation>>, TError, LearningRequestRoyaltyCalculationMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningRequestRoyaltyCalculation>>, TError, LearningRequestRoyaltyCalculationMutationVariables, TContext>;
+export declare const getLearningResetRoyaltyCalculationUrl: (periodId: number) => string;
+/**
+ * Require the generation just reviewed, advance it, clear frozen inputs and worker claims, and reset channel budgets to draft. This permits corrected inputs after a failed or unwanted calculation. Historical and approved months are immutable. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Invalidate an unapproved calculation
+ */
+export declare const learningResetRoyaltyCalculation: (periodId: number, learningRoyaltyApprovalWrite: LearningRoyaltyApprovalWrite, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyPeriodRead>;
+export declare const getLearningResetRoyaltyCalculationMutationKey: () => readonly ['learningResetRoyaltyCalculation'];
+export declare const getLearningResetRoyaltyCalculationMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningResetRoyaltyCalculation>>, TError, LearningResetRoyaltyCalculationMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningResetRoyaltyCalculation>>, TError, LearningResetRoyaltyCalculationMutationVariables, TContext>;
+export type LearningResetRoyaltyCalculationMutationResult = NonNullable<Awaited<ReturnType<typeof learningResetRoyaltyCalculation>>>;
+export type LearningResetRoyaltyCalculationMutationBody = BodyType<LearningRoyaltyApprovalWrite>;
+export type LearningResetRoyaltyCalculationMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningResetRoyaltyCalculationMutationVariables = {
+  periodId: number;
+  data: BodyType<LearningRoyaltyApprovalWrite>;
+};
+/**
+ * @summary Invalidate an unapproved calculation
+ */
+export declare const useLearningResetRoyaltyCalculation: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningResetRoyaltyCalculation>>, TError, LearningResetRoyaltyCalculationMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningResetRoyaltyCalculation>>, TError, LearningResetRoyaltyCalculationMutationVariables, TContext>;
+export declare const getLearningReadRoyaltySettlementUrl: (settlementId: number) => string;
+/**
+ * Read the two-month components, computed payable amount and recorded payment status. A historical settlement without a resolved payee requires catalogue finance authority; otherwise the linked rightsholder may read it. Amounts are decimal major currency units, not integer cents. Available to the linked independent rightsholder or catalogue finance/global commercial authority; support impersonation is refused.
+ * @summary Read a rightsholder settlement
+ */
+export declare const learningReadRoyaltySettlement: (settlementId: number, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltySettlementRead>;
+export declare const getLearningReadRoyaltySettlementQueryKey: (settlementId: number) => readonly [`/learning/finance/settlements/${number}`];
+export declare const getLearningReadRoyaltySettlementQueryOptions: <TData = Awaited<ReturnType<typeof learningReadRoyaltySettlement>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(settlementId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltySettlement>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}) => UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltySettlement>>, TError, TData> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type LearningReadRoyaltySettlementQueryResult = NonNullable<Awaited<ReturnType<typeof learningReadRoyaltySettlement>>>;
+export type LearningReadRoyaltySettlementQueryError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export declare function useLearningReadRoyaltySettlement<TData = Awaited<ReturnType<typeof learningReadRoyaltySettlement>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(settlementId: number, options: {
+  query: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltySettlement>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof learningReadRoyaltySettlement>>, TError, Awaited<ReturnType<typeof learningReadRoyaltySettlement>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningReadRoyaltySettlement<TData = Awaited<ReturnType<typeof learningReadRoyaltySettlement>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(settlementId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltySettlement>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof learningReadRoyaltySettlement>>, TError, Awaited<ReturnType<typeof learningReadRoyaltySettlement>>>, 'initialData'>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useLearningReadRoyaltySettlement<TData = Awaited<ReturnType<typeof learningReadRoyaltySettlement>>, TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>>(settlementId: number, options?: {
+  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof learningReadRoyaltySettlement>>, TError, TData>>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+  queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare const getLearningIssueRoyaltyInvoiceUrl: (settlementId: number) => string;
+/**
+ * Snapshot the rightsholder’s complete billing address, recipient, settlement net amount and percentage tax rate. Generate a native number per payee/year. Matching recipient/tax retries return the existing invoice; issued facts cannot be replaced. The example EUR 590 net at 20% produces EUR 118 tax and EUR 708 total in the PDF. Issuance does not mark the settlement paid. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Issue an immutable royalty invoice
+ */
+export declare const learningIssueRoyaltyInvoice: (settlementId: number, learningRoyaltyInvoiceWrite: LearningRoyaltyInvoiceWrite, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltyInvoiceRead>;
+export declare const getLearningIssueRoyaltyInvoiceMutationKey: () => readonly ['learningIssueRoyaltyInvoice'];
+export declare const getLearningIssueRoyaltyInvoiceMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningIssueRoyaltyInvoice>>, TError, LearningIssueRoyaltyInvoiceMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningIssueRoyaltyInvoice>>, TError, LearningIssueRoyaltyInvoiceMutationVariables, TContext>;
+export type LearningIssueRoyaltyInvoiceMutationResult = NonNullable<Awaited<ReturnType<typeof learningIssueRoyaltyInvoice>>>;
+export type LearningIssueRoyaltyInvoiceMutationBody = BodyType<LearningRoyaltyInvoiceWrite>;
+export type LearningIssueRoyaltyInvoiceMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningIssueRoyaltyInvoiceMutationVariables = {
+  settlementId: number;
+  data: BodyType<LearningRoyaltyInvoiceWrite>;
+};
+/**
+ * @summary Issue an immutable royalty invoice
+ */
+export declare const useLearningIssueRoyaltyInvoice: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningIssueRoyaltyInvoice>>, TError, LearningIssueRoyaltyInvoiceMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningIssueRoyaltyInvoice>>, TError, LearningIssueRoyaltyInvoiceMutationVariables, TContext>;
+export declare const getLearningRecordRoyaltyPaymentUrl: (settlementId: number) => string;
+/**
+ * Mark the settlement paid using external accounting evidence and record the current time as paidAt. This operation never initiates a bank transfer or sends money. A matching paymentReference is idempotent; different existing evidence conflicts. Historical unresolved payee/payment facts must first be reconciled. Available to an independent profile with this catalogue’s finance grant or global commercial authority; support impersonation is refused. Mutations require high authentication assurance.
+ * @summary Record an observed royalty payment
+ */
+export declare const learningRecordRoyaltyPayment: (settlementId: number, learningRoyaltyPaidWrite: LearningRoyaltyPaidWrite, options?: Parameters<typeof request>[1]) => Promise<LearningRoyaltySettlementRead>;
+export declare const getLearningRecordRoyaltyPaymentMutationKey: () => readonly ['learningRecordRoyaltyPayment'];
+export declare const getLearningRecordRoyaltyPaymentMutationOptions: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningRecordRoyaltyPayment>>, TError, LearningRecordRoyaltyPaymentMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}) => UseMutationOptions<Awaited<ReturnType<typeof learningRecordRoyaltyPayment>>, TError, LearningRecordRoyaltyPaymentMutationVariables, TContext>;
+export type LearningRecordRoyaltyPaymentMutationResult = NonNullable<Awaited<ReturnType<typeof learningRecordRoyaltyPayment>>>;
+export type LearningRecordRoyaltyPaymentMutationBody = BodyType<LearningRoyaltyPaidWrite>;
+export type LearningRecordRoyaltyPaymentMutationError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>;
+export type LearningRecordRoyaltyPaymentMutationVariables = {
+  settlementId: number;
+  data: BodyType<LearningRoyaltyPaidWrite>;
+};
+/**
+ * @summary Record an observed royalty payment
+ */
+export declare const useLearningRecordRoyaltyPayment: <TError = ErrorType<HTTPExceptionResponse | ValidationErrorResponse>, TContext = unknown>(options?: {
+  mutation?: UseMutationOptions<Awaited<ReturnType<typeof learningRecordRoyaltyPayment>>, TError, LearningRecordRoyaltyPaymentMutationVariables, TContext>;
+  request?: SecondParameter<typeof request>;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof learningRecordRoyaltyPayment>>, TError, LearningRecordRoyaltyPaymentMutationVariables, TContext>;
+//#endregion
+//# sourceMappingURL=biblio-learning-finance.d.ts.map