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

package/dist/api/biblio-learning-authoring.js

@@ -0,0 +1,586 @@
+
+import { r as request } from "../chunks/client.js";
+//#region src/api/biblio-learning-authoring/biblio-learning-authoring.ts
+const getLearningListAuthorCataloguesUrl = () => {
+	return `/learning/author/catalogues`;
+};
+/**
+* Requires the effective independent author profile and the relevant catalogue, ownership or global authority. Support impersonation is rejected. Lists active catalogues with creation, review or finance authority. Review permission also enables creation; finance permission alone does not. The collection is ordered by catalogue ID and is not paginated.
+* @summary List my authoring catalogues
+*/
+const learningListAuthorCatalogues = async (options) => {
+	return request(getLearningListAuthorCataloguesUrl(), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningCreateAuthorCatalogueUrl = () => {
+	return `/learning/author/catalogues`;
+};
+/**
+* Requires global catalogue write authority and rejects support impersonation. Creates an active authoring catalogue; the returned capability flags describe the operator making this request.
+* @summary Create a learning catalogue
+*/
+const learningCreateAuthorCatalogue = async (learningCatalogueWrite, 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(getLearningCreateAuthorCatalogueUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningCatalogueWrite)
+	});
+};
+const getLearningSetCatalogueAuthorityUrl = (catalogueId) => {
+	return `/learning/author/catalogues/${catalogueId}/authority`;
+};
+/**
+* Requires global catalogue write authority. Replaces all three grants for the selected active independent account, including revocation when all flags are false. The reason is recorded for audit. Successful updates return 204 with no response body.
+* @summary Replace an author's catalogue permissions
+*/
+const learningSetCatalogueAuthority = async (catalogueId, learningCatalogueGrantWrite, 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(getLearningSetCatalogueAuthorityUrl(catalogueId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningCatalogueGrantWrite)
+	});
+};
+const getLearningListAuthorCoursesUrl = (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/author/courses?${stringifiedParams}` : `/learning/author/courses`;
+};
+/**
+* Returns courses assigned to the effective author and courses in active catalogues they may review. Global administrators and support readers can see all courses. Dependent profiles and support impersonation are refused. Pagination counts this authorized scope and sorts by course ID ascending; draft courses are included.
+* @summary List courses available to the author
+*/
+const learningListAuthorCourses = async (params, options) => {
+	return request(getLearningListAuthorCoursesUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningCreateCourseUrl = () => {
+	return `/learning/author/courses`;
+};
+/**
+* Create an inactive course from a title in an authorized catalogue, then register media and create an edition. Binding an existing catalogue contentId, or creating without catalogueId, requires global administration. Assigning other authors requires curator authority. Publication activates a new course; this request alone does not make it readable.
+* @summary Create a native course shell
+*/
+const learningCreateCourse = async (learningCourseCreateWrite, 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(getLearningCreateCourseUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningCourseCreateWrite)
+	});
+};
+const getLearningUpdateCourseSettingsUrl = (courseId) => {
+	return `/learning/author/courses/${courseId}`;
+};
+/**
+* Requires course curator or global administrator authority and an audit reason. Non-null scalar fields replace their current values; null or omitted values leave them unchanged. authorIds replaces the complete author set, including clearing it with an empty list. A course must have a published edition before isActive can be true.
+* @summary Update publication and author settings
+*/
+const learningUpdateCourseSettings = async (courseId, learningCourseSettingsWrite, 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(getLearningUpdateCourseSettingsUrl(courseId), {
+		...options,
+		method: "PATCH",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningCourseSettingsWrite)
+	});
+};
+const getLearningRegisterAssetUrl = (courseId) => {
+	return `/learning/author/courses/${courseId}/assets`;
+};
+/**
+* Requires edit authority on the course. Registers an immutable media reference for use in edition definitions. Vimeo requires a numeric video ID; external resources require HTTPS without credentials; HTML is sanitized; storage keys must identify an existing object under this author's learning prefix. The response identifies the asset and does not issue a playback URL. For new file bytes use the upload reservation workflow.
+* @summary Register a course media resource
+*/
+const learningRegisterAsset = async (courseId, learningAssetWrite, 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(getLearningRegisterAssetUrl(courseId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningAssetWrite)
+	});
+};
+const getLearningAttachCaptionsUrl = (courseId, assetId) => {
+	return `/learning/author/courses/${courseId}/assets/${assetId}/captions`;
+};
+/**
+* Requires course edit authority. First upload validated UTF-8 WebVTT to the same course, then reference its asset ID here. Returns a new immutable media variant; existing editions keep their original asset. Repeating the original asset, caption asset and language returns the existing variant. Put the returned assetId into a draft edition to publish the captions.
+* @summary Create a captioned variant of course audio or video
+*/
+const learningAttachCaptions = async (courseId, assetId, learningCaptionWrite, 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(getLearningAttachCaptionsUrl(courseId, assetId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningCaptionWrite)
+	});
+};
+const getLearningListRevisionsUrl = (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/author/courses/${courseId}/revisions?${stringifiedParams}` : `/learning/author/courses/${courseId}/revisions`;
+};
+/**
+* Requires read authority on this course. Returns draft, submitted, published, rejected and superseded editions, newest version first. version identifies the course edition; editVersion is the optimistic concurrency counter within a working edition.
+* @summary List the course's edition history
+*/
+const learningListRevisions = async (courseId, params, options) => {
+	return request(getLearningListRevisionsUrl(courseId, params), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningCreateRevisionUrl = (courseId) => {
+	return `/learning/author/courses/${courseId}/revisions`;
+};
+/**
+* Requires course edit authority. Creates a complete edition with the next version number; only one draft or submitted edition may exist for a course. Asset and library references must be available to this course. Chapters contain 1–2000 lessons with unique keys across the edition; the serialized authoring definition is limited to 2,000,000 bytes. Published editions and existing enrollments remain pinned to their definitions.
+* @summary Create the next draft edition
+*/
+const learningCreateRevision = async (courseId, courseRevisionWriteInput, 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(getLearningCreateRevisionUrl(courseId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(courseRevisionWriteInput)
+	});
+};
+const getLearningReadAuthorRevisionUrl = (courseId, revisionId) => {
+	return `/learning/author/courses/${courseId}/revisions/${revisionId}`;
+};
+/**
+* Requires authoring read authority and checks that revisionId belongs to courseId. Returns editorial content, lessons, resources, vocabularies and private assessment solutions. Read revision.editVersion before replacing a changed definition. This author-only representation includes grading keys that are deliberately absent from reader questions.
+* @summary Read a complete editable edition definition
+*/
+const learningReadAuthorRevision = async (courseId, revisionId, options) => {
+	return request(getLearningReadAuthorRevisionUrl(courseId, revisionId), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningReplaceRevisionUrl = (courseId, revisionId) => {
+	return `/learning/author/courses/${courseId}/revisions/${revisionId}`;
+};
+/**
+* Replaces the entire editorial and lesson graph of a draft or rejected edition. Send the editVersion last read as expectedEditVersion. An identical definition is an idempotent replay; a changed definition requires a matching version and increments editVersion. A changed rejected edition returns to draft and clears its review note and submission date. Published and submitted editions cannot be edited.
+* @summary Replace a draft edition with concurrency protection
+*/
+const learningReplaceRevision = async (courseId, revisionId, courseRevisionWriteInput, 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(getLearningReplaceRevisionUrl(courseId, revisionId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(courseRevisionWriteInput)
+	});
+};
+const getLearningReviewRevisionUrl = (courseId, revisionId) => {
+	return `/learning/author/courses/${courseId}/revisions/${revisionId}/review`;
+};
+/**
+* Requires course curator or global administrator authority. Approval revalidates materials, publishes this edition, supersedes its published predecessor, updates catalogue editorial fields and activates the course. Existing readers retain their selected edition until they explicitly upgrade. Rejection returns the edition for editing. Every decision requires a review note; repeated decisions return 409 once the edition leaves submitted.
+* @summary Publish or reject a submitted edition
+*/
+const learningReviewRevision = async (courseId, revisionId, courseReviewWrite, 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(getLearningReviewRevisionUrl(courseId, revisionId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(courseReviewWrite)
+	});
+};
+const getLearningSubmitRevisionUrl = (courseId, revisionId) => {
+	return `/learning/author/courses/${courseId}/revisions/${revisionId}/submit`;
+};
+/**
+* Requires course edit authority. Moves draft to submitted and records submittedAt; reviewers can then approve or reject it. Submission locks the definition against editing. This transition is not replay-idempotent: submitting an already submitted edition returns 409.
+* @summary Submit a draft edition for review
+*/
+const learningSubmitRevision = async (courseId, revisionId, options) => {
+	return request(getLearningSubmitRevisionUrl(courseId, revisionId), {
+		...options,
+		method: "POST"
+	});
+};
+const getLearningListLibrariesUrl = (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/author/libraries?${stringifiedParams}` : `/learning/author/libraries`;
+};
+/**
+* Requires the effective independent author profile and the relevant catalogue, ownership or global authority. Support impersonation is rejected. Results are filtered to the caller's scope before pagination; page is one-based and limit is bounded by the shared pagination contract. Lists owned or shared libraries for creators, all libraries in reviewable active catalogues for reviewers, and all libraries for global operators. Ordered by library ID. publishedVersion=0 means no native published version is selected.
+* @summary List reusable teaching libraries
+*/
+const learningListLibraries = async (params, options) => {
+	return request(getLearningListLibrariesUrl(params), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningCreateLibraryUrl = () => {
+	return `/learning/author/libraries`;
+};
+/**
+* Requires the effective independent author profile and the relevant catalogue, ownership or global authority. Support impersonation is rejected. Creates an empty assessment or vocabulary container owned by the caller. A null catalogueId requires global authority. shared allows catalogue peers to reuse published material; it does not grant them editing rights. Create a version separately.
+* @summary Create a reusable teaching library
+*/
+const learningCreateLibrary = async (learningLibraryWrite, 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(getLearningCreateLibraryUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningLibraryWrite)
+	});
+};
+const getLearningListLibraryVersionsUrl = (libraryId, 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/author/libraries/${libraryId}/versions?${stringifiedParams}` : `/learning/author/libraries/${libraryId}/versions`;
+};
+/**
+* Requires the effective independent author profile and the relevant catalogue, ownership or global authority. Support impersonation is rejected. Results are filtered to the caller's scope before pagination; page is one-based and limit is bounded by the shared pagination contract. Ordered by version descending. Owners, reviewers and global operators can read drafts; other eligible users see published and superseded versions only. sealed is authoritative for editing: imported or referenced material can be sealed even with a draft status.
+* @summary List versions of a teaching library
+*/
+const learningListLibraryVersions = async (libraryId, params, options) => {
+	return request(getLearningListLibraryVersionsUrl(libraryId, params), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningCreateLibraryVersionUrl = (libraryId) => {
+	return `/learning/author/libraries/${libraryId}/versions`;
+};
+/**
+* Requires the effective independent author profile and the relevant catalogue, ownership or global authority. Support impersonation is rejected. Requires library ownership, catalogue review authority or global authority for writes; sharing only permits reuse and reading published versions. Creates the next numbered draft without changing any previous definition. Supply exactly one assessment or vocabulary matching the library kind. There must be no submitted version or unsealed working draft. Sealed source drafts do not block a successor. Referenced questions must be published and accessible; sourceLessonKeys are not accepted for libraries.
+* @summary Create a successor library version
+*/
+const learningCreateLibraryVersion = async (libraryId, learningLibraryVersionWrite, 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(getLearningCreateLibraryVersionUrl(libraryId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningLibraryVersionWrite)
+	});
+};
+const getLearningReadLibraryVersionUrl = (libraryId, version) => {
+	return `/learning/author/libraries/${libraryId}/versions/${version}`;
+};
+/**
+* Requires the effective independent author profile and the relevant catalogue, ownership or global authority. Support impersonation is rejected. Returns the full authoring definition and stable question references. version is the library's sequential version number, not materialId. Draft visibility is restricted to owner/reviewer/global operator. Answer keys are part of this private authoring contract. A sealed source snapshot must be copied into a successor to change it.
+* @summary Read a teaching library version
+*/
+const learningReadLibraryVersion = async (libraryId, version, options) => {
+	return request(getLearningReadLibraryVersionUrl(libraryId, version), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningReplaceLibraryVersionUrl = (libraryId, version) => {
+	return `/learning/author/libraries/${libraryId}/versions/${version}`;
+};
+/**
+* Requires the effective independent author profile and the relevant catalogue, ownership or global authority. Support impersonation is rejected. Requires library ownership, catalogue review authority or global authority for writes; sharing only permits reuse and reading published versions. Replaces an unsealed draft or rejected version. Supply the current expectedEditVersion when changing the definition; a semantic no-op returns the same version. Submitted, published, superseded, imported and referenced definitions are immutable. Create a successor for sealed material instead. Exactly one matching assessment or vocabulary is required.
+* @summary Replace an editable library definition
+*/
+const learningReplaceLibraryVersion = async (libraryId, version, learningLibraryVersionWrite, 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(getLearningReplaceLibraryVersionUrl(libraryId, version), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningLibraryVersionWrite)
+	});
+};
+const getLearningReviewLibraryVersionUrl = (libraryId, version) => {
+	return `/learning/author/libraries/${libraryId}/versions/${version}/review`;
+};
+/**
+* Requires the effective independent author profile and the relevant catalogue, ownership or global authority. Support impersonation is rejected. Requires catalogue review or global authority. Approval revalidates resources, publishes this version and supersedes the previously published version. Rejection records the decision and makes an unpinned definition editable again. The supplied note is audited; it is not a field of the returned version summary.
+* @summary Approve or reject a submitted library version
+*/
+const learningReviewLibraryVersion = async (libraryId, version, courseReviewWrite, 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(getLearningReviewLibraryVersionUrl(libraryId, version), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(courseReviewWrite)
+	});
+};
+const getLearningSubmitLibraryVersionUrl = (libraryId, version) => {
+	return `/learning/author/libraries/${libraryId}/versions/${version}/submit`;
+};
+/**
+* Requires the effective independent author profile and the relevant catalogue, ownership or global authority. Support impersonation is rejected. Requires library ownership, catalogue review authority or global authority for writes; sharing only permits reuse and reading published versions. Only an unsealed draft can be submitted. Submission locks its definition pending review; it does not publish the material. Source snapshots and referenced drafts require a successor before submission.
+* @summary Submit a library draft for review
+*/
+const learningSubmitLibraryVersion = async (libraryId, version, options) => {
+	return request(getLearningSubmitLibraryVersionUrl(libraryId, version), {
+		...options,
+		method: "POST"
+	});
+};
+const getLearningCreatePathUrl = () => {
+	return `/learning/author/paths`;
+};
+/**
+* Requires review authority for the chosen catalogue, or global authority for a null catalogueId. Creates a path with ordered, unique content IDs; these are catalogue content identities, not revision IDs. Creators without review permission cannot curate paths. Active publication requires active content and eligible catalogue resources.
+* @summary Create a curated learning path
+*/
+const learningCreatePath = async (learningPathWrite, 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(getLearningCreatePathUrl(), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningPathWrite)
+	});
+};
+const getLearningReadAuthorPathUrl = (pathId) => {
+	return `/learning/author/paths/${pathId}`;
+};
+/**
+* Requires review authority for the path's original catalogue or global authority. Returns the complete ordered definition and its current editVersion; use that counter in the next replacement request.
+* @summary Read a path's authoring definition
+*/
+const learningReadAuthorPath = async (pathId, options) => {
+	return request(getLearningReadAuthorPathUrl(pathId), {
+		...options,
+		method: "GET"
+	});
+};
+const getLearningUpdatePathUrl = (pathId) => {
+	return `/learning/author/paths/${pathId}`;
+};
+/**
+* Requires review authority for the original catalogue or global authority. Replaces the entire definition and step ordering, increments editVersion, and requires expectedEditVersion to match. The catalogue cannot change. Setting isActive=true requires all referenced content to be active; step visibility for readers still follows their existing access grants.
+* @summary Replace and optionally publish a learning path
+*/
+const learningUpdatePath = async (pathId, learningPathWrite, 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(getLearningUpdatePathUrl(pathId), {
+		...options,
+		method: "PUT",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningPathWrite)
+	});
+};
+const getLearningCreatePathAssessmentUrl = (pathId) => {
+	return `/learning/author/paths/${pathId}/assessments`;
+};
+/**
+* Requires path catalogue review authority or global authority. Creates a new assessment with kind=final and explicit questions or published questionRefs; sourceLessonKeys are not accepted. References must come from courses in this path. Existing assessments are immutable; withdraw one and create another when replacing it.
+* @summary Add a final assessment to a learning path
+*/
+const learningCreatePathAssessment = async (pathId, learningAssessmentWriteInput, 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(getLearningCreatePathAssessmentUrl(pathId), {
+		...options,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...getHeaders(options?.headers)
+		},
+		body: JSON.stringify(learningAssessmentWriteInput)
+	});
+};
+const getLearningWithdrawPathAssessmentUrl = (pathId, assessmentId) => {
+	return `/learning/author/paths/${pathId}/assessments/${assessmentId}`;
+};
+/**
+* Requires path catalogue review authority or global authority. Marks the selected assessment inactive while retaining its identity and recorded evidence. assessmentId must belong to pathId. Repeating withdrawal leaves it inactive. Success returns 204 with no response body.
+* @summary Withdraw a path assessment
+*/
+const learningWithdrawPathAssessment = async (pathId, assessmentId, options) => {
+	return request(getLearningWithdrawPathAssessmentUrl(pathId, assessmentId), {
+		...options,
+		method: "DELETE"
+	});
+};
+//#endregion
+export { getLearningAttachCaptionsUrl, getLearningCreateAuthorCatalogueUrl, getLearningCreateCourseUrl, getLearningCreateLibraryUrl, getLearningCreateLibraryVersionUrl, getLearningCreatePathAssessmentUrl, getLearningCreatePathUrl, getLearningCreateRevisionUrl, getLearningListAuthorCataloguesUrl, getLearningListAuthorCoursesUrl, getLearningListLibrariesUrl, getLearningListLibraryVersionsUrl, getLearningListRevisionsUrl, getLearningReadAuthorPathUrl, getLearningReadAuthorRevisionUrl, getLearningReadLibraryVersionUrl, getLearningRegisterAssetUrl, getLearningReplaceLibraryVersionUrl, getLearningReplaceRevisionUrl, getLearningReviewLibraryVersionUrl, getLearningReviewRevisionUrl, getLearningSetCatalogueAuthorityUrl, getLearningSubmitLibraryVersionUrl, getLearningSubmitRevisionUrl, getLearningUpdateCourseSettingsUrl, getLearningUpdatePathUrl, getLearningWithdrawPathAssessmentUrl, learningAttachCaptions, learningCreateAuthorCatalogue, learningCreateCourse, learningCreateLibrary, learningCreateLibraryVersion, learningCreatePath, learningCreatePathAssessment, learningCreateRevision, learningListAuthorCatalogues, learningListAuthorCourses, learningListLibraries, learningListLibraryVersions, learningListRevisions, learningReadAuthorPath, learningReadAuthorRevision, learningReadLibraryVersion, learningRegisterAsset, learningReplaceLibraryVersion, learningReplaceRevision, learningReviewLibraryVersion, learningReviewRevision, learningSetCatalogueAuthority, learningSubmitLibraryVersion, learningSubmitRevision, learningUpdateCourseSettings, learningUpdatePath, learningWithdrawPathAssessment };
+
+//# sourceMappingURL=biblio-learning-authoring.js.map