@learnorama/mozaik-sdk 0.12.3-staging.46.1 → 0.13.0-staging.48.1

package/dist/react/biblio-learning.js

@@ -0,0 +1,1667 @@
+"use client";
+import { r as request } from "../chunks/client.js";
+import { useMutation, useQuery } from "@tanstack/react-query";
+//#region src/react/biblio-learning/biblio-learning.ts
+/**
+* Generated by orval 🍺
+* Do not edit manually.
+* Mozaik backend
+* Four products behind one API — Biblio, Médiathèques, the partner catalogues (Nextory and YouScribe) and Prof Express. Authentication is Keycloak SSO only, once, for all of them: see the **auth** section below for the browser flow and the three failure modes.
+* OpenAPI spec version: 0.13.0
+*/
+const withQueryKey = (query, queryKey) => {
+	const result = { queryKey };
+	for (const key of Object.keys(query)) {
+		if (key === "queryKey") continue;
+		Object.defineProperty(result, key, {
+			enumerable: true,
+			configurable: true,
+			get: () => query[key]
+		});
+	}
+	return result;
+};
+const getLearningStartAttemptUrl = (assessmentId) => {
+	return `/learning/assessments/${assessmentId}/attempts`;
+};
+/**
+* Creates an immutable snapshot of the selected questions, ordering and pages. Course attempts need the profile's open reading session; provide lessonId when the assessment appears in multiple lessons. A lessonId without sessionId requests an allowed free preview. Path assessments use neither course session nor lesson. requestKey is scoped to profile and assessment: identical context replays the existing attempt; changed lesson/session context returns 409. Deadlines and attempt limits are enforced by the server. Preview results do not update course progress or score summaries.
+* @summary Start or replay a scoped assessment attempt
+*/
+const learningStartAttempt = async (assessmentId, learningAttemptStartWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningStartAttemptUrl(assessmentId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningAttemptStartWrite)
+	});
+};
+const getLearningStartAttemptMutationKey = () => ["learningStartAttempt"];
+const getLearningStartAttemptMutationOptions = (options) => {
+	const mutationKey = getLearningStartAttemptMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { assessmentId, data } = props ?? {};
+		return learningStartAttempt(assessmentId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Start or replay a scoped assessment attempt
+*/
+const useLearningStartAttempt = (options, queryClient) => {
+	return useMutation(getLearningStartAttemptMutationOptions(options), queryClient);
+};
+const getLearningReadAttemptUrl = (attemptId) => {
+	return `/learning/attempts/${attemptId}`;
+};
+/**
+* Returns only an attempt owned by the effective profile. In-progress native attempts recheck their learning context; completed and historical evidence remains readable by its owner. Public questions never include answer keys. Corrections and answer grades appear after completion/expiry, or for answered questions when immediate feedback is configured. Historical attempts return retained answers and scores without inventing a replayable question definition. This read does not itself finalize an elapsed deadline.
+* @summary Read the profile's attempt and available feedback
+*/
+const learningReadAttempt = async (attemptId, options) => {
+	return request(getLearningReadAttemptUrl(attemptId), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningReadAttemptQueryKey = (attemptId) => {
+	return [`/learning/attempts/${attemptId}`];
+};
+const getLearningReadAttemptQueryOptions = (attemptId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningReadAttemptQueryKey(attemptId);
+	const queryFn = ({ signal }) => learningReadAttempt(attemptId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: attemptId !== null && attemptId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Read the profile's attempt and available feedback
+*/
+function useLearningReadAttempt(attemptId, options, queryClient) {
+	const queryOptions = getLearningReadAttemptQueryOptions(attemptId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningAbandonAttemptUrl = (attemptId) => {
+	return `/learning/attempts/${attemptId}/abandon`;
+};
+/**
+* Changes the effective profile's in-progress native attempt to abandoned and records finishedAt. Saved responses remain in history; abandoning does not calculate a score or grant completion. Repeating an abandoned or other terminal native attempt returns its existing state. Imported attempts are historical evidence and cannot be abandoned.
+* @summary Abandon an unfinished native attempt
+*/
+const learningAbandonAttempt = async (attemptId, options) => {
+	return request(getLearningAbandonAttemptUrl(attemptId), {
+		...options,
+		method: "POST"
+	});
+};
+const getLearningAbandonAttemptMutationKey = () => ["learningAbandonAttempt"];
+const getLearningAbandonAttemptMutationOptions = (options) => {
+	const mutationKey = getLearningAbandonAttemptMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { attemptId } = props ?? {};
+		return learningAbandonAttempt(attemptId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Abandon an unfinished native attempt
+*/
+const useLearningAbandonAttempt = (options, queryClient) => {
+	return useMutation(getLearningAbandonAttemptMutationOptions(options), queryClient);
+};
+const getLearningAnswerQuestionUrl = (attemptId, questionKey) => {
+	return `/learning/attempts/${attemptId}/answers/${questionKey}`;
+};
+/**
+* Use the selected question's key and kind-specific response object. Before finalization answers can be replaced unless immediate feedback has made the first response final. An identical saved response can be replayed after finalization; a different final answer returns 409. An elapsed deadline finalizes the attempt as expired and rejects the late answer. Uploaded reflection answers must reference this profile's completed upload reserved for this exact attempt and question. The response returns the entire attempt with only currently authorized feedback.
+* @summary Save a question response in the owned attempt
+*/
+const learningAnswerQuestion = async (attemptId, questionKey, learningAnswerWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningAnswerQuestionUrl(attemptId, questionKey), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningAnswerWrite)
+	});
+};
+const getLearningAnswerQuestionMutationKey = () => ["learningAnswerQuestion"];
+const getLearningAnswerQuestionMutationOptions = (options) => {
+	const mutationKey = getLearningAnswerQuestionMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { attemptId, questionKey, data } = props ?? {};
+		return learningAnswerQuestion(attemptId, questionKey, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Save a question response in the owned attempt
+*/
+const useLearningAnswerQuestion = (options, queryClient) => {
+	return useMutation(getLearningAnswerQuestionMutationOptions(options), queryClient);
+};
+const getLearningFinishAttemptUrl = (attemptId) => {
+	return `/learning/attempts/${attemptId}/finish`;
+};
+/**
+* Requires the owned attempt's learning context. Before its deadline every selected question must have a response, including reflection and information acknowledgements. After the deadline the attempt is finalized as expired, with unanswered scored questions counted as zero. Returns corrections and a percentage score, or null for an unscored assessment. Eligible native results update score summaries and completion evidence; preview results do not. Repeating a terminal attempt returns its existing state.
+* @summary Finalize answers and compute assessment results
+*/
+const learningFinishAttempt = async (attemptId, options) => {
+	return request(getLearningFinishAttemptUrl(attemptId), {
+		...options,
+		method: "POST"
+	});
+};
+const getLearningFinishAttemptMutationKey = () => ["learningFinishAttempt"];
+const getLearningFinishAttemptMutationOptions = (options) => {
+	const mutationKey = getLearningFinishAttemptMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { attemptId } = props ?? {};
+		return learningFinishAttempt(attemptId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Finalize answers and compute assessment results
+*/
+const useLearningFinishAttempt = (options, queryClient) => {
+	return useMutation(getLearningFinishAttemptMutationOptions(options), queryClient);
+};
+const getLearningRateExercisePageUrl = (attemptId, pageKey) => {
+	return `/learning/attempts/${attemptId}/pages/${pageKey}/self-rating`;
+};
+/**
+* Requires an owned native exercise attempt containing pageKey and full learning access. Saves a rating from 1 to 5 for this profile and exercise page; later submissions replace the rating and mark the page's self-reflection complete. Preview attempts cannot save ratings. This does not submit answers, award points or substitute for assessment completion.
+* @summary Save a private exercise-page self-rating
+*/
+const learningRateExercisePage = async (attemptId, pageKey, learningSelfRatingWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningRateExercisePageUrl(attemptId, pageKey), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningSelfRatingWrite)
+	});
+};
+const getLearningRateExercisePageMutationKey = () => ["learningRateExercisePage"];
+const getLearningRateExercisePageMutationOptions = (options) => {
+	const mutationKey = getLearningRateExercisePageMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { attemptId, pageKey, data } = props ?? {};
+		return learningRateExercisePage(attemptId, pageKey, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Save a private exercise-page self-rating
+*/
+const useLearningRateExercisePage = (options, queryClient) => {
+	return useMutation(getLearningRateExercisePageMutationOptions(options), queryClient);
+};
+const getLearningReserveExerciseUploadUrl = (attemptId, questionKey) => {
+	return `/learning/attempts/${attemptId}/questions/${questionKey}/uploads`;
+};
+/**
+* Requires the effective profile's in-progress, unexpired native attempt and a reflection question configured for upload or text_or_upload. The MIME type must map to one of that question's allowedUploadKinds; exercise files are limited to 50 MiB (WebVTT remains limited to 2 MiB). Reserve, PUT the exact bytes to uploadUrl, then submit response.assetId using the answer operation. The uploaded asset remains scoped to this profile, attempt and question; reservation alone does not answer it.
+* @summary Reserve a private uploaded reflection answer
+*/
+const learningReserveExerciseUpload = async (attemptId, questionKey, learningUploadWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningReserveExerciseUploadUrl(attemptId, questionKey), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningUploadWrite)
+	});
+};
+const getLearningReserveExerciseUploadMutationKey = () => ["learningReserveExerciseUpload"];
+const getLearningReserveExerciseUploadMutationOptions = (options) => {
+	const mutationKey = getLearningReserveExerciseUploadMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { attemptId, questionKey, data } = props ?? {};
+		return learningReserveExerciseUpload(attemptId, questionKey, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Reserve a private uploaded reflection answer
+*/
+const useLearningReserveExerciseUpload = (options, queryClient) => {
+	return useMutation(getLearningReserveExerciseUploadMutationOptions(options), queryClient);
+};
+const getLearningReadAttemptResourceUrl = (attemptId, assetId) => {
+	return `/learning/attempts/${attemptId}/resources/${assetId}`;
+};
+/**
+* Checks the profile's ownership and retained assessment context. Permits selected question/page media, allowed choice media and public hints. Correction resources become available after completion/expiry or after the corresponding answer when immediate feedback is configured. A submitted reflection upload is accessible only through its owning attempt and question. Resource IDs outside this authorized set return 404; returned delivery URLs may expire.
+* @summary Resolve a resource authorized by the owned attempt
+*/
+const learningReadAttemptResource = async (attemptId, assetId, options) => {
+	return request(getLearningReadAttemptResourceUrl(attemptId, assetId), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningReadAttemptResourceQueryKey = (attemptId, assetId) => {
+	return [`/learning/attempts/${attemptId}/resources/${assetId}`];
+};
+const getLearningReadAttemptResourceQueryOptions = (attemptId, assetId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningReadAttemptResourceQueryKey(attemptId, assetId);
+	const queryFn = ({ signal }) => learningReadAttemptResource(attemptId, assetId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: attemptId !== null && attemptId !== void 0 && assetId !== null && assetId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Resolve a resource authorized by the owned attempt
+*/
+function useLearningReadAttemptResource(attemptId, assetId, options, queryClient) {
+	const queryOptions = getLearningReadAttemptResourceQueryOptions(attemptId, assetId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningReserveCourseUploadUrl = (courseId) => {
+	return `/learning/author/courses/${courseId}/uploads`;
+};
+/**
+* Requires edit authority on courseId. Reserves one immutable file with an exact byte count and declared MIME type for 15 minutes. Course files are limited to 200 MiB; WebVTT captions to 2 MiB. At most ten unexpired pending uploads may exist per profile. Send the raw bytes with authenticated PUT to uploadUrl, then use its returned assetId in the course definition. Each reservation request creates a new reservation.
+* @summary Reserve a file upload for course authoring
+*/
+const learningReserveCourseUpload = async (courseId, learningUploadWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningReserveCourseUploadUrl(courseId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningUploadWrite)
+	});
+};
+const getLearningReserveCourseUploadMutationKey = () => ["learningReserveCourseUpload"];
+const getLearningReserveCourseUploadMutationOptions = (options) => {
+	const mutationKey = getLearningReserveCourseUploadMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { courseId, data } = props ?? {};
+		return learningReserveCourseUpload(courseId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Reserve a file upload for course authoring
+*/
+const useLearningReserveCourseUpload = (options, queryClient) => {
+	return useMutation(getLearningReserveCourseUploadMutationOptions(options), queryClient);
+};
+const getLearningReadCertificateUrl = (certificateId) => {
+	return `/learning/certificates/${certificateId}`;
+};
+/**
+* Returns the immutable recipient, course title, edition and issuance date recorded for this profile's certificate. Another profile's certificate is not visible. This read does not require opening a new course session; documentUrl identifies the separately authenticated PDF download.
+* @summary Read an issued certificate owned by the profile
+*/
+const learningReadCertificate = async (certificateId, options) => {
+	return request(getLearningReadCertificateUrl(certificateId), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningReadCertificateQueryKey = (certificateId) => {
+	return [`/learning/certificates/${certificateId}`];
+};
+const getLearningReadCertificateQueryOptions = (certificateId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningReadCertificateQueryKey(certificateId);
+	const queryFn = ({ signal }) => learningReadCertificate(certificateId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: certificateId !== null && certificateId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Read an issued certificate owned by the profile
+*/
+function useLearningReadCertificate(certificateId, options, queryClient) {
+	const queryOptions = getLearningReadCertificateQueryOptions(certificateId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningDownloadCertificateUrl = (certificateId) => {
+	return `/learning/certificates/${certificateId}/document`;
+};
+/**
+* Renders the certificate's retained recipient name, course title and issuance evidence as a PDF attachment. Only the effective profile that owns the certificate can download it. The successful response is application/pdf bytes with Content-Disposition attachment and private, no-store caching; it has no JSON body.
+* @summary Download an owned completion certificate as PDF
+*/
+const learningDownloadCertificate = async (certificateId, options) => {
+	return request(getLearningDownloadCertificateUrl(certificateId), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningDownloadCertificateQueryKey = (certificateId) => {
+	return [`/learning/certificates/${certificateId}/document`];
+};
+const getLearningDownloadCertificateQueryOptions = (certificateId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningDownloadCertificateQueryKey(certificateId);
+	const queryFn = ({ signal }) => learningDownloadCertificate(certificateId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: certificateId !== null && certificateId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Download an owned completion certificate as PDF
+*/
+function useLearningDownloadCertificate(certificateId, options, queryClient) {
+	const queryOptions = getLearningDownloadCertificateQueryOptions(certificateId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningReadCourseUrl = (courseId) => {
+	return `/learning/courses/${courseId}`;
+};
+/**
+* Returns the effective profile's enrolled edition, or the latest published edition before enrollment. Eligibility uses the shared profile, age, category and entitlement rules; an allowed preview may expose the outline with hasFullAccess=false. This GET creates no enrollment or reading session. Check upgradeAvailable and latestRevisionId before offering an explicit edition upgrade. Lesson progress and final assessment IDs are included only with full access.
+* @summary Read the selected course edition and progress
+*/
+const learningReadCourse = async (courseId, options) => {
+	return request(getLearningReadCourseUrl(courseId), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningReadCourseQueryKey = (courseId) => {
+	return [`/learning/courses/${courseId}`];
+};
+const getLearningReadCourseQueryOptions = (courseId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningReadCourseQueryKey(courseId);
+	const queryFn = ({ signal }) => learningReadCourse(courseId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: courseId !== null && courseId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Read the selected course edition and progress
+*/
+function useLearningReadCourse(courseId, options, queryClient) {
+	const queryOptions = getLearningReadCourseQueryOptions(courseId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningIssueCertificateUrl = (courseId) => {
+	return `/learning/courses/${courseId}/certificate`;
+};
+/**
+* Requires an existing current enrollment in a course with certification enabled. Recomputes evidence: every required lesson must be complete and every required assessment passed. Creates one certificate per profile and edition, retaining recipient name and course title as issued; repeating issuance returns the existing certificate. Evidence can support issuance without a new reading session. Use documentUrl to download the PDF.
+* @summary Issue the profile's course completion certificate
+*/
+const learningIssueCertificate = async (courseId, options) => {
+	return request(getLearningIssueCertificateUrl(courseId), {
+		...options,
+		method: "POST"
+	});
+};
+const getLearningIssueCertificateMutationKey = () => ["learningIssueCertificate"];
+const getLearningIssueCertificateMutationOptions = (options) => {
+	const mutationKey = getLearningIssueCertificateMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { courseId } = props ?? {};
+		return learningIssueCertificate(courseId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Issue the profile's course completion certificate
+*/
+const useLearningIssueCertificate = (options, queryClient) => {
+	return useMutation(getLearningIssueCertificateMutationOptions(options), queryClient);
+};
+const getLearningEnrollUrl = (courseId) => {
+	return `/learning/courses/${courseId}/enrollment`;
+};
+/**
+* Requires full access for the effective profile. Creates a current enrollment pinned to the published edition if none exists; otherwise retains the selected edition and progress. archived controls the reader's personal archive preference. Repeating the same preference does not duplicate enrollment. Opening a reading session is a separate explicit step.
+* @summary Enroll in the course or set its archive preference
+*/
+const learningEnroll = async (courseId, courseEnrollmentWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningEnrollUrl(courseId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(courseEnrollmentWrite)
+	});
+};
+const getLearningEnrollMutationKey = () => ["learningEnroll"];
+const getLearningEnrollMutationOptions = (options) => {
+	const mutationKey = getLearningEnrollMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { courseId, data } = props ?? {};
+		return learningEnroll(courseId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Enroll in the course or set its archive preference
+*/
+const useLearningEnroll = (options, queryClient) => {
+	return useMutation(getLearningEnrollMutationOptions(options), queryClient);
+};
+const getLearningReadEnrollmentHistoryUrl = (courseId, params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/learning/courses/${courseId}/enrollments?${stringifiedParams}` : `/learning/courses/${courseId}/enrollments`;
+};
+/**
+* Requires current full course access and returns this profile's enrollments only, newest enrollment ID first. isCurrent identifies the selected edition; archived is a personal list preference independent of edition selection. Earlier progress and completedAt are preserved after an upgrade.
+* @summary List the profile's course enrollments by edition
+*/
+const learningReadEnrollmentHistory = async (courseId, params, options) => {
+	return request(getLearningReadEnrollmentHistoryUrl(courseId, params), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningReadEnrollmentHistoryQueryKey = (courseId, params) => {
+	return [`/learning/courses/${courseId}/enrollments`, ...params ? [params] : []];
+};
+const getLearningReadEnrollmentHistoryQueryOptions = (courseId, params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningReadEnrollmentHistoryQueryKey(courseId, params);
+	const queryFn = ({ signal }) => learningReadEnrollmentHistory(courseId, params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: courseId !== null && courseId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary List the profile's course enrollments by edition
+*/
+function useLearningReadEnrollmentHistory(courseId, params, options, queryClient) {
+	const queryOptions = getLearningReadEnrollmentHistoryQueryOptions(courseId, params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningStartSessionUrl = (courseId) => {
+	return `/learning/courses/${courseId}/sessions`;
+};
+/**
+* Requires full course access, creates enrollment if needed and opens a shared consumption lease pinned to the selected edition. Generate requestKey once for the opening action and reuse it after uncertain network outcomes. The key is scoped to the effective profile: the same course returns its existing session, including a closed one; reuse for another course returns 409. Use a new key for a new reading session, then open a lesson with the returned sessionId.
+* @summary Open an entitled course reading session
+*/
+const learningStartSession = async (courseId, learningSessionStartWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningStartSessionUrl(courseId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningSessionStartWrite)
+	});
+};
+const getLearningStartSessionMutationKey = () => ["learningStartSession"];
+const getLearningStartSessionMutationOptions = (options) => {
+	const mutationKey = getLearningStartSessionMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { courseId, data } = props ?? {};
+		return learningStartSession(courseId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Open an entitled course reading session
+*/
+const useLearningStartSession = (options, queryClient) => {
+	return useMutation(getLearningStartSessionMutationOptions(options), queryClient);
+};
+const getLearningUpgradeCourseEditionUrl = (courseId) => {
+	return `/learning/courses/${courseId}/upgrade-edition`;
+};
+/**
+* Requires full course access and an existing current enrollment. Send its revisionId as expectedRevisionId and latestRevisionId as targetRevisionId. Closes open course reading sessions, retains earlier enrollment and completion evidence, and selects the target edition without copying old lesson progress. Repeating the same target succeeds; stale expectations or a target other than the latest publication return 409.
+* @summary Move enrollment to the latest published edition
+*/
+const learningUpgradeCourseEdition = async (courseId, courseEditionUpgradeWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningUpgradeCourseEditionUrl(courseId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(courseEditionUpgradeWrite)
+	});
+};
+const getLearningUpgradeCourseEditionMutationKey = () => ["learningUpgradeCourseEdition"];
+const getLearningUpgradeCourseEditionMutationOptions = (options) => {
+	const mutationKey = getLearningUpgradeCourseEditionMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { courseId, data } = props ?? {};
+		return learningUpgradeCourseEdition(courseId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Move enrollment to the latest published edition
+*/
+const useLearningUpgradeCourseEdition = (options, queryClient) => {
+	return useMutation(getLearningUpgradeCourseEditionMutationOptions(options), queryClient);
+};
+const getLearningAnswerSelectionEvidenceUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/learning/history/answer-selections?${stringifiedParams}` : `/learning/history/answer-selections`;
+};
+/**
+* Returns evidence owned by the effective profile and rejects support impersonation. Resource identifiers do not authorize access to another learner. Source flags and counters are reported evidence, not newly computed grades. Missing dates, links and scoring remain null; a recorded completion flag does not establish a native pass result. attemptId selects an owned historical attempt; unlinkedOnly=true selects rows with no stored attempt link and cannot be combined with attemptId. Optional object filters apply within that same ownership scope. Results are ordered by history ID descending and paginated after filtering. questionId optionally filters by a local question mapping. choiceId, questionId, componentKey and attemptId may be incomplete. A null attemptId in the response does not create a synthetic attempt. Selection records reveal what was retained, without reconstructing correctness or scores.
+* @summary List my historical answer selections
+*/
+const learningAnswerSelectionEvidence = async (params, options) => {
+	return request(getLearningAnswerSelectionEvidenceUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningAnswerSelectionEvidenceQueryKey = (params) => {
+	return [`/learning/history/answer-selections`, ...params ? [params] : []];
+};
+const getLearningAnswerSelectionEvidenceQueryOptions = (params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningAnswerSelectionEvidenceQueryKey(params);
+	const queryFn = ({ signal }) => learningAnswerSelectionEvidence(params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary List my historical answer selections
+*/
+function useLearningAnswerSelectionEvidence(params, options, queryClient) {
+	const queryOptions = getLearningAnswerSelectionEvidenceQueryOptions(params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningAnswerSelectionDetailUrl = (historyId) => {
+	return `/learning/history/answer-selections/${historyId}`;
+};
+/**
+* Returns evidence owned by the effective profile and rejects support impersonation. Resource identifiers do not authorize access to another learner. Source flags and counters are reported evidence, not newly computed grades. Missing dates, links and scoring remain null; a recorded completion flag does not establish a native pass result. historyId identifies a retained selection record rather than a current answer or question. Optional local mappings remain null when unavailable; no grade or completion date is inferred. The source selection's recorded creation timestamp is returned as stored.
+* @summary Read my historical answer selection
+*/
+const learningAnswerSelectionDetail = async (historyId, options) => {
+	return request(getLearningAnswerSelectionDetailUrl(historyId), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningAnswerSelectionDetailQueryKey = (historyId) => {
+	return [`/learning/history/answer-selections/${historyId}`];
+};
+const getLearningAnswerSelectionDetailQueryOptions = (historyId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningAnswerSelectionDetailQueryKey(historyId);
+	const queryFn = ({ signal }) => learningAnswerSelectionDetail(historyId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: historyId !== null && historyId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Read my historical answer selection
+*/
+function useLearningAnswerSelectionDetail(historyId, options, queryClient) {
+	const queryOptions = getLearningAnswerSelectionDetailQueryOptions(historyId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningListAttemptHistoryUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/learning/history/attempts?${stringifiedParams}` : `/learning/history/attempts`;
+};
+/**
+* Returns only the effective profile's attempts, ordered by startedAt descending then attemptId descending. assessment_id optionally filters this history; it never changes ownership. Historical records are retained evidence and cannot be resumed. Scores are percentages serialized as decimal strings; null means no score is available.
+* @summary List the profile's native and historical attempts
+*/
+const learningListAttemptHistory = async (params, options) => {
+	return request(getLearningListAttemptHistoryUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningListAttemptHistoryQueryKey = (params) => {
+	return [`/learning/history/attempts`, ...params ? [params] : []];
+};
+const getLearningListAttemptHistoryQueryOptions = (params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningListAttemptHistoryQueryKey(params);
+	const queryFn = ({ signal }) => learningListAttemptHistory(params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary List the profile's native and historical attempts
+*/
+function useLearningListAttemptHistory(params, options, queryClient) {
+	const queryOptions = getLearningListAttemptHistoryQueryOptions(params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningAttemptEvidenceUrl = (attemptId) => {
+	return `/learning/history/attempts/${attemptId}/evidence`;
+};
+/**
+* Returns evidence owned by the effective profile and rejects support impersonation. Resource identifiers do not authorize access to another learner. Source flags and counters are reported evidence, not newly computed grades. Missing dates, links and scoring remain null; a recorded completion flag does not establish a native pass result. attemptId must identify an historical attempt. evidenceBasis distinguishes source_master_session counters from a source_session success flag. Counts describe linked recorded rows, not a reconstructed test definition. startedAt is the recorded attempt timestamp; unavailable completion or expiry dates remain null.
+* @summary Read my historical assessment attempt evidence
+*/
+const learningAttemptEvidence = async (attemptId, options) => {
+	return request(getLearningAttemptEvidenceUrl(attemptId), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningAttemptEvidenceQueryKey = (attemptId) => {
+	return [`/learning/history/attempts/${attemptId}/evidence`];
+};
+const getLearningAttemptEvidenceQueryOptions = (attemptId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningAttemptEvidenceQueryKey(attemptId);
+	const queryFn = ({ signal }) => learningAttemptEvidence(attemptId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: attemptId !== null && attemptId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Read my historical assessment attempt evidence
+*/
+function useLearningAttemptEvidence(attemptId, options, queryClient) {
+	const queryOptions = getLearningAttemptEvidenceQueryOptions(attemptId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningHistoricalSelectedPagesUrl = (attemptId, params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/learning/history/attempts/${attemptId}/selected-pages?${stringifiedParams}` : `/learning/history/attempts/${attemptId}/selected-pages`;
+};
+/**
+* Returns evidence owned by the effective profile and rejects support impersonation. Resource identifiers do not authorize access to another learner. Lists the retained selected-page set, ordered by page ID and paginated with one-based page/limit. A selected page is evidence of inclusion, not proof it was viewed, answered or passed. Detailed page history is available separately. No questions or correct answers are reconstructed from this set.
+* @summary List pages selected for my historical attempt
+*/
+const learningHistoricalSelectedPages = async (attemptId, params, options) => {
+	return request(getLearningHistoricalSelectedPagesUrl(attemptId, params), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningHistoricalSelectedPagesQueryKey = (attemptId, params) => {
+	return [`/learning/history/attempts/${attemptId}/selected-pages`, ...params ? [params] : []];
+};
+const getLearningHistoricalSelectedPagesQueryOptions = (attemptId, params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningHistoricalSelectedPagesQueryKey(attemptId, params);
+	const queryFn = ({ signal }) => learningHistoricalSelectedPages(attemptId, params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: attemptId !== null && attemptId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary List pages selected for my historical attempt
+*/
+function useLearningHistoricalSelectedPages(attemptId, params, options, queryClient) {
+	const queryOptions = getLearningHistoricalSelectedPagesQueryOptions(attemptId, params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningPageEvidenceUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/learning/history/pages?${stringifiedParams}` : `/learning/history/pages`;
+};
+/**
+* Returns evidence owned by the effective profile and rejects support impersonation. Resource identifiers do not authorize access to another learner. Source flags and counters are reported evidence, not newly computed grades. Missing dates, links and scoring remain null; a recorded completion flag does not establish a native pass result. attemptId selects an owned historical attempt; unlinkedOnly=true selects rows with no stored attempt link and cannot be combined with attemptId. Optional object filters apply within that same ownership scope. Results are ordered by history ID descending and paginated after filtering. pageId optionally narrows to one local page identity. A returned attemptId is exposed only when it links to an owned historical attempt. responseAvailable indicates retained response evidence, not whether the bounded detail endpoint will return its serialized bytes.
+* @summary List my recorded page evidence
+*/
+const learningPageEvidence = async (params, options) => {
+	return request(getLearningPageEvidenceUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningPageEvidenceQueryKey = (params) => {
+	return [`/learning/history/pages`, ...params ? [params] : []];
+};
+const getLearningPageEvidenceQueryOptions = (params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningPageEvidenceQueryKey(params);
+	const queryFn = ({ signal }) => learningPageEvidence(params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary List my recorded page evidence
+*/
+function useLearningPageEvidence(params, options, queryClient) {
+	const queryOptions = getLearningPageEvidenceQueryOptions(params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningPageEvidenceDetailUrl = (historyId) => {
+	return `/learning/history/pages/${historyId}`;
+};
+/**
+* Returns evidence owned by the effective profile and rejects support impersonation. Resource identifiers do not authorize access to another learner. Source flags and counters are reported evidence, not newly computed grades. Missing dates, links and scoring remain null; a recorded completion flag does not establish a native pass result. Returns opaque PHP-serialized answer text only when retained as source master-selection evidence and at most 65,536 UTF-8 bytes. Larger responses retain encoding and byte count but set responseOmitted=true and serializedAnswers=null. A missing response instead has null encoding/count and responseOmitted=false. Source text is evidence, never a native answer request or trusted executable serialization.
+* @summary Read my historical page response evidence
+*/
+const learningPageEvidenceDetail = async (historyId, options) => {
+	return request(getLearningPageEvidenceDetailUrl(historyId), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningPageEvidenceDetailQueryKey = (historyId) => {
+	return [`/learning/history/pages/${historyId}`];
+};
+const getLearningPageEvidenceDetailQueryOptions = (historyId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningPageEvidenceDetailQueryKey(historyId);
+	const queryFn = ({ signal }) => learningPageEvidenceDetail(historyId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: historyId !== null && historyId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Read my historical page response evidence
+*/
+function useLearningPageEvidenceDetail(historyId, options, queryClient) {
+	const queryOptions = getLearningPageEvidenceDetailQueryOptions(historyId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningListScoreHistoryUrl = (params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/learning/history/scores?${stringifiedParams}` : `/learning/history/scores`;
+};
+/**
+* Returns one stored summary per assessment in the effective profile's history, newest creation time first with assessmentId as tie-breaker. A native completion replaces its assessment's summary; this is not a best-score leaderboard. An imported aggregate may have historical=true and attemptId=null because no attempt evidence exists. assessment_id restricts the list to that assessment.
+* @summary List the profile's assessment score summaries
+*/
+const learningListScoreHistory = async (params, options) => {
+	return request(getLearningListScoreHistoryUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningListScoreHistoryQueryKey = (params) => {
+	return [`/learning/history/scores`, ...params ? [params] : []];
+};
+const getLearningListScoreHistoryQueryOptions = (params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningListScoreHistoryQueryKey(params);
+	const queryFn = ({ signal }) => learningListScoreHistory(params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		...queryOptions
+	};
+};
+/**
+* @summary List the profile's assessment score summaries
+*/
+function useLearningListScoreHistory(params, options, queryClient) {
+	const queryOptions = getLearningListScoreHistoryQueryOptions(params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningOpenLessonUrl = (lessonId) => {
+	return `/learning/lessons/${lessonId}/open`;
+};
+/**
+* With sessionId, checks this profile's open course session and edition, renews its lease and selects the lesson for subsequent activity ticks. Without sessionId, both course previews and this lesson's freePreview must be enabled. Returns authorized media delivery URLs or HTML, public attachments and any vocabulary; corrections remain attempt-scoped. Delivery URLs may expire, so request fresh resources when reopening. A preview does not enroll the profile or record full-course consumption.
+* @summary Open lesson resources in a session or free preview
+*/
+const learningOpenLesson = async (lessonId, learningLessonOpenWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningOpenLessonUrl(lessonId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningLessonOpenWrite)
+	});
+};
+const getLearningOpenLessonMutationKey = () => ["learningOpenLesson"];
+const getLearningOpenLessonMutationOptions = (options) => {
+	const mutationKey = getLearningOpenLessonMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { lessonId, data } = props ?? {};
+		return learningOpenLesson(lessonId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Open lesson resources in a session or free preview
+*/
+const useLearningOpenLesson = (options, queryClient) => {
+	return useMutation(getLearningOpenLessonMutationOptions(options), queryClient);
+};
+const getLearningUpdateProgressUrl = (lessonId) => {
+	return `/learning/lessons/${lessonId}/progress`;
+};
+/**
+* Requires full access to the profile's selected course edition and creates enrollment if needed. Omit note to retain it; send null to clear it. positionSeconds is allowed only for resource lessons and cannot exceed a known duration. completed=true marks only a resource lesson complete; assessment and vocabulary lessons require their own completion workflow. Completion is retained on later completed=false writes. Updates the resume lesson and recomputes course progress from required lessons.
+* @summary Save lesson notes, playback position or resource completion
+*/
+const learningUpdateProgress = async (lessonId, lessonProgressWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningUpdateProgressUrl(lessonId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(lessonProgressWrite)
+	});
+};
+const getLearningUpdateProgressMutationKey = () => ["learningUpdateProgress"];
+const getLearningUpdateProgressMutationOptions = (options) => {
+	const mutationKey = getLearningUpdateProgressMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { lessonId, data } = props ?? {};
+		return learningUpdateProgress(lessonId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Save lesson notes, playback position or resource completion
+*/
+const useLearningUpdateProgress = (options, queryClient) => {
+	return useMutation(getLearningUpdateProgressMutationOptions(options), queryClient);
+};
+const getLearningPathIntroductionUrl = (pathId) => {
+	return `/learning/paths/${pathId}/introduction`;
+};
+/**
+* Returns a delivery descriptor, not the media bytes. The path must be active and at least one of its steps visible through the effective profile's catalogue access. Follow the returned URL promptly; delivery URLs may be temporary.
+* @summary Get a visible path's introduction resource
+*/
+const learningPathIntroduction = async (pathId, options) => {
+	return request(getLearningPathIntroductionUrl(pathId), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningPathIntroductionQueryKey = (pathId) => {
+	return [`/learning/paths/${pathId}/introduction`];
+};
+const getLearningPathIntroductionQueryOptions = (pathId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningPathIntroductionQueryKey(pathId);
+	const queryFn = ({ signal }) => learningPathIntroduction(pathId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: pathId !== null && pathId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Get a visible path's introduction resource
+*/
+function useLearningPathIntroduction(pathId, options, queryClient) {
+	const queryOptions = getLearningPathIntroductionQueryOptions(pathId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningOpenPathStepUrl = (pathId) => {
+	return `/learning/paths/${pathId}/open`;
+};
+/**
+* Sets the effective profile's current position to an active path's visible step, creating progress on first use. contentId must be a member of the path and pass existing catalogue visibility checks. This records navigation; the response is not a course reader payload. Support impersonation is rejected.
+* @summary Record my selected path step
+*/
+const learningOpenPathStep = async (pathId, learningPathOpenWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningOpenPathStepUrl(pathId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningPathOpenWrite)
+	});
+};
+const getLearningOpenPathStepMutationKey = () => ["learningOpenPathStep"];
+const getLearningOpenPathStepMutationOptions = (options) => {
+	const mutationKey = getLearningOpenPathStepMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { pathId, data } = props ?? {};
+		return learningOpenPathStep(pathId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Record my selected path step
+*/
+const useLearningOpenPathStep = (options, queryClient) => {
+	return useMutation(getLearningOpenPathStepMutationOptions(options), queryClient);
+};
+const getLearningReadPathProgressUrl = (pathId) => {
+	return `/learning/paths/${pathId}/progress`;
+};
+/**
+* Returns only the effective profile's recorded position and does not start the path. started=false means no progress row exists, including for an unknown path ID. position is zero-based. currentContentId is null when no recorded step is currently visible; a stored position may survive later curation changes.
+* @summary Read my current position in a path
+*/
+const learningReadPathProgress = async (pathId, options) => {
+	return request(getLearningReadPathProgressUrl(pathId), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningReadPathProgressQueryKey = (pathId) => {
+	return [`/learning/paths/${pathId}/progress`];
+};
+const getLearningReadPathProgressQueryOptions = (pathId, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningReadPathProgressQueryKey(pathId);
+	const queryFn = ({ signal }) => learningReadPathProgress(pathId, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: pathId !== null && pathId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Read my current position in a path
+*/
+function useLearningReadPathProgress(pathId, options, queryClient) {
+	const queryOptions = getLearningReadPathProgressQueryOptions(pathId, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningCloseSessionUrl = (sessionId) => {
+	return `/learning/sessions/${sessionId}`;
+};
+/**
+* Closes only a session owned by the effective profile and records closedAt. Repeating the close returns the same closed session. Enrollment, answers and lesson progress are retained; this operation does not mark a lesson complete.
+* @summary Close a course session and its consumption lease
+*/
+const learningCloseSession = async (sessionId, options) => {
+	return request(getLearningCloseSessionUrl(sessionId), {
+		...options,
+		method: "DELETE"
+	});
+};
+const getLearningCloseSessionMutationKey = () => ["learningCloseSession"];
+const getLearningCloseSessionMutationOptions = (options) => {
+	const mutationKey = getLearningCloseSessionMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { sessionId } = props ?? {};
+		return learningCloseSession(sessionId, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Close a course session and its consumption lease
+*/
+const useLearningCloseSession = (options, queryClient) => {
+	return useMutation(getLearningCloseSessionMutationOptions(options), queryClient);
+};
+const getLearningRecordActivityUrl = (sessionId) => {
+	return `/learning/sessions/${sessionId}/activity`;
+};
+/**
+* Requires this profile's open session and the lesson most recently selected with the lesson-open operation. Renews the consumption lease. active=true records server-observed elapsed time since the previous heartbeat, capped at 60 seconds per tick; active=false moves the clock forward without adding time. activeSeconds is cumulative seconds, separate from lesson completion and playback position. Heartbeats have no request key; send them only for current activity.
+* @summary Record an activity heartbeat for the selected lesson
+*/
+const learningRecordActivity = async (sessionId, learningActivityWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningRecordActivityUrl(sessionId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningActivityWrite)
+	});
+};
+const getLearningRecordActivityMutationKey = () => ["learningRecordActivity"];
+const getLearningRecordActivityMutationOptions = (options) => {
+	const mutationKey = getLearningRecordActivityMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { sessionId, data } = props ?? {};
+		return learningRecordActivity(sessionId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Record an activity heartbeat for the selected lesson
+*/
+const useLearningRecordActivity = (options, queryClient) => {
+	return useMutation(getLearningRecordActivityMutationOptions(options), queryClient);
+};
+const getLearningUploadBytesUrl = (uploadId) => {
+	return `/learning/uploads/${uploadId}/body`;
+};
+/**
+* Send an authenticated raw binary PUT, not multipart or JSON, to the reservation's uploadUrl before expiresAt. The byte count must exactly match sizeBytes; file signatures are checked against the reserved MIME type and captions must be valid UTF-8 WebVTT. Ownership and upload purpose are rechecked. A same-byte replay before expiry returns the existing immutable asset; different bytes cannot overwrite it. The JSON response contains the asset ID for a course definition or reflection answer, without issuing a delivery URL.
+* @summary Upload the exact bytes of a reserved file
+*/
+const learningUploadBytes = async (uploadId, learningUploadBytesBody, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningUploadBytesUrl(uploadId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/octet-stream",
+			...getHeaders(options?.headers)
+		},
+		body: learningUploadBytesBody
+	});
+};
+const getLearningUploadBytesMutationKey = () => ["learningUploadBytes"];
+const getLearningUploadBytesMutationOptions = (options) => {
+	const mutationKey = getLearningUploadBytesMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { uploadId, data } = props ?? {};
+		return learningUploadBytes(uploadId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Upload the exact bytes of a reserved file
+*/
+const useLearningUploadBytes = (options, queryClient) => {
+	return useMutation(getLearningUploadBytesMutationOptions(options), queryClient);
+};
+const getLearningReadVocabularyUrl = (vocabularyId, params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/learning/vocabularies/${vocabularyId}?${stringifiedParams}` : `/learning/vocabularies/${vocabularyId}`;
+};
+/**
+* lesson_id must identify a lesson using this vocabulary directly or as an attachment. Full reads return the profile's position and completion evidence. preview=true additionally requires that lesson's free-preview permission and omits saved personal progress. Entries are ordered by position then entry ID; term media IDs must be resolved through the vocabulary resource operation.
+* @summary Read vocabulary through an authorized lesson
+*/
+const learningReadVocabulary = async (vocabularyId, params, options) => {
+	return request(getLearningReadVocabularyUrl(vocabularyId, params), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningReadVocabularyQueryKey = (vocabularyId, params) => {
+	return [`/learning/vocabularies/${vocabularyId}`, ...params ? [params] : []];
+};
+const getLearningReadVocabularyQueryOptions = (vocabularyId, params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningReadVocabularyQueryKey(vocabularyId, params);
+	const queryFn = ({ signal }) => learningReadVocabulary(vocabularyId, params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: vocabularyId !== null && vocabularyId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Read vocabulary through an authorized lesson
+*/
+function useLearningReadVocabulary(vocabularyId, params, options, queryClient) {
+	const queryOptions = getLearningReadVocabularyQueryOptions(vocabularyId, params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningVocabularyResourceUrl = (vocabularyId, assetId, params) => {
+	const normalizedParams = new URLSearchParams();
+	Object.entries(params || {}).forEach(([key, value]) => {
+		if (value !== void 0) normalizedParams.append(key, value === null ? "null" : String(value));
+	});
+	const stringifiedParams = normalizedParams.toString();
+	return stringifiedParams.length > 0 ? `/learning/vocabularies/${vocabularyId}/assets/${assetId}?${stringifiedParams}` : `/learning/vocabularies/${vocabularyId}/assets/${assetId}`;
+};
+/**
+* Checks vocabulary and lesson context exactly as the vocabulary read operation, including preview permission when preview=true. assetId must be audio or image referenced by a term or translation in this vocabulary; knowing a media ID alone grants no access. Returns delivery metadata with a potentially expiring URL.
+* @summary Resolve a vocabulary term's audio or image
+*/
+const learningVocabularyResource = async (vocabularyId, assetId, params, options) => {
+	return request(getLearningVocabularyResourceUrl(vocabularyId, assetId, params), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningVocabularyResourceQueryKey = (vocabularyId, assetId, params) => {
+	return [`/learning/vocabularies/${vocabularyId}/assets/${assetId}`, ...params ? [params] : []];
+};
+const getLearningVocabularyResourceQueryOptions = (vocabularyId, assetId, params, options) => {
+	const { query: queryOptions, request: requestOptions } = options ?? {};
+	const queryKey = queryOptions?.queryKey ?? getLearningVocabularyResourceQueryKey(vocabularyId, assetId, params);
+	const queryFn = ({ signal }) => learningVocabularyResource(vocabularyId, assetId, params, {
+		signal,
+		...requestOptions
+	});
+	return {
+		queryKey,
+		queryFn,
+		enabled: vocabularyId !== null && vocabularyId !== void 0 && assetId !== null && assetId !== void 0,
+		...queryOptions
+	};
+};
+/**
+* @summary Resolve a vocabulary term's audio or image
+*/
+function useLearningVocabularyResource(vocabularyId, assetId, params, options, queryClient) {
+	const queryOptions = getLearningVocabularyResourceQueryOptions(vocabularyId, assetId, params, options);
+	const query = useQuery(queryOptions, queryClient);
+	return withQueryKey(query, queryOptions.queryKey);
+}
+const getLearningUpdateVocabularyUrl = (vocabularyId) => {
+	return `/learning/vocabularies/${vocabularyId}/progress`;
+};
+/**
+* Requires full access through lessonId and creates course enrollment if needed. position is a cursor from 0 through the entry count; completed=true requires a nonempty vocabulary and position exactly equal to its entry count. Completion is retained on subsequent writes. Completing the lesson's primary vocabulary also completes that lesson; completing an attached vocabulary does not. Updates the resume lesson and recomputes required-lesson progress.
+* @summary Save vocabulary position or completion
+*/
+const learningUpdateVocabulary = async (vocabularyId, vocabularyProgressWrite, options) => {
+	const getHeaders = (h) => {
+		if (!h) return {};
+		if (h instanceof Headers) return Object.fromEntries(h.entries());
+		if (Symbol.iterator in h) return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+		const headers = {};
+		for (const [name, value] of Object.entries(h)) if (value !== void 0) headers[name] = value;
+		return headers;
+	};
+	return request(getLearningUpdateVocabularyUrl(vocabularyId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(vocabularyProgressWrite)
+	});
+};
+const getLearningUpdateVocabularyMutationKey = () => ["learningUpdateVocabulary"];
+const getLearningUpdateVocabularyMutationOptions = (options) => {
+	const mutationKey = getLearningUpdateVocabularyMutationKey();
+	const { mutation: mutationOptions, request: requestOptions } = options ? options.mutation && "mutationKey" in options.mutation && options.mutation.mutationKey ? options : {
+		...options,
+		mutation: {
+			...options.mutation,
+			mutationKey
+		}
+	} : {
+		mutation: { mutationKey },
+		request: void 0
+	};
+	const mutationFn = (props) => {
+		const { vocabularyId, data } = props ?? {};
+		return learningUpdateVocabulary(vocabularyId, data, requestOptions);
+	};
+	return {
+		mutationFn,
+		...mutationOptions
+	};
+};
+/**
+* @summary Save vocabulary position or completion
+*/
+const useLearningUpdateVocabulary = (options, queryClient) => {
+	return useMutation(getLearningUpdateVocabularyMutationOptions(options), queryClient);
+};
+//#endregion
+export { getLearningAbandonAttemptMutationKey, getLearningAbandonAttemptMutationOptions, getLearningAbandonAttemptUrl, getLearningAnswerQuestionMutationKey, getLearningAnswerQuestionMutationOptions, getLearningAnswerQuestionUrl, getLearningAnswerSelectionDetailQueryKey, getLearningAnswerSelectionDetailQueryOptions, getLearningAnswerSelectionDetailUrl, getLearningAnswerSelectionEvidenceQueryKey, getLearningAnswerSelectionEvidenceQueryOptions, getLearningAnswerSelectionEvidenceUrl, getLearningAttemptEvidenceQueryKey, getLearningAttemptEvidenceQueryOptions, getLearningAttemptEvidenceUrl, getLearningCloseSessionMutationKey, getLearningCloseSessionMutationOptions, getLearningCloseSessionUrl, getLearningDownloadCertificateQueryKey, getLearningDownloadCertificateQueryOptions, getLearningDownloadCertificateUrl, getLearningEnrollMutationKey, getLearningEnrollMutationOptions, getLearningEnrollUrl, getLearningFinishAttemptMutationKey, getLearningFinishAttemptMutationOptions, getLearningFinishAttemptUrl, getLearningHistoricalSelectedPagesQueryKey, getLearningHistoricalSelectedPagesQueryOptions, getLearningHistoricalSelectedPagesUrl, getLearningIssueCertificateMutationKey, getLearningIssueCertificateMutationOptions, getLearningIssueCertificateUrl, getLearningListAttemptHistoryQueryKey, getLearningListAttemptHistoryQueryOptions, getLearningListAttemptHistoryUrl, getLearningListScoreHistoryQueryKey, getLearningListScoreHistoryQueryOptions, getLearningListScoreHistoryUrl, getLearningOpenLessonMutationKey, getLearningOpenLessonMutationOptions, getLearningOpenLessonUrl, getLearningOpenPathStepMutationKey, getLearningOpenPathStepMutationOptions, getLearningOpenPathStepUrl, getLearningPageEvidenceDetailQueryKey, getLearningPageEvidenceDetailQueryOptions, getLearningPageEvidenceDetailUrl, getLearningPageEvidenceQueryKey, getLearningPageEvidenceQueryOptions, getLearningPageEvidenceUrl, getLearningPathIntroductionQueryKey, getLearningPathIntroductionQueryOptions, getLearningPathIntroductionUrl, getLearningRateExercisePageMutationKey, getLearningRateExercisePageMutationOptions, getLearningRateExercisePageUrl, getLearningReadAttemptQueryKey, getLearningReadAttemptQueryOptions, getLearningReadAttemptResourceQueryKey, getLearningReadAttemptResourceQueryOptions, getLearningReadAttemptResourceUrl, getLearningReadAttemptUrl, getLearningReadCertificateQueryKey, getLearningReadCertificateQueryOptions, getLearningReadCertificateUrl, getLearningReadCourseQueryKey, getLearningReadCourseQueryOptions, getLearningReadCourseUrl, getLearningReadEnrollmentHistoryQueryKey, getLearningReadEnrollmentHistoryQueryOptions, getLearningReadEnrollmentHistoryUrl, getLearningReadPathProgressQueryKey, getLearningReadPathProgressQueryOptions, getLearningReadPathProgressUrl, getLearningReadVocabularyQueryKey, getLearningReadVocabularyQueryOptions, getLearningReadVocabularyUrl, getLearningRecordActivityMutationKey, getLearningRecordActivityMutationOptions, getLearningRecordActivityUrl, getLearningReserveCourseUploadMutationKey, getLearningReserveCourseUploadMutationOptions, getLearningReserveCourseUploadUrl, getLearningReserveExerciseUploadMutationKey, getLearningReserveExerciseUploadMutationOptions, getLearningReserveExerciseUploadUrl, getLearningStartAttemptMutationKey, getLearningStartAttemptMutationOptions, getLearningStartAttemptUrl, getLearningStartSessionMutationKey, getLearningStartSessionMutationOptions, getLearningStartSessionUrl, getLearningUpdateProgressMutationKey, getLearningUpdateProgressMutationOptions, getLearningUpdateProgressUrl, getLearningUpdateVocabularyMutationKey, getLearningUpdateVocabularyMutationOptions, getLearningUpdateVocabularyUrl, getLearningUpgradeCourseEditionMutationKey, getLearningUpgradeCourseEditionMutationOptions, getLearningUpgradeCourseEditionUrl, getLearningUploadBytesMutationKey, getLearningUploadBytesMutationOptions, getLearningUploadBytesUrl, getLearningVocabularyResourceQueryKey, getLearningVocabularyResourceQueryOptions, getLearningVocabularyResourceUrl, learningAbandonAttempt, learningAnswerQuestion, learningAnswerSelectionDetail, learningAnswerSelectionEvidence, learningAttemptEvidence, learningCloseSession, learningDownloadCertificate, learningEnroll, learningFinishAttempt, learningHistoricalSelectedPages, learningIssueCertificate, learningListAttemptHistory, learningListScoreHistory, learningOpenLesson, learningOpenPathStep, learningPageEvidence, learningPageEvidenceDetail, learningPathIntroduction, learningRateExercisePage, learningReadAttempt, learningReadAttemptResource, learningReadCertificate, learningReadCourse, learningReadEnrollmentHistory, learningReadPathProgress, learningReadVocabulary, learningRecordActivity, learningReserveCourseUpload, learningReserveExerciseUpload, learningStartAttempt, learningStartSession, learningUpdateProgress, learningUpdateVocabulary, learningUpgradeCourseEdition, learningUploadBytes, learningVocabularyResource, useLearningAbandonAttempt, useLearningAnswerQuestion, useLearningAnswerSelectionDetail, useLearningAnswerSelectionEvidence, useLearningAttemptEvidence, useLearningCloseSession, useLearningDownloadCertificate, useLearningEnroll, useLearningFinishAttempt, useLearningHistoricalSelectedPages, useLearningIssueCertificate, useLearningListAttemptHistory, useLearningListScoreHistory, useLearningOpenLesson, useLearningOpenPathStep, useLearningPageEvidence, useLearningPageEvidenceDetail, useLearningPathIntroduction, useLearningRateExercisePage, useLearningReadAttempt, useLearningReadAttemptResource, useLearningReadCertificate, useLearningReadCourse, useLearningReadEnrollmentHistory, useLearningReadPathProgress, useLearningReadVocabulary, useLearningRecordActivity, useLearningReserveCourseUpload, useLearningReserveExerciseUpload, useLearningStartAttempt, useLearningStartSession, useLearningUpdateProgress, useLearningUpdateVocabulary, useLearningUpgradeCourseEdition, useLearningUploadBytes, useLearningVocabularyResource };
+
+//# sourceMappingURL=biblio-learning.js.map