@phtngyn/cms 0.1.0-beta.0 → 0.1.0-beta.2

package/src/models-DwYioyNV.js

@@ -0,0 +1,726 @@
+import { c as RevisionId, d as SourcePath, f as nonNegativeInt, i as DocumentVersion, o as PublicPath, p as publicPathPattern, r as DocumentId, s as RelativeDocumentPath, t as DocumentGeneration, u as Slug } from "./scalars-B2lgGUnj.js";
+import { DateTime, Option, Schema } from "effect";
+
+//#region ../protocol/src/Identity.ts
+const RequestId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("RequestId"));
+
+//#endregion
+//#region ../protocol/src/internal/configuration/scalars.ts
+const collectionNamePattern = /^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$/u;
+const localePattern = /^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/u;
+const sourceDirectoryPattern = /^(?:\.|(?!\.)[^/?#\\]+(?:\/(?!\.)[^/?#\\]+)*)$/u;
+const AddressPattern = Schema.String.check(Schema.isPattern(publicPathPattern)).pipe(Schema.brand("AddressPattern"));
+const CollectionName = Schema.String.check(Schema.isPattern(collectionNamePattern)).pipe(Schema.brand("CollectionName"));
+const Locale = Schema.String.check(Schema.isPattern(localePattern)).pipe(Schema.brand("Locale"));
+const SourceDirectory = Schema.String.check(Schema.isPattern(sourceDirectoryPattern)).pipe(Schema.brand("SourceDirectory"));
+
+//#endregion
+//#region ../protocol/src/Media.ts
+/**
+* Media wire models. Search pages are newest-first with opaque continuation cursors; only ready
+* assets are public results, and names, folders, and object keys are validated path-safe values.
+*/
+const hasUnsafeMediaCharacter = (value) => {
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		if (character === "\\" || codePoint !== void 0 && (codePoint <= 31 || codePoint === 127)) return true;
+	}
+	return false;
+};
+const isSafeMediaPath = (value, allowEmpty) => {
+	if (value.length === 0) return allowEmpty;
+	if (value !== value.trim() || value.startsWith("/") || value.endsWith("/") || hasUnsafeMediaCharacter(value)) return false;
+	return value.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+};
+const safeMediaFolder = Schema.makeFilter((value) => isSafeMediaPath(value, true), { expected: "a provider-relative media folder without traversal segments" });
+const safeMediaObjectKey = Schema.makeFilter((value) => isSafeMediaPath(value, false), { expected: "a non-empty provider-relative media object key without traversal segments" });
+const safeMediaName = Schema.makeFilter((value) => value.length > 0 && value.length <= 255 && value === value.trim() && value !== "." && value !== ".." && !value.includes("/") && !hasUnsafeMediaCharacter(value), { expected: "a safe media file name of at most 255 characters" });
+const MediaId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("MediaId"));
+const MediaFolder = Schema.String.check(Schema.isMaxLength(512), safeMediaFolder).pipe(Schema.brand("MediaFolder"));
+const MediaObjectKey = Schema.String.check(Schema.isMaxLength(1024), safeMediaObjectKey).pipe(Schema.brand("MediaObjectKey"));
+const MediaName = Schema.String.check(safeMediaName).pipe(Schema.brand("MediaName"));
+const MediaCursor = Schema.NonEmptyString.pipe(Schema.brand("MediaCursor"));
+const ImageMimeType = Schema.Literals([
+	"image/avif",
+	"image/gif",
+	"image/jpeg",
+	"image/png",
+	"image/webp"
+]);
+const MediaStatus = Schema.Literals([
+	"uploading",
+	"ready",
+	"deleting"
+]);
+const MediaByteSize = Schema.Int.check(Schema.isGreaterThan(0));
+const MediaAsset = Schema.Struct({
+	kind: Schema.tag("image"),
+	id: MediaId,
+	objectKey: MediaObjectKey,
+	url: Schema.NonEmptyString,
+	name: MediaName,
+	folder: MediaFolder,
+	mimeType: ImageMimeType,
+	byteSize: MediaByteSize,
+	createdAt: Schema.DateTimeUtcFromString,
+	updatedAt: Schema.DateTimeUtcFromString,
+	status: MediaStatus
+}).annotate({ identifier: "MediaAsset" });
+const MediaUpload = Schema.Struct({
+	name: MediaName,
+	folder: Schema.optionalKey(MediaFolder),
+	declaredMimeType: Schema.optionalKey(Schema.NonEmptyString),
+	declaredByteSize: MediaByteSize
+}).annotate({ identifier: "MediaUpload" });
+const MediaQuery = Schema.Struct({
+	cursor: Schema.optionalKey(MediaCursor),
+	folder: Schema.optionalKey(MediaFolder),
+	search: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(200))),
+	limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 100
+	})))
+}).annotate({ identifier: "MediaQuery" });
+const ReadyMediaAssets = Schema.Array(MediaAsset).check(Schema.makeFilter((assets) => assets.every((asset) => asset.status === "ready"), { expected: "media assets whose lifecycle status is ready" }));
+const MediaPage = Schema.Struct({
+	assets: ReadyMediaAssets,
+	folders: Schema.Array(MediaFolder),
+	nextCursor: Schema.optionalKey(MediaCursor),
+	total: nonNegativeInt
+}).annotate({ identifier: "MediaPage" });
+const MediaReference = Schema.Struct({
+	documentId: DocumentId,
+	mediaId: Schema.optionalKey(MediaId),
+	path: PublicPath,
+	sourcePath: SourcePath,
+	objectKey: MediaObjectKey,
+	nodePath: Schema.Array(nonNegativeInt)
+}).annotate({ identifier: "MediaReference" });
+const MediaObjectMismatch = Schema.Struct({
+	asset: MediaAsset,
+	storedByteSize: MediaByteSize,
+	storedMimeType: Schema.optionalKey(ImageMimeType)
+}).annotate({ identifier: "MediaObjectMismatch" });
+const MediaIntegrityReport = Schema.Struct({
+	missingAssets: Schema.Array(MediaReference),
+	missingObjects: Schema.Array(MediaAsset),
+	mismatchedObjects: Schema.Array(MediaObjectMismatch),
+	orphanedObjectKeys: Schema.Array(MediaObjectKey),
+	unusedAssets: Schema.Array(MediaAsset)
+}).annotate({ identifier: "MediaIntegrityReport" });
+const MediaCleanupReport = Schema.Struct({ removedObjectKeys: Schema.Array(MediaObjectKey) }).annotate({ identifier: "MediaCleanupReport" });
+var MediaNotFound = class extends Schema.TaggedError()("Media.NotFound", { mediaId: MediaId }) {};
+var MediaReferenced = class extends Schema.TaggedError()("Media.Referenced", {
+	mediaId: MediaId,
+	references: Schema.Array(MediaReference),
+	seoScopes: Schema.optionalKey(Schema.Array(Schema.Literals(["working", "published"])))
+}) {};
+var MediaConflict = class extends Schema.TaggedError()("Media.Conflict", { mediaId: MediaId }) {};
+var MediaInvalid = class extends Schema.TaggedError()("Media.Invalid", { message: Schema.NonEmptyString }) {};
+var MediaTooLarge = class extends Schema.TaggedError()("Media.TooLarge", {
+	declaredByteSize: MediaByteSize,
+	maxUploadBytes: MediaByteSize
+}) {};
+
+//#endregion
+//#region ../protocol/src/AccessControl.ts
+const ROLES = [
+	"administrator",
+	"editor",
+	"viewer"
+];
+const Role = Schema.Literals(ROLES);
+const StudioActor = Schema.Struct({
+	id: Schema.NonEmptyString,
+	email: Schema.NonEmptyString,
+	name: Schema.NonEmptyString,
+	roles: Schema.Array(Schema.NonEmptyString)
+}).annotate({ identifier: "StudioActor" });
+const StudioRequestContext = Schema.Struct({
+	actor: StudioActor,
+	requestId: RequestId
+}).annotate({ identifier: "StudioRequestContext" });
+const DOCUMENT_ACTIONS = [
+	"document.browse",
+	"document.read",
+	"document.trash",
+	"document.validate",
+	"document.create",
+	"document.update",
+	"document.move",
+	"document.remove",
+	"document.restore",
+	"document.undelete",
+	"document.publish",
+	"document.unpublish",
+	"document.duplicate",
+	"document.history"
+];
+const DocumentAction = Schema.Literals(DOCUMENT_ACTIONS);
+const DocumentCatalogResource = Schema.Struct({ kind: Schema.tag("catalog") });
+const CollectionResource = Schema.Struct({
+	kind: Schema.tag("collection"),
+	collection: CollectionName,
+	locale: Schema.optionalKey(Locale)
+});
+const DocumentResource = Schema.Struct({
+	kind: Schema.tag("document"),
+	documentId: DocumentId
+});
+const DocumentAccessResource = Schema.Union([
+	DocumentCatalogResource,
+	CollectionResource,
+	DocumentResource
+]).pipe(Schema.toTaggedUnion("kind"));
+const DocumentAccessDecision = Schema.Struct({
+	action: DocumentAction,
+	resource: DocumentAccessResource
+}).annotate({ identifier: "DocumentAccessDecision" });
+const MEDIA_ACTIONS = [
+	"media.read",
+	"media.search",
+	"media.integrity",
+	"media.upload",
+	"media.replace",
+	"media.remove",
+	"media.cleanup"
+];
+const MediaAction = Schema.Literals(MEDIA_ACTIONS);
+const MediaCatalogResource = Schema.Struct({ kind: Schema.tag("media-catalog") });
+const MediaAssetResource = Schema.Struct({
+	kind: Schema.tag("media-asset"),
+	mediaId: MediaId
+});
+const MediaFolderResource = Schema.Struct({
+	kind: Schema.tag("media-folder"),
+	folder: MediaFolder
+});
+const MediaResource = Schema.Union([
+	MediaCatalogResource,
+	MediaAssetResource,
+	MediaFolderResource
+]).pipe(Schema.toTaggedUnion("kind"));
+const MediaAccessDecision = Schema.Struct({
+	action: MediaAction,
+	resource: MediaResource
+}).annotate({ identifier: "MediaAccessDecision" });
+const ActivityResource = Schema.Struct({ kind: Schema.tag("activity") });
+const ActivityAccessDecision = Schema.Struct({
+	action: Schema.Literal("activity.read"),
+	resource: ActivityResource
+}).annotate({ identifier: "ActivityAccessDecision" });
+const SEO_ACTIONS = [
+	"seo.read",
+	"seo.save",
+	"seo.publish"
+];
+const SeoAction = Schema.Literals(SEO_ACTIONS);
+const SeoResource = Schema.Struct({ kind: Schema.tag("seo") });
+const SeoAccessDecision = Schema.Struct({
+	action: SeoAction,
+	resource: SeoResource
+}).annotate({ identifier: "SeoAccessDecision" });
+const STUDIO_ACTIONS = [
+	...DOCUMENT_ACTIONS,
+	...MEDIA_ACTIONS,
+	...SEO_ACTIONS,
+	"activity.read"
+];
+const StudioAction = Schema.Literals(STUDIO_ACTIONS);
+const StudioResource = Schema.Union([
+	DocumentAccessResource,
+	MediaResource,
+	ActivityResource,
+	SeoResource
+]);
+const StudioAccessDecision = Schema.Union([
+	DocumentAccessDecision,
+	MediaAccessDecision,
+	ActivityAccessDecision,
+	SeoAccessDecision
+]);
+var AuthenticationRequired = class extends Schema.TaggedError()("Studio.AuthenticationRequired", {}) {};
+var StudioEntryDenied = class extends Schema.TaggedError()("Studio.EntryDenied", {}) {};
+var AccessDenied = class extends Schema.TaggedError()("Studio.AccessDenied", {
+	action: StudioAction,
+	actorId: StudioActor.fields.id,
+	resource: StudioResource
+}) {};
+
+//#endregion
+//#region ../protocol/src/Seo.ts
+const absoluteUrl = Schema.makeFilter((value) => {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}, { expected: "an absolute HTTP or HTTPS URL" });
+const canonicalOrigin = Schema.makeFilter((value) => {
+	try {
+		const url = new URL(value);
+		return (url.protocol === "http:" || url.protocol === "https:") && url.origin === value && url.pathname === "/" && url.search === "" && url.hash === "";
+	} catch {
+		return false;
+	}
+}, { expected: "an HTTP or HTTPS origin without a path, query, hash, or trailing slash" });
+const titleTemplate = Schema.makeFilter((value) => value.includes("%s"), { expected: "a title template containing %s" });
+const calendarDate = Schema.makeFilter((value) => {
+	if (!/^\d{4}-\d{2}-\d{2}$/u.test(value)) return false;
+	const parsed = DateTime.make(value);
+	return Option.isSome(parsed) && DateTime.formatIsoDate(parsed.value) === value;
+}, { expected: "a valid calendar date in YYYY-MM-DD format" });
+const SeoUrl = Schema.NonEmptyString.check(absoluteUrl).pipe(Schema.brand("SeoUrl"));
+const SeoCanonicalOrigin = Schema.NonEmptyString.check(canonicalOrigin).pipe(Schema.brand("SeoCanonicalOrigin"));
+const SeoImage = Schema.Struct({
+	mediaId: MediaId,
+	url: SeoUrl,
+	alt: Schema.NonEmptyString
+}).annotate({ identifier: "SeoImage" });
+const StructuredDataType = Schema.Literals(["WebPage", "Article"]);
+const WebPageStructuredData = Schema.Struct({ type: Schema.tag("WebPage") });
+const ArticleStructuredData = Schema.Struct({
+	type: Schema.tag("Article"),
+	headline: Schema.optionalKey(Schema.NonEmptyString),
+	datePublished: Schema.optionalKey(Schema.String.check(calendarDate)),
+	dateModified: Schema.optionalKey(Schema.String.check(calendarDate))
+});
+const DocumentStructuredData = Schema.Union([WebPageStructuredData, ArticleStructuredData]).pipe(Schema.toTaggedUnion("type"));
+const IdentityType = Schema.Literals([
+	"Person",
+	"Organization",
+	"LocalBusiness"
+]);
+const identityFields = {
+	name: Schema.NonEmptyString,
+	url: Schema.optionalKey(SeoUrl)
+};
+const PersonIdentity = Schema.Struct({
+	type: Schema.tag("Person"),
+	...identityFields,
+	image: Schema.optionalKey(SeoImage)
+});
+const OrganizationIdentity = Schema.Struct({
+	type: Schema.tag("Organization"),
+	...identityFields,
+	logo: Schema.optionalKey(SeoImage)
+});
+const PostalAddress = Schema.Struct({
+	streetAddress: Schema.optionalKey(Schema.NonEmptyString),
+	addressLocality: Schema.optionalKey(Schema.NonEmptyString),
+	addressRegion: Schema.optionalKey(Schema.NonEmptyString),
+	postalCode: Schema.optionalKey(Schema.NonEmptyString),
+	addressCountry: Schema.optionalKey(Schema.NonEmptyString)
+}).annotate({ identifier: "PostalAddress" });
+const LocalBusinessIdentity = Schema.Struct({
+	type: Schema.tag("LocalBusiness"),
+	...identityFields,
+	logo: Schema.optionalKey(SeoImage),
+	image: Schema.optionalKey(SeoImage),
+	telephone: Schema.optionalKey(Schema.NonEmptyString),
+	address: Schema.optionalKey(PostalAddress)
+});
+const SiteIdentity = Schema.Union([
+	PersonIdentity,
+	OrganizationIdentity,
+	LocalBusinessIdentity
+]).pipe(Schema.toTaggedUnion("type"));
+const DocumentSeo = Schema.Struct({
+	title: Schema.optionalKey(Schema.NonEmptyString),
+	description: Schema.optionalKey(Schema.NonEmptyString),
+	socialTitle: Schema.optionalKey(Schema.NonEmptyString),
+	socialDescription: Schema.optionalKey(Schema.NonEmptyString),
+	socialImage: Schema.optionalKey(SeoImage),
+	index: Schema.optionalKey(Schema.Boolean),
+	follow: Schema.optionalKey(Schema.Boolean),
+	canonicalUrl: Schema.optionalKey(SeoUrl),
+	structuredData: Schema.optionalKey(DocumentStructuredData)
+}).annotate({ identifier: "DocumentSeo" });
+const GlobalSeoSettings = Schema.Struct({
+	siteName: Schema.NonEmptyString,
+	defaultDescription: Schema.optionalKey(Schema.NonEmptyString),
+	canonicalOrigin: SeoCanonicalOrigin,
+	titleTemplate: Schema.optionalKey(Schema.NonEmptyString.check(titleTemplate)),
+	socialTitle: Schema.optionalKey(Schema.NonEmptyString),
+	socialDescription: Schema.optionalKey(Schema.NonEmptyString),
+	socialImage: Schema.optionalKey(SeoImage),
+	index: Schema.Boolean,
+	follow: Schema.Boolean,
+	identity: Schema.optionalKey(SiteIdentity)
+}).annotate({ identifier: "GlobalSeoSettings" });
+const SeoCapabilities = Schema.Struct({
+	structuredDataTypes: Schema.Array(StructuredDataType),
+	identityTypes: Schema.Array(IdentityType),
+	generatedSocialImageTemplateIds: Schema.Array(Schema.NonEmptyString)
+}).annotate({ identifier: "SeoCapabilities" });
+const SeoConfiguration = Schema.Struct({
+	defaults: GlobalSeoSettings,
+	capabilities: SeoCapabilities
+}).annotate({ identifier: "SeoConfiguration" });
+const ResolvedSeo = Schema.Struct({
+	title: Schema.NonEmptyString,
+	description: Schema.optionalKey(Schema.NonEmptyString),
+	socialTitle: Schema.NonEmptyString,
+	socialDescription: Schema.optionalKey(Schema.NonEmptyString),
+	socialImage: Schema.optionalKey(SeoImage),
+	canonicalUrl: SeoUrl,
+	index: Schema.Boolean,
+	follow: Schema.Boolean,
+	structuredData: Schema.optionalKey(DocumentStructuredData),
+	identity: Schema.optionalKey(SiteIdentity)
+}).annotate({ identifier: "ResolvedSeo" });
+const SeoVersion = Schema.NonEmptyString.pipe(Schema.brand("SeoVersion"));
+const SeoRevisionId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("SeoRevisionId"));
+const SeoRevision = Schema.Struct({
+	revisionId: SeoRevisionId,
+	version: SeoVersion,
+	settings: GlobalSeoSettings,
+	editedBy: StudioActor,
+	editedAt: Schema.DateTimeUtcFromString
+}).annotate({ identifier: "SeoRevision" });
+const SeoState = Schema.Struct({
+	working: SeoRevision,
+	published: Schema.optionalKey(SeoRevision),
+	capabilities: SeoCapabilities
+}).annotate({ identifier: "SeoState" });
+const SeoSnapshot = Schema.Struct({
+	revision: SeoRevision,
+	capabilities: SeoCapabilities
+}).annotate({ identifier: "SeoSnapshot" });
+const mutationMetadata = {
+	reason: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(1e3))),
+	confirmedSiteWideChange: Schema.optionalKey(Schema.Boolean)
+};
+const SaveSeoInput = Schema.Struct({
+	expectedVersion: SeoVersion,
+	settings: GlobalSeoSettings,
+	...mutationMetadata
+}).annotate({ identifier: "SaveSeoInput" });
+const PublishSeoInput = Schema.Struct({
+	expectedVersion: SeoVersion,
+	...mutationMetadata
+}).annotate({ identifier: "PublishSeoInput" });
+const SeoMutationResult = Schema.Struct({
+	action: Schema.Literals(["seo.save", "seo.publish"]),
+	state: SeoState
+}).annotate({ identifier: "SeoMutationResult" });
+const SitemapAlternative = Schema.Struct({
+	locale: Locale,
+	loc: PublicPath
+}).annotate({ identifier: "SitemapAlternative" });
+const SitemapEntry = Schema.Struct({
+	loc: PublicPath,
+	lastmod: Schema.DateTimeUtcFromString,
+	alternatives: Schema.optionalKey(Schema.Array(SitemapAlternative))
+}).annotate({ identifier: "SitemapEntry" });
+const SeoConfirmationChange = Schema.Literals(["canonicalOrigin", "indexability"]);
+var SeoVersionConflict = class extends Schema.TaggedError()("Seo.VersionConflict", {
+	expectedVersion: SeoVersion,
+	actualVersion: SeoVersion
+}) {};
+var SeoConfirmationRequired = class extends Schema.TaggedError()("Seo.ConfirmationRequired", { changes: Schema.Array(SeoConfirmationChange) }) {};
+var SeoMediaUnavailable = class extends Schema.TaggedError()("Seo.MediaUnavailable", { mediaId: MediaId }) {};
+
+//#endregion
+//#region ../protocol/src/internal/documents/models.ts
+const DocumentIssueCode = Schema.Literals([
+	"document.collision",
+	"document.id",
+	"document.invalid",
+	"i18n.missing-translation",
+	"markdown.parse",
+	"reference.document",
+	"reference.component",
+	"seo.invalid",
+	"schema.option",
+	"schema.constraint",
+	"schema.required",
+	"schema.type",
+	"schema.unknown"
+]);
+const DocumentIssue = Schema.Struct({
+	code: DocumentIssueCode,
+	severity: Schema.Literals(["error", "warning"]),
+	message: Schema.NonEmptyString,
+	sourcePath: Schema.optionalKey(SourcePath),
+	collection: Schema.optionalKey(CollectionName),
+	field: Schema.optionalKey(Schema.NonEmptyString),
+	key: Schema.optionalKey(PublicPath),
+	locale: Schema.optionalKey(Locale)
+}).annotate({ identifier: "DocumentIssue" });
+const DocumentSourcePoint = Schema.Struct({
+	offset: nonNegativeInt,
+	line: nonNegativeInt,
+	column: nonNegativeInt
+});
+const DocumentSourceRange = Schema.Struct({
+	start: DocumentSourcePoint,
+	end: DocumentSourcePoint
+});
+const DocumentSourceMapping = Schema.Struct({
+	nodePath: Schema.Array(nonNegativeInt),
+	range: DocumentSourceRange
+});
+const MarkdownNode = Schema.suspend(() => Schema.Union([
+	Schema.String,
+	Schema.Tuple([
+		Schema.Null,
+		Schema.JsonObject,
+		Schema.String
+	]),
+	Schema.TupleWithRest(Schema.Tuple([Schema.NonEmptyString, Schema.JsonObject]), [MarkdownNode])
+]));
+const CmsMarkdownDocument = Schema.Struct({
+	nodes: Schema.Array(MarkdownNode),
+	frontmatter: Schema.JsonObject,
+	meta: Schema.JsonObject
+}).annotate({ identifier: "CmsMarkdownDocument" });
+const CmsDocumentHeading = Schema.Struct({
+	depth: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 6
+	})),
+	id: Schema.String,
+	text: Schema.String
+});
+const CmsDocumentAnalysis = Schema.Struct({
+	components: Schema.Array(Schema.NonEmptyString),
+	headings: Schema.Array(CmsDocumentHeading),
+	searchText: Schema.String,
+	summary: Schema.String
+});
+const CompiledDocumentSource = Schema.Struct({
+	path: SourcePath,
+	mappings: Schema.Array(DocumentSourceMapping),
+	publishedAt: Schema.optionalKey(Schema.DateTimeUtcFromString)
+});
+const CompiledDocument = Schema.Struct({
+	id: DocumentId,
+	key: PublicPath,
+	path: PublicPath,
+	locale: Schema.optionalKey(Locale),
+	collection: CollectionName,
+	draft: Schema.Boolean,
+	title: Schema.NonEmptyString,
+	description: Schema.optionalKey(Schema.String),
+	seo: Schema.optionalKey(DocumentSeo),
+	resolvedSeo: Schema.optionalKey(ResolvedSeo),
+	data: Schema.JsonObject,
+	issues: Schema.Array(DocumentIssue),
+	analysis: CmsDocumentAnalysis,
+	body: CmsMarkdownDocument,
+	engineFingerprint: Schema.NonEmptyString,
+	source: CompiledDocumentSource
+}).annotate({ identifier: "CompiledDocument" });
+const documentAttribution = {
+	createdBy: Schema.optionalKey(StudioActor),
+	editedBy: Schema.optionalKey(StudioActor),
+	editedAt: Schema.optionalKey(Schema.DateTimeUtcFromString)
+};
+const DocumentSource = Schema.Struct({
+	...documentAttribution,
+	documentId: DocumentId,
+	sourcePath: SourcePath,
+	markdown: Schema.String,
+	revisionId: RevisionId,
+	version: DocumentVersion,
+	publishedVersion: Schema.optionalKey(DocumentVersion)
+}).annotate({ identifier: "DocumentSource" });
+const DocumentImportSource = Schema.Struct({
+	sourcePath: SourcePath,
+	markdown: Schema.String,
+	published: Schema.Boolean
+}).annotate({ identifier: "DocumentImportSource" });
+const DocumentImportMode = Schema.Literals(["preserve", "overwrite"]);
+const DocumentImportInput = Schema.Struct({
+	sources: Schema.Array(DocumentImportSource),
+	mode: DocumentImportMode,
+	reason: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(1e3)))
+}).annotate({ identifier: "DocumentImportInput" });
+const DocumentImportReport = Schema.Struct({
+	created: nonNegativeInt,
+	preserved: nonNegativeInt,
+	published: nonNegativeInt,
+	unchanged: nonNegativeInt,
+	updated: nonNegativeInt
+}).annotate({ identifier: "DocumentImportReport" });
+const DocumentSummary = Schema.Struct({
+	...documentAttribution,
+	publishedVersion: Schema.optionalKey(DocumentVersion),
+	publishedPath: Schema.optionalKey(PublicPath),
+	sourcePath: SourcePath,
+	version: DocumentVersion,
+	document: CompiledDocument
+}).annotate({ identifier: "DocumentSummary" });
+const DeletedDocument = Schema.Struct({
+	title: Schema.optionalKey(Schema.String),
+	path: Schema.optionalKey(PublicPath),
+	trashBatchId: Schema.optionalKey(DocumentVersion),
+	documentId: DocumentId,
+	deletedAt: Schema.DateTimeUtcFromString,
+	sourcePath: SourcePath,
+	version: DocumentVersion
+}).annotate({ identifier: "DeletedDocument" });
+const DocumentBrowseQuery = Schema.Struct({
+	collection: Schema.optionalKey(CollectionName),
+	locale: Schema.optionalKey(Locale)
+}).annotate({ identifier: "DocumentBrowseQuery" });
+const PublishedDocumentLookup = Schema.Union([
+	Schema.Struct({
+		kind: Schema.tag("id"),
+		documentId: DocumentId
+	}),
+	Schema.Struct({
+		kind: Schema.tag("path"),
+		path: PublicPath
+	}),
+	Schema.Struct({
+		kind: Schema.tag("key"),
+		key: PublicPath,
+		collection: Schema.optionalKey(CollectionName),
+		locale: Schema.optionalKey(Locale)
+	})
+]).pipe(Schema.toTaggedUnion("kind"));
+const DocumentQueryScalar = Schema.Union([
+	Schema.String,
+	Schema.Finite,
+	Schema.Boolean,
+	Schema.Null
+]);
+const validDocumentQueryField = Schema.makeFilter((field) => {
+	const segments = field.split(".");
+	return field.length <= 200 && segments.length <= 8 && segments.every((segment) => segment.length > 0);
+}, { expected: "a non-empty field path of at most 200 characters and eight non-empty segments" });
+const DocumentQueryField = Schema.NonEmptyString.check(validDocumentQueryField);
+const DocumentQueryValue = Schema.Union([DocumentQueryScalar, Schema.Array(DocumentQueryScalar).check(Schema.isMaxLength(20))]);
+const DocumentQuerySort = Schema.Struct({
+	field: DocumentQueryField,
+	direction: Schema.optionalKey(Schema.Literals(["asc", "desc"]))
+});
+const DocumentQueryWhere = Schema.Record(Schema.String, DocumentQueryValue).check(Schema.makeFilter((where) => Object.keys(where).every((field) => Schema.is(DocumentQueryField)(field)), { expected: "document query keys with valid bounded field paths" }), Schema.makeFilter((where) => Object.keys(where).length <= 12, { expected: "at most 12 document query filters" }));
+const PublishedDocumentSelection = Schema.Struct({
+	collection: Schema.optionalKey(CollectionName),
+	locale: Schema.optionalKey(Locale),
+	where: Schema.optionalKey(DocumentQueryWhere),
+	sort: Schema.optionalKey(Schema.Array(DocumentQuerySort).check(Schema.isMaxLength(4)))
+}).annotate({ identifier: "PublishedDocumentSelection" });
+const PublishedDocumentQuery = Schema.Struct({
+	...PublishedDocumentSelection.fields,
+	offset: Schema.optionalKey(nonNegativeInt),
+	limit: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 100
+	}))
+}).annotate({ identifier: "PublishedDocumentQuery" });
+const PublishedDocumentSurroundQuery = Schema.Struct({ ...PublishedDocumentSelection.fields }).annotate({ identifier: "PublishedDocumentSurroundQuery" });
+const PublishedDocumentPage = Schema.Struct({
+	items: Schema.Array(CompiledDocument),
+	total: nonNegativeInt
+}).annotate({ identifier: "PublishedDocumentPage" });
+const DocumentNavigationQuery = Schema.Struct({
+	collection: Schema.optionalKey(CollectionName),
+	locale: Schema.optionalKey(Locale)
+}).annotate({ identifier: "DocumentNavigationQuery" });
+const documentMutationMetadata = { reason: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(1e3))) };
+const DocumentNavigationItem = Schema.suspend(() => Schema.Struct({
+	key: PublicPath,
+	title: Schema.NonEmptyString,
+	path: Schema.optionalKey(PublicPath),
+	locale: Schema.optionalKey(Locale),
+	documentId: Schema.optionalKey(DocumentId),
+	children: Schema.Array(DocumentNavigationItem)
+}));
+const DocumentSurround = Schema.Struct({
+	previous: Schema.NullOr(CompiledDocument),
+	next: Schema.NullOr(CompiledDocument)
+}).annotate({ identifier: "DocumentSurround" });
+const HomeDocumentLocation = Schema.Struct({ kind: Schema.tag("home") });
+const NestedDocumentLocation = Schema.Struct({
+	kind: Schema.tag("entry"),
+	parent: Schema.optionalKey(RelativeDocumentPath),
+	slug: Slug
+});
+const DocumentLocation = Schema.Union([HomeDocumentLocation, NestedDocumentLocation]).pipe(Schema.toTaggedUnion("kind"));
+const CreateDocumentInput = Schema.Struct({
+	collection: CollectionName,
+	locale: Schema.optionalKey(Locale),
+	location: DocumentLocation,
+	title: Schema.NonEmptyString,
+	...documentMutationMetadata
+}).annotate({ identifier: "CreateDocumentInput" });
+const UpdateDocumentInput = Schema.Struct({
+	documentId: DocumentId,
+	expectedVersion: DocumentVersion,
+	markdown: Schema.String,
+	...documentMutationMetadata
+}).annotate({ identifier: "UpdateDocumentInput" });
+const MoveDocumentInput = Schema.Struct({
+	documentId: DocumentId,
+	expectedVersion: DocumentVersion,
+	location: DocumentLocation,
+	...documentMutationMetadata
+}).annotate({ identifier: "MoveDocumentInput" });
+const DuplicateDocumentInput = Schema.Struct({
+	...MoveDocumentInput.fields,
+	includeChildren: Schema.Boolean
+}).annotate({ identifier: "DuplicateDocumentInput" });
+const UnpublishDocumentInput = Schema.Struct({
+	documentId: DocumentId,
+	expectedVersion: DocumentVersion,
+	...documentMutationMetadata
+}).annotate({ identifier: "UnpublishDocumentInput" });
+const RemoveDocumentInput = Schema.Struct({
+	documentId: DocumentId,
+	expectedVersion: DocumentVersion,
+	...documentMutationMetadata
+}).annotate({ identifier: "RemoveDocumentInput" });
+const PublishDocumentInput = Schema.Struct({
+	documentId: DocumentId,
+	expectedVersion: DocumentVersion,
+	...documentMutationMetadata
+}).annotate({ identifier: "PublishDocumentInput" });
+const RestoreDocumentInput = Schema.Struct({
+	documentId: DocumentId,
+	revisionId: RevisionId,
+	expectedVersion: DocumentVersion,
+	...documentMutationMetadata
+}).annotate({ identifier: "RestoreDocumentInput" });
+const UndeleteDocumentInput = Schema.Struct({
+	documentId: DocumentId,
+	expectedVersion: DocumentVersion,
+	...documentMutationMetadata
+}).annotate({ identifier: "UndeleteDocumentInput" });
+const DOCUMENT_REVISION_ACTIONS = [
+	"document.create",
+	"document.move",
+	"document.remove",
+	"document.restore",
+	"document.undelete",
+	"document.update"
+];
+const DocumentRevisionAction = Schema.Literals(DOCUMENT_REVISION_ACTIONS);
+const DocumentMutationAction = Schema.Literals([
+	...DOCUMENT_REVISION_ACTIONS,
+	"document.publish",
+	"document.unpublish"
+]);
+const DocumentMutationResult = Schema.Struct({
+	action: DocumentMutationAction,
+	affectedDocumentIds: Schema.optionalKey(Schema.Array(DocumentId)),
+	documentId: DocumentId,
+	generation: DocumentGeneration,
+	revisionId: RevisionId,
+	sourcePath: SourcePath,
+	version: DocumentVersion,
+	entry: Schema.optionalKey(DocumentSummary)
+}).annotate({ identifier: "DocumentMutationResult" });
+const DocumentValidationResult = Schema.Struct({
+	valid: Schema.Boolean,
+	document: Schema.optionalKey(CompiledDocument),
+	issues: Schema.Array(DocumentIssue)
+}).annotate({ identifier: "DocumentValidationResult" });
+
+//#endregion
+export { DOCUMENT_ACTIONS as $, RemoveDocumentInput as A, SeoCapabilities as B, MarkdownNode as C, MediaTooLarge as Ct, PublishedDocumentPage as D, Locale as Dt, PublishedDocumentLookup as E, CollectionName as Et, DocumentSeo as F, SeoRevision as G, SeoConfirmationRequired as H, GlobalSeoSettings as I, SeoUrl as J, SeoSnapshot as K, PublishSeoInput as L, UndeleteDocumentInput as M, UnpublishDocumentInput as N, PublishedDocumentQuery as O, SourceDirectory as Ot, UpdateDocumentInput as P, AuthenticationRequired as Q, SaveSeoInput as R, DuplicateDocumentInput as S, MediaStatus as St, PublishDocumentInput as T, AddressPattern as Tt, SeoMediaUnavailable as U, SeoConfiguration as V, SeoMutationResult as W, SitemapEntry as X, SeoVersionConflict as Y, AccessDenied as Z, DocumentSource as _, MediaObjectKey as _t, DOCUMENT_REVISION_ACTIONS as a, ImageMimeType as at, DocumentSurround as b, MediaReference as bt, DocumentImportInput as c, MediaCleanupReport as ct, DocumentIssue as d, MediaFolder as dt, MEDIA_ACTIONS as et, DocumentMutationResult as f, MediaId as ft, DocumentRevisionAction as g, MediaNotFound as gt, DocumentQueryScalar as h, MediaName as ht, CreateDocumentInput as i, StudioRequestContext as it, RestoreDocumentInput as j, PublishedDocumentSurroundQuery as k, RequestId as kt, DocumentImportReport as l, MediaConflict as lt, DocumentNavigationQuery as m, MediaInvalid as mt, CmsMarkdownDocument as n, StudioActor as nt, DeletedDocument as o, MediaAsset as ot, DocumentNavigationItem as p, MediaIntegrityReport as pt, SeoState as q, CompiledDocument as r, StudioEntryDenied as rt, DocumentBrowseQuery as s, MediaByteSize as st, CmsDocumentAnalysis as t, Role as tt, DocumentImportSource as u, MediaCursor as ut, DocumentSourceMapping as v, MediaPage as vt, MoveDocumentInput as w, MediaUpload as wt, DocumentValidationResult as x, MediaReferenced as xt, DocumentSummary as y, MediaQuery as yt, SeoCanonicalOrigin as z };
+//# sourceMappingURL=models-DwYioyNV.js.map