@phtngyn/cms 0.2.0-beta.8 → 0.3.0

package/src/StudioApi-CXLwwocX.js

@@ -0,0 +1,833 @@
+import { a as SiteSeoState, i as SiteSeoSettings, r as SiteSeoRevision } from "./Seo-CjNUtUkj.js";
+import { d as MediaSort, i as MediaId, l as MediaPage, n as MediaFolder, r as MediaFolderSummary, s as MediaLibraryKind, t as MediaAsset } from "./Media-DSyvd14o.js";
+import { C as TrashPlan, T as WebsiteRevisionSelection, _ as DocumentSource, a as DocumentCatalogSummary, b as RevisionHistoryPage, c as DocumentEditorSnapshot, d as DocumentInventorySummary, f as DocumentIssue, g as DocumentSnapshot, l as DocumentId, m as DocumentRevision, n as Document, o as DocumentCheckpoint, p as DocumentPlacement, t as CollectionName, u as DocumentIdentity, v as DocumentVersion, w as TrashedDocument, x as RevisionId } from "./Document-CKXMSEf1.js";
+import { n as LocaleConfiguration, t as Locale } from "./Locales-Ch7a5xuA.js";
+import { t as CollectionDefinition } from "./Fields-ioGaMEh9.js";
+import { n as StudioErrorFields, t as StudioErrorCode } from "./StudioErrors-T5zLGQ1M.js";
+import { t as BlockDefinition } from "./Blocks-BrxSemnd.js";
+import { a as PersonEmail, i as Person, n as Invitation, o as Role, r as PeoplePage, s as StudioModule, t as CreatePerson } from "./People-DvNZauWw.js";
+import { i as RevisionLinkId, n as IssuedRevisionLink, r as RevisionLink, t as CreateRevisionLink } from "./RevisionPreview-IVwbJ9Wy.js";
+import { t as PreviewFocusTarget } from "./PreviewFocus-C_EelZO5.js";
+import { Context, Schema } from "effect";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
+//#region ../model/src/Publication.ts
+const PublicationScheduleId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("PublicationScheduleId"));
+/** Publish pins the current saved revision; unpublish pins the live revision. */
+const PublicationChange = Schema.Struct({
+	documentId: DocumentId,
+	revisionId: RevisionId,
+	action: Schema.Literals(["publish", "unpublish"])
+});
+const PublicationChanges = Schema.Array(PublicationChange).check(Schema.isMinLength(1), Schema.isMaxLength(100));
+const PublicationSelection = Schema.Array(Schema.Struct({
+	documentId: DocumentId,
+	action: Schema.Literals(["publish", "unpublish"]),
+	revisionId: Schema.optionalKey(RevisionId)
+})).check(Schema.isMinLength(1), Schema.isMaxLength(100));
+const PublicationSection = Schema.Literals([
+	"details",
+	"content",
+	"new",
+	"offline"
+]);
+const PublicationIssue = Schema.Struct({
+	...StudioErrorFields,
+	code: StudioErrorCode,
+	documentId: Schema.NullOr(DocumentId),
+	message: Schema.String
+});
+/** A persisted failure retains stable localization data and a readable API fallback. */
+const PublicationFailure = Schema.Struct({
+	...StudioErrorFields,
+	message: Schema.String
+});
+const PublicationPlan = Schema.Struct({
+	stamp: Schema.String,
+	changes: PublicationChanges,
+	documents: Schema.Array(Schema.Struct({
+		documentId: DocumentId,
+		title: Schema.String,
+		beforePath: Schema.NullOr(Schema.String),
+		afterPath: Schema.NullOr(Schema.String),
+		sections: Schema.Array(PublicationSection)
+	})),
+	issues: Schema.Array(PublicationIssue)
+});
+const PublicationRelease = Schema.Struct({
+	id: PublicationScheduleId,
+	/** An empty generated label is presented as the localized publication default. */
+	label: Schema.String,
+	changes: PublicationChanges,
+	publishAt: Schema.String,
+	status: Schema.Literals([
+		"pending",
+		"completed",
+		"failed",
+		"cancelled"
+	]),
+	requestedBy: Schema.NonEmptyString,
+	requestedByName: Schema.NullOr(Schema.String),
+	failure: Schema.NullOr(PublicationFailure)
+});
+//#endregion
+//#region ../model/src/Presence.ts
+const PresenceClientId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("PresenceClientId"));
+const PresenceParticipant = Schema.Struct({
+	id: Schema.String,
+	name: Schema.String
+});
+const Position = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(1024));
+const PresenceCursor = Schema.Struct({
+	anchor: Position,
+	head: Position
+});
+const PresenceHeartbeat = Schema.Struct({
+	clientId: PresenceClientId,
+	cursor: Schema.NullOr(PresenceCursor)
+});
+const PresenceLeave = Schema.Struct({ clientId: PresenceClientId });
+const RemoteCursor = Schema.Struct({
+	clientId: PresenceClientId,
+	userId: Schema.String,
+	name: Schema.String,
+	cursor: PresenceCursor
+});
+const PresencePage = Schema.Struct({
+	participants: Schema.Array(PresenceParticipant),
+	cursors: Schema.Array(RemoteCursor)
+});
+const ActivityAction = Schema.Literals([
+	"document.created",
+	"document.updated",
+	"document.settings.updated",
+	"document.moved",
+	"document.trashed",
+	"document.revision.restored",
+	"document.revision-link.created",
+	"document.revision-link.revoked",
+	"document.untrashed",
+	"document.published",
+	"document.unpublished",
+	"document.schedule.created",
+	"document.schedule.cancelled",
+	"document.schedule.completed",
+	"document.schedule.failed",
+	"media.uploaded",
+	"media.removed",
+	"media.cleaned",
+	"seo.saved",
+	"seo.published",
+	"user.created",
+	"user.removed",
+	"user.role.changed",
+	"user.sessions.revoked",
+	"authentication.signed-in",
+	"authentication.signed-out",
+	"authentication.password.changed",
+	"authentication.password.reset"
+]);
+const ActivityTargetKind = Schema.Literals([
+	"document",
+	"media",
+	"media-library",
+	"seo",
+	"user"
+]);
+const ActivityTarget = Schema.Union([
+	Schema.Struct({
+		kind: Schema.tag("document"),
+		documentId: DocumentId
+	}),
+	Schema.Struct({
+		kind: Schema.tag("media"),
+		mediaId: MediaId
+	}),
+	Schema.Struct({ kind: Schema.tag("media-library") }),
+	Schema.Struct({ kind: Schema.tag("seo") }),
+	Schema.Struct({
+		kind: Schema.tag("user"),
+		userId: Schema.NonEmptyString
+	})
+]).pipe(Schema.toTaggedUnion("kind"));
+const ActivityActor = Schema.Struct({
+	id: Schema.NonEmptyString,
+	name: Schema.NonEmptyString,
+	email: Schema.optionalKey(Schema.String)
+});
+const ActivityEntry = Schema.Struct({
+	id: Schema.String.check(Schema.isUUID()),
+	action: ActivityAction,
+	actor: ActivityActor,
+	requestId: Schema.String.check(Schema.isUUID()),
+	reason: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(1e3))),
+	target: ActivityTarget,
+	details: Schema.JsonObject,
+	occurredAt: Schema.DateTimeUtcFromString
+});
+const ActivityQuery = Schema.Struct({
+	action: Schema.optionalKey(ActivityAction),
+	actorId: Schema.optionalKey(Schema.NonEmptyString),
+	cursor: Schema.optionalKey(Schema.NonEmptyString),
+	offset: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+	limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 100
+	}))),
+	requestId: Schema.optionalKey(Schema.String.check(Schema.isUUID())),
+	targetId: Schema.optionalKey(Schema.NonEmptyString),
+	targetKind: Schema.optionalKey(ActivityTargetKind)
+});
+const ActivityPage = Schema.Struct({
+	entries: Schema.Array(ActivityEntry),
+	nextCursor: Schema.optionalKey(Schema.NonEmptyString),
+	total: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+});
+//#endregion
+//#region ../model/src/Content.ts
+const ContentBaseline = Schema.Struct({ draft: Schema.String });
+const ContentDocument = Schema.Struct({
+	identity: DocumentIdentity,
+	draft: DocumentSource,
+	baseline: ContentBaseline
+});
+const ContentSnapshot = Schema.Struct({
+	format: Schema.Literal(1),
+	documents: Schema.Array(ContentDocument),
+	media: Schema.Array(MediaAsset)
+});
+const ContentApplyInput = Schema.Struct({
+	format: Schema.Literal(1),
+	documents: Schema.Array(ContentDocument)
+});
+const ContentPlanItem = Schema.Struct({
+	documentId: DocumentIdentity.fields.documentId,
+	action: Schema.Literals([
+		"create",
+		"update",
+		"unchanged",
+		"conflict"
+	]),
+	reason: Schema.optionalKey(Schema.String)
+});
+const ContentPlan = Schema.Struct({ items: Schema.Array(ContentPlanItem) });
+const ContentDocumentVersion = Schema.Struct({
+	documentId: DocumentIdentity.fields.documentId,
+	revisionId: RevisionId,
+	documentVersion: DocumentVersion,
+	websiteRevisionId: Schema.NullOr(RevisionId)
+});
+/** Sources, baselines, and mutation handles accepted atomically with the import. */
+const ContentApplyResult = Schema.Struct({
+	items: ContentPlan.fields.items,
+	documents: Schema.Array(ContentDocument),
+	versions: Schema.Array(ContentDocumentVersion)
+});
+//#endregion
+//#region ../model/src/Configuration.ts
+const ConfigurationCatalog = Schema.Struct({
+	version: Schema.Literal(1),
+	collections: Schema.Array(CollectionDefinition),
+	blocks: Schema.Array(BlockDefinition),
+	locales: Schema.NullOr(LocaleConfiguration)
+});
+const ConfigurationAffectedDocument = Schema.Struct({
+	documentId: DocumentId,
+	state: Schema.Literals([
+		"draft",
+		"published",
+		"trashed"
+	]),
+	route: Schema.NullOr(Schema.String),
+	severity: Schema.Literals(["error", "warning"]),
+	issues: Schema.Array(Schema.NonEmptyString)
+});
+const ConfigurationReport = Schema.Struct({
+	compatible: Schema.Boolean,
+	checkedDocuments: Schema.Struct({
+		drafts: Schema.Int,
+		published: Schema.Int,
+		trashed: Schema.Int
+	}),
+	documents: Schema.Array(ConfigurationAffectedDocument)
+});
+//#endregion
+//#region ../model/src/Data.ts
+const Timestamp = Schema.String.check(Schema.makeFilter((value) => Number.isFinite(Date.parse(value)), { expected: "an ISO date and time" }));
+const DataDocument = Schema.Struct({
+	identity: Document.fields.identity,
+	settings: Document.fields.settings,
+	latestRevisionId: Document.fields.latestRevisionId,
+	websiteRevisionId: Document.fields.websiteRevisionId,
+	createdAt: Timestamp,
+	updatedAt: Timestamp,
+	updatedBy: Schema.String,
+	publishedAt: Schema.NullOr(Timestamp),
+	trash: Schema.NullOr(Schema.Struct({
+		deletedAt: Timestamp,
+		batchId: DocumentId,
+		path: Schema.String
+	})),
+	revisions: Schema.Array(Schema.Struct({
+		revisionId: DocumentRevision.fields.revisionId,
+		number: DocumentRevision.fields.number,
+		content: DocumentRevision.fields.content,
+		createdAt: Timestamp,
+		createdBy: Schema.String
+	})).check(Schema.isMinLength(1)),
+	/** Only present when Working differs from the latest saved content or current SEO. */
+	working: Schema.optionalKey(DocumentSource)
+});
+const DataMedia = Schema.Struct({
+	id: MediaAsset.fields.id,
+	name: MediaAsset.fields.name,
+	folder: MediaAsset.fields.folder,
+	mimeType: MediaAsset.fields.mimeType,
+	byteSize: MediaAsset.fields.byteSize,
+	sha256: MediaAsset.fields.sha256,
+	createdAt: Timestamp,
+	updatedAt: Timestamp,
+	uploadedBy: Schema.NullOr(Schema.String)
+});
+/** Portable authored state. Credentials, live sessions and temporary access grants belong to the installation. */
+const CmsData = Schema.Struct({
+	format: Schema.Literal(1),
+	configuration: ConfigurationCatalog,
+	documents: Schema.Array(DataDocument),
+	media: Schema.Array(DataMedia),
+	folders: Schema.Array(MediaFolder),
+	people: Schema.Array(Schema.Struct({
+		...Person.fields,
+		createdAt: Timestamp
+	})),
+	seo: Schema.Struct({
+		revisions: Schema.Array(SiteSeoRevision).check(Schema.isMinLength(1)),
+		workingVersion: SiteSeoRevision.fields.version,
+		publishedVersion: SiteSeoRevision.fields.version
+	}),
+	redirects: Schema.Array(Schema.Struct({
+		fromPath: Schema.String,
+		documentId: DocumentId
+	})),
+	releases: Schema.Array(Schema.Struct({
+		id: PublicationRelease.fields.id,
+		label: PublicationRelease.fields.label,
+		changes: PublicationRelease.fields.changes,
+		publishAt: PublicationRelease.fields.publishAt,
+		status: PublicationRelease.fields.status,
+		requestedBy: PublicationRelease.fields.requestedBy,
+		failure: PublicationRelease.fields.failure,
+		createdAt: Timestamp
+	})),
+	activity: Schema.Array(Schema.Struct({
+		...ActivityEntry.fields,
+		occurredAt: Timestamp
+	}))
+});
+/** Collection order is authored; record order in an export is deterministic. */
+function orderedData(data) {
+	return {
+		...data,
+		documents: data.documents.toSorted((a, b) => a.identity.documentId.localeCompare(b.identity.documentId)).map((document) => ({
+			...document,
+			revisions: document.revisions.toSorted((a, b) => a.number - b.number)
+		})),
+		media: data.media.toSorted((a, b) => a.id.localeCompare(b.id)),
+		folders: data.folders.toSorted(),
+		people: data.people.toSorted((a, b) => a.id.localeCompare(b.id)),
+		seo: {
+			...data.seo,
+			revisions: data.seo.revisions.toSorted((a, b) => a.version.localeCompare(b.version))
+		},
+		redirects: data.redirects.toSorted((a, b) => a.fromPath.localeCompare(b.fromPath)),
+		releases: data.releases.toSorted((a, b) => a.id.localeCompare(b.id))
+	};
+}
+const DataImportInput = Schema.Struct({
+	data: CmsData,
+	replace: Schema.Boolean
+});
+const DataImportPlan = Schema.Struct({
+	stamp: Schema.NonEmptyString,
+	status: Schema.Literals(["ready", "unchanged"]),
+	documents: Schema.Int,
+	revisions: Schema.Int,
+	media: Schema.Int,
+	people: Schema.Int,
+	removedDocuments: Schema.Int,
+	removedMedia: Schema.Int
+});
+const DataImportApply = Schema.Struct({
+	...DataImportInput.fields,
+	stamp: Schema.NonEmptyString
+});
+//#endregion
+//#region ../model/src/Search.ts
+const Offset = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const SearchRange = Schema.Struct({
+	from: Offset,
+	to: Offset
+});
+const SearchTarget = Schema.Union([PreviewFocusTarget, Schema.Struct({
+	kind: Schema.Literal("seo"),
+	path: Schema.Array(Schema.String)
+})]);
+/** Ranges address the excerpt; offset locates that excerpt in the original control or text block. */
+const SearchMatch = Schema.Struct({
+	locale: Schema.NullOr(Schema.String),
+	label: Schema.String,
+	target: SearchTarget,
+	text: Schema.String,
+	offset: Offset,
+	ranges: Schema.Array(SearchRange)
+});
+const SearchHit = Schema.Struct({
+	documentId: DocumentId,
+	title: Schema.String,
+	path: Schema.String,
+	matchCount: Offset,
+	matches: Schema.Array(SearchMatch)
+});
+const SearchResults = Schema.Struct({
+	version: Offset,
+	hits: Schema.Array(SearchHit)
+});
+const SearchSelection = Schema.Struct({
+	documentId: DocumentId,
+	match: SearchMatch
+});
+Schema.Struct({
+	selection: SearchSelection,
+	activation: Schema.String
+});
+//#endregion
+//#region ../model/src/StudioApi.ts
+const StudioUser = Schema.Struct({
+	id: Schema.String,
+	name: Schema.String,
+	email: Schema.String,
+	role: Role
+});
+const Configuration = Schema.Struct({
+	collections: Schema.Array(CollectionDefinition),
+	blocks: Schema.Array(BlockDefinition),
+	locales: Schema.NullOr(LocaleConfiguration),
+	mediaUploadLimit: Schema.Int.check(Schema.isGreaterThan(0)),
+	studioModules: Schema.Array(StudioModule)
+});
+const Version = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const ResourceVersions = Schema.Struct({
+	catalog: Version,
+	inventory: Version,
+	media: Version,
+	people: Version,
+	activity: Version,
+	seo: Version,
+	releases: Version,
+	links: Version
+});
+const CatalogPage = Schema.Struct({
+	version: Version,
+	entries: Schema.Array(DocumentCatalogSummary)
+});
+const InventoryPage = Schema.Struct({
+	version: Version,
+	summaries: Schema.Array(DocumentInventorySummary)
+});
+const Bootstrap = Schema.TaggedUnion({
+	Setup: {},
+	SignedOut: {},
+	Ready: {
+		user: StudioUser,
+		configuration: Configuration,
+		epoch: Schema.String,
+		versions: ResourceVersions,
+		catalog: CatalogPage
+	}
+});
+const Changes = Schema.Struct({
+	user: StudioUser,
+	epoch: Schema.String,
+	versions: ResourceVersions,
+	document: Schema.NullOr(Schema.Struct({
+		documentId: DocumentId,
+		generation: Schema.NullOr(Version),
+		version: Schema.NullOr(Version),
+		presence: PresencePage
+	}))
+});
+const ErrorFields = {
+	...StudioErrorFields,
+	error: Schema.String,
+	changes: Schema.optionalKey(Schema.Array(Schema.String))
+};
+var BadRequest = class extends Schema.TaggedError()("Studio.BadRequest", ErrorFields, { httpApiStatus: 400 }) {};
+var Unauthorized = class extends Schema.TaggedError()("Studio.Unauthorized", ErrorFields, { httpApiStatus: 401 }) {};
+var Forbidden = class extends Schema.TaggedError()("Studio.Forbidden", ErrorFields, { httpApiStatus: 403 }) {};
+var NotFound = class extends Schema.TaggedError()("Studio.NotFound", ErrorFields, { httpApiStatus: 404 }) {};
+var Conflict = class extends Schema.TaggedError()("Studio.Conflict", ErrorFields, { httpApiStatus: 409 }) {};
+var Invalid = class extends Schema.TaggedError()("Studio.Invalid", ErrorFields, { httpApiStatus: 422 }) {};
+var Unavailable = class extends Schema.TaggedError()("Studio.Unavailable", ErrorFields, { httpApiStatus: 503 }) {};
+var InternalError = class extends Schema.TaggedError()("Studio.InternalError", ErrorFields, { httpApiStatus: 500 }) {};
+const errors = [
+	BadRequest,
+	Unauthorized,
+	Forbidden,
+	NotFound,
+	Conflict,
+	Invalid,
+	Unavailable,
+	InternalError
+];
+const ApiError = Schema.Union(errors);
+var CurrentUser = class extends Context.Service()("@internal/model/StudioApi/CurrentUser") {};
+var Authorize = class extends HttpApiMiddleware.Service()("@internal/model/StudioApi/Authorize", { error: errors }) {};
+const id = { documentId: DocumentId };
+const revision = {
+	...id,
+	revisionId: RevisionId
+};
+const pagination = {
+	offset: Schema.optional(Schema.NumberFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0))),
+	limit: Schema.optional(Schema.NumberFromString.check(Schema.isInt(), Schema.isBetween({
+		minimum: 1,
+		maximum: 100
+	}))),
+	search: Schema.optional(Schema.String.check(Schema.isMaxLength(200)))
+};
+const numberHeader = Schema.NumberFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0));
+const bytes = Schema.Uint8Array.pipe(HttpApiSchema.asUint8Array());
+const WorkingResponse = HttpApiSchema.WithHeaders(bytes, {
+	"x-cms-working-generation": numberHeader,
+	"x-cms-working-version": numberHeader
+});
+const workingHeaders = { "x-cms-working-generation": numberHeader };
+const sourceMutation = { expectedDocumentVersion: DocumentVersion };
+const api = HttpApi.make("Studio").add(HttpApiGroup.make("session").add(HttpApiEndpoint.get("bootstrap", "/_cms/api/bootstrap", {
+	error: errors,
+	success: Bootstrap
+}), HttpApiEndpoint.get("installation", "/_cms/api/installation", {
+	error: errors,
+	success: Schema.Struct({ initialized: Schema.Boolean })
+}), HttpApiEndpoint.post("initialize", "/_cms/api/installation", {
+	error: errors,
+	payload: Schema.Struct({
+		email: PersonEmail,
+		name: Schema.NonEmptyString,
+		password: Schema.String.check(Schema.isMinLength(8)),
+		installationSecret: Schema.NonEmptyString
+	}),
+	success: StudioUser.pipe(HttpApiSchema.status(201))
+})), HttpApiGroup.make("connection").add(HttpApiEndpoint.get("versions", "/_cms/api/versions", {
+	error: errors,
+	query: { documentId: Schema.optional(DocumentId) },
+	success: Changes
+}), HttpApiEndpoint.get("user", "/_cms/api/session", {
+	error: errors,
+	success: StudioUser
+}), HttpApiEndpoint.get("configuration", "/_cms/api/config", {
+	error: errors,
+	success: Configuration
+}), HttpApiEndpoint.get("changes", "/_cms/api/changes", {
+	error: errors,
+	query: { documentId: Schema.optional(DocumentId) },
+	success: HttpApiSchema.StreamSse({
+		data: Changes,
+		error: ApiError
+	})
+})).middleware(Authorize), HttpApiGroup.make("documents").add(HttpApiEndpoint.get("catalog", "/_cms/api/documents", {
+	error: errors,
+	success: CatalogPage
+}), HttpApiEndpoint.post("create", "/_cms/api/documents", {
+	error: errors,
+	payload: Schema.Struct({
+		collection: CollectionName,
+		source: DocumentSource,
+		templateId: Schema.optional(Schema.NonEmptyString)
+	}),
+	success: DocumentSnapshot.pipe(HttpApiSchema.status(201))
+}), HttpApiEndpoint.get("inventory", "/_cms/api/documents/inventory", {
+	error: errors,
+	success: InventoryPage
+}), HttpApiEndpoint.get("search", "/_cms/api/documents/search", {
+	error: errors,
+	query: { q: Schema.String.check(Schema.isMaxLength(200)) },
+	success: SearchResults
+}), HttpApiEndpoint.get("draft", "/_cms/api/documents/:documentId", {
+	error: errors,
+	params: id,
+	success: DocumentSnapshot
+}), HttpApiEndpoint.get("settings", "/_cms/api/documents/:documentId/settings", {
+	error: errors,
+	params: id,
+	success: Document
+}), HttpApiEndpoint.get("editor", "/_cms/api/documents/:documentId/editor", {
+	error: errors,
+	params: id,
+	success: DocumentEditorSnapshot
+}), HttpApiEndpoint.get("preview", "/_cms/api/documents/:documentId/preview", {
+	error: errors,
+	params: id,
+	success: DocumentSource
+}), HttpApiEndpoint.get("diagnostics", "/_cms/api/documents/:documentId/diagnostics", {
+	error: errors,
+	params: id,
+	success: Schema.Array(DocumentIssue)
+}), HttpApiEndpoint.get("revisions", "/_cms/api/documents/:documentId/revisions", {
+	error: errors,
+	params: id,
+	query: { before: Schema.optional(Schema.NumberFromString.check(Schema.isInt(), Schema.isGreaterThan(0))) },
+	success: RevisionHistoryPage
+}), HttpApiEndpoint.get("revision", "/_cms/api/documents/:documentId/revisions/:revisionId", {
+	error: errors,
+	params: revision,
+	success: DocumentRevision
+}), HttpApiEndpoint.get("revisionSnapshot", "/_cms/api/documents/:documentId/revisions/:revisionId/snapshot", {
+	error: errors,
+	params: revision,
+	success: DocumentSnapshot
+}), HttpApiEndpoint.post("duplicate", "/_cms/api/documents/:documentId/duplicate", {
+	error: errors,
+	params: id,
+	payload: Schema.Struct({
+		expectedRevisionId: RevisionId,
+		title: Schema.NonEmptyString,
+		placement: DocumentPlacement
+	}),
+	success: DocumentSnapshot.pipe(HttpApiSchema.status(201))
+}), HttpApiEndpoint.post("checkpoint", "/_cms/api/documents/:documentId/checkpoint", {
+	error: errors,
+	params: id,
+	success: DocumentCheckpoint
+}), HttpApiEndpoint.post("move", "/_cms/api/documents/:documentId/move", {
+	error: errors,
+	params: id,
+	payload: Schema.Struct({
+		...sourceMutation,
+		placement: DocumentPlacement
+	}),
+	success: DocumentSnapshot
+}), HttpApiEndpoint.post("restore", "/_cms/api/documents/:documentId/restore", {
+	error: errors,
+	params: id,
+	payload: Schema.Struct({
+		...sourceMutation,
+		sourceRevisionId: RevisionId
+	}),
+	success: DocumentEditorSnapshot
+}), HttpApiEndpoint.put("selectWebsiteRevision", "/_cms/api/documents/:documentId/website-version", {
+	error: errors,
+	params: id,
+	payload: WebsiteRevisionSelection,
+	success: Document
+}), HttpApiEndpoint.get("trashPlan", "/_cms/api/documents/:documentId/trash-plan", {
+	error: errors,
+	params: id,
+	success: TrashPlan
+}), HttpApiEndpoint.post("trash", "/_cms/api/documents/:documentId/trash", {
+	error: errors,
+	params: id,
+	payload: TrashPlan,
+	success: TrashPlan
+}), HttpApiEndpoint.get("listTrash", "/_cms/api/trash", {
+	error: errors,
+	success: Schema.Array(TrashedDocument)
+}), HttpApiEndpoint.post("restoreTrash", "/_cms/api/documents/:documentId/restore-trash", {
+	error: errors,
+	params: id,
+	payload: Schema.Struct({ expectedRevisionId: RevisionId }),
+	success: Schema.Array(DocumentSnapshot)
+})).middleware(Authorize), HttpApiGroup.make("working").add(HttpApiEndpoint.get("open", "/_cms/api/documents/:documentId/working", {
+	error: errors,
+	params: id,
+	success: WorkingResponse
+}), HttpApiEndpoint.post("sync", "/_cms/api/documents/:documentId/working/sync", {
+	error: errors,
+	params: id,
+	payload: bytes,
+	headers: {
+		...workingHeaders,
+		"x-cms-working-version": numberHeader
+	},
+	success: WorkingResponse
+}), HttpApiEndpoint.post("apply", "/_cms/api/documents/:documentId/working", {
+	error: errors,
+	params: id,
+	payload: bytes,
+	headers: {
+		...workingHeaders,
+		"x-cms-working-vector": Schema.optional(Schema.String.check(Schema.isMaxLength(24e3)))
+	},
+	success: WorkingResponse
+}), HttpApiEndpoint.post("translation", "/_cms/api/documents/:documentId/translation", {
+	error: errors,
+	params: id,
+	payload: Schema.Struct({
+		generation: Version,
+		locale: Locale,
+		action: Schema.Literals(["add", "remove"])
+	}),
+	success: WorkingResponse
+}), HttpApiEndpoint.post("presence", "/_cms/api/documents/:documentId/presence", {
+	error: errors,
+	params: id,
+	payload: PresenceHeartbeat,
+	success: PresencePage
+}), HttpApiEndpoint.delete("leavePresence", "/_cms/api/documents/:documentId/presence", {
+	error: errors,
+	params: id,
+	payload: PresenceLeave,
+	success: PresencePage
+})).middleware(Authorize), HttpApiGroup.make("publication").add(HttpApiEndpoint.post("plan", "/_cms/api/publication/plan", {
+	error: errors,
+	payload: PublicationSelection,
+	success: PublicationPlan
+}), HttpApiEndpoint.post("apply", "/_cms/api/publication", {
+	error: errors,
+	payload: Schema.Struct({
+		changes: PublicationChanges,
+		stamp: Schema.String
+	}),
+	success: PublicationPlan
+}), HttpApiEndpoint.get("releases", "/_cms/api/releases", {
+	error: errors,
+	query: { documentId: Schema.optional(DocumentId) },
+	success: Schema.Array(PublicationRelease)
+}), HttpApiEndpoint.post("createRelease", "/_cms/api/releases", {
+	error: errors,
+	payload: Schema.Struct({
+		label: Schema.optional(Schema.String.check(Schema.isMaxLength(120))),
+		changes: PublicationChanges,
+		stamp: Schema.String,
+		publishAt: Schema.String
+	}),
+	success: PublicationRelease.pipe(HttpApiSchema.status(201))
+}), HttpApiEndpoint.post("cancelRelease", "/_cms/api/releases/:id/cancel", {
+	error: errors,
+	params: { id: PublicationScheduleId },
+	success: PublicationRelease
+})).middleware(Authorize), HttpApiGroup.make("links").add(HttpApiEndpoint.get("list", "/_cms/api/documents/:documentId/revision-links", {
+	error: errors,
+	params: id,
+	success: Schema.Array(RevisionLink)
+}), HttpApiEndpoint.post("create", "/_cms/api/documents/:documentId/revision-links", {
+	error: errors,
+	params: id,
+	payload: CreateRevisionLink,
+	success: IssuedRevisionLink.pipe(HttpApiSchema.status(201))
+}), HttpApiEndpoint.delete("revoke", "/_cms/api/revision-links/:id", {
+	error: errors,
+	params: { id: RevisionLinkId },
+	success: Schema.Struct({ revoked: Schema.Boolean })
+})).middleware(Authorize), HttpApiGroup.make("media").add(HttpApiEndpoint.get("list", "/_cms/api/media", {
+	error: errors,
+	query: {
+		...pagination,
+		folder: Schema.optional(Schema.String),
+		kind: Schema.optional(MediaLibraryKind),
+		sort: Schema.optional(MediaSort)
+	},
+	success: MediaPage
+}), HttpApiEndpoint.get("folders", "/_cms/api/media/folders", {
+	error: errors,
+	success: Schema.Array(MediaFolderSummary)
+}), HttpApiEndpoint.post("createFolder", "/_cms/api/media/folders", {
+	error: errors,
+	payload: Schema.Struct({ folder: MediaFolder }),
+	success: HttpApiSchema.NoContent
+}), HttpApiEndpoint.get("get", "/_cms/api/media/:id", {
+	error: errors,
+	params: { id: MediaId },
+	success: MediaAsset
+}), HttpApiEndpoint.post("upload", "/_cms/api/media", {
+	error: errors,
+	headers: {
+		"x-cms-media-name": Schema.String,
+		"x-cms-media-folder": Schema.optional(Schema.String),
+		"x-cms-media-size": numberHeader,
+		"content-type": Schema.String,
+		"x-cms-media-sha256": Schema.optional(Schema.String),
+		"x-cms-media-id": Schema.optional(MediaId)
+	},
+	success: MediaAsset.pipe(HttpApiSchema.status(201))
+}), HttpApiEndpoint.delete("remove", "/_cms/api/media/:id", {
+	error: errors,
+	params: { id: MediaId },
+	success: HttpApiSchema.NoContent
+})).middleware(Authorize), HttpApiGroup.make("people").add(HttpApiEndpoint.get("list", "/_cms/api/people", {
+	error: errors,
+	query: pagination,
+	success: PeoplePage
+}), HttpApiEndpoint.post("create", "/_cms/api/people", {
+	error: errors,
+	payload: CreatePerson,
+	success: Person.pipe(HttpApiSchema.status(201))
+}), HttpApiEndpoint.post("invite", "/_cms/api/people/:id/invite", {
+	error: errors,
+	params: { id: Schema.NonEmptyString },
+	success: Invitation
+}), HttpApiEndpoint.post("changeRole", "/_cms/api/people/:id/role", {
+	error: errors,
+	params: { id: Schema.NonEmptyString },
+	payload: Schema.Struct({ role: Role }),
+	success: Person
+}), HttpApiEndpoint.post("revokeSessions", "/_cms/api/people/:id/sessions/revoke", {
+	error: errors,
+	params: { id: Schema.NonEmptyString },
+	success: Person
+}), HttpApiEndpoint.post("remove", "/_cms/api/people/:id/remove", {
+	error: errors,
+	params: { id: Schema.NonEmptyString },
+	success: Schema.Struct({ removed: Schema.Boolean })
+})).middleware(Authorize), HttpApiGroup.make("activity").add(HttpApiEndpoint.get("list", "/_cms/api/activity", {
+	error: errors,
+	query: {
+		...ActivityQuery.fields,
+		offset: pagination.offset,
+		limit: pagination.limit
+	},
+	success: ActivityPage
+})).middleware(Authorize), HttpApiGroup.make("seo").add(HttpApiEndpoint.get("state", "/_cms/api/seo", {
+	error: errors,
+	success: SiteSeoState
+}), HttpApiEndpoint.get("working", "/_cms/api/seo/working", {
+	error: errors,
+	success: SiteSeoSettings
+}), HttpApiEndpoint.put("save", "/_cms/api/seo", {
+	error: errors,
+	payload: Schema.Struct({
+		expectedVersion: Schema.String.check(Schema.isUUID()),
+		settings: SiteSeoSettings
+	}),
+	success: SiteSeoState
+}), HttpApiEndpoint.post("publish", "/_cms/api/seo/publish", {
+	error: errors,
+	payload: Schema.Struct({
+		expectedVersion: Schema.String.check(Schema.isUUID()),
+		confirmedSiteWideChange: Schema.optional(Schema.Boolean)
+	}),
+	success: SiteSeoState
+})).middleware(Authorize), HttpApiGroup.make("data").add(HttpApiEndpoint.get("snapshot", "/_cms/api/data", {
+	error: errors,
+	success: CmsData
+}), HttpApiEndpoint.post("plan", "/_cms/api/data/plan", {
+	error: errors,
+	payload: DataImportInput,
+	success: DataImportPlan
+}), HttpApiEndpoint.post("apply", "/_cms/api/data/apply", {
+	error: errors,
+	payload: DataImportApply,
+	success: DataImportPlan
+})).annotate(HttpApi.PayloadParseOptions, { onExcessProperty: "error" }).middleware(Authorize), HttpApiGroup.make("content").add(HttpApiEndpoint.get("snapshot", "/_cms/api/content", {
+	error: errors,
+	success: ContentSnapshot
+}), HttpApiEndpoint.post("plan", "/_cms/api/content/plan", {
+	error: errors,
+	payload: ContentApplyInput,
+	success: ContentPlan
+}), HttpApiEndpoint.post("apply", "/_cms/api/content/apply", {
+	error: errors,
+	payload: ContentApplyInput,
+	success: ContentApplyResult
+})).annotate(HttpApi.PayloadParseOptions, { onExcessProperty: "error" }).middleware(Authorize));
+//#endregion
+export { PublicationRelease as C, PublicationPlan as S, ConfigurationCatalog as _, Conflict as a, ActivityPage as b, InternalError as c, Unauthorized as d, Unavailable as f, orderedData as g, CmsData as h, Bootstrap as i, Invalid as l, errors as m, Authorize as n, CurrentUser as o, api as p, BadRequest as r, Forbidden as s, ApiError as t, NotFound as u, ConfigurationReport as v, PublicationSelection as w, PublicationChanges as x, ActivityEntry as y };