emdash 0.40.1 → 0.42.0

package/dist/entry-lock-PP1JCXBB.mjs

@@ -0,0 +1,1180 @@
+import { a as MAX_COLLECTION_GROUP_LENGTH, o as MAX_COLLECTION_ICON_LENGTH, s as MAX_COLLECTION_LIST_COLUMNS } from "./types-BGmQ0uXs.mjs";
+import { t as SQL_BATCH_SIZE } from "./chunks-DBmkKmBH.mjs";
+import { t as SEARCH_TOKENIZERS } from "./types-CVsmpTcU.mjs";
+import { t as compileUrlPattern } from "./url-pattern-DGAG6ZP2.mjs";
+import { C as roleLevel, g as cursorPaginationQuery, v as httpUrl, w as slugPattern$1, y as localeCode } from "./redirects-D4EWeXAo.mjs";
+import { z } from "zod";
+
+//#region src/api/schemas/bylines.ts
+/** Slug pattern: lowercase letters, digits, and hyphens; must start with a letter */
+const bylineSlugPattern = /^[a-z][a-z0-9-]*$/;
+const bylineSummarySchema = z.object({
+	id: z.string(),
+	slug: z.string(),
+	displayName: z.string(),
+	bio: z.string().nullable(),
+	avatarMediaId: z.string().nullable(),
+	avatarStorageKey: z.string().nullish(),
+	avatarAlt: z.string().nullish(),
+	avatarBlurhash: z.string().nullish(),
+	avatarDominantColor: z.string().nullish(),
+	websiteUrl: z.string().nullable(),
+	userId: z.string().nullable(),
+	isGuest: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	locale: z.string(),
+	translationGroup: z.string().nullable(),
+	customFields: z.record(z.string(), z.union([
+		z.string(),
+		z.boolean(),
+		z.null()
+	])).optional()
+}).meta({ id: "BylineSummary" });
+const bylineCreditSchema = z.object({
+	byline: bylineSummarySchema,
+	sortOrder: z.number().int(),
+	roleLabel: z.string().nullable(),
+	source: z.enum(["explicit", "inferred"]).optional().meta({ description: "Whether this credit was explicitly assigned or inferred from authorId" })
+}).meta({ id: "BylineCredit" });
+const contentBylineInputSchema = z.object({
+	bylineId: z.string().min(1),
+	roleLabel: z.string().nullish()
+}).meta({ id: "ContentBylineInput" });
+const bylinesListQuery = cursorPaginationQuery.extend({
+	search: z.string().optional(),
+	isGuest: z.coerce.boolean().optional(),
+	userId: z.string().optional(),
+	locale: localeCode.optional()
+}).meta({ id: "BylinesListQuery" });
+const bylineCreateBody = z.object({
+	slug: z.string().min(1).regex(bylineSlugPattern, "Slug must contain only lowercase letters, digits, and hyphens"),
+	displayName: z.string().min(1),
+	bio: z.string().nullish(),
+	avatarMediaId: z.string().nullish(),
+	websiteUrl: httpUrl.nullish(),
+	userId: z.string().nullish(),
+	isGuest: z.boolean().optional(),
+	locale: localeCode.optional(),
+	translationOf: z.string().min(1).optional(),
+	customFields: z.record(z.string(), z.unknown()).optional()
+}).meta({ id: "BylineCreateBody" });
+const bylineTranslationCreateBody = z.object({
+	locale: localeCode,
+	slug: z.string().min(1).regex(bylineSlugPattern, "Slug must contain only lowercase letters, digits, and hyphens").optional(),
+	displayName: z.string().min(1).optional(),
+	bio: z.string().nullish(),
+	avatarMediaId: z.string().nullish(),
+	websiteUrl: httpUrl.nullish()
+}).meta({ id: "BylineTranslationCreateBody" });
+const bylineTranslationsResponseSchema = z.object({ items: z.array(bylineSummarySchema) }).meta({ id: "BylineTranslationsResponse" });
+const bylineUpdateBody = z.object({
+	slug: z.string().min(1).regex(bylineSlugPattern, "Slug must contain only lowercase letters, digits, and hyphens").optional(),
+	displayName: z.string().min(1).optional(),
+	bio: z.string().nullish(),
+	avatarMediaId: z.string().nullish(),
+	websiteUrl: httpUrl.nullish(),
+	userId: z.string().nullish(),
+	isGuest: z.boolean().optional(),
+	customFields: z.record(z.string(), z.unknown()).optional()
+}).meta({ id: "BylineUpdateBody" });
+const bylineListResponseSchema = z.object({
+	items: z.array(bylineSummarySchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "BylineListResponse" });
+
+//#endregion
+//#region src/api/schemas/relations.ts
+const slugPattern = /^[a-z][a-z0-9_]*$/;
+const collectionSlug$1 = z.string().min(1).max(63).regex(slugPattern, "Invalid collection slug format");
+/** NULL means unlimited on that side. */
+const roleLimit = z.number().int().positive().nullable().optional();
+const roleLabelSingular = z.string().min(1).max(200).nullable().optional();
+const createRelationBody = z.object({
+	slug: z.string().min(1).max(63).regex(slugPattern, "Slug must be lowercase alphanumeric with underscores"),
+	parentCollection: collectionSlug$1,
+	childCollection: collectionSlug$1,
+	parentLabel: z.string().min(1).max(200),
+	parentLabelSingular: roleLabelSingular,
+	childLabel: z.string().min(1).max(200),
+	childLabelSingular: roleLabelSingular,
+	maxChildrenPerParent: roleLimit,
+	maxParentsPerChild: roleLimit
+}).meta({ id: "CreateRelationBody" });
+const relationListQuery = z.object({ collection: collectionSlug$1.optional().meta({ description: "Only relations with this collection on one end" }) }).meta({ id: "RelationListQuery" });
+const updateRelationBody = z.object({
+	parentLabel: z.string().min(1).max(200).optional(),
+	parentLabelSingular: roleLabelSingular,
+	childLabel: z.string().min(1).max(200).optional(),
+	childLabelSingular: roleLabelSingular,
+	maxChildrenPerParent: roleLimit,
+	maxParentsPerChild: roleLimit
+}).refine((body) => Object.values(body).some((value) => value !== void 0), { message: "At least one field is required" }).meta({ id: "UpdateRelationBody" });
+const relationDefSchema = z.object({
+	id: z.string(),
+	slug: z.string(),
+	parentCollection: z.string(),
+	childCollection: z.string(),
+	parentLabel: z.string(),
+	parentLabelSingular: z.string().nullable(),
+	childLabel: z.string(),
+	childLabelSingular: z.string().nullable(),
+	maxChildrenPerParent: z.number().int().nullable(),
+	maxParentsPerChild: z.number().int().nullable()
+}).meta({ id: "RelationDef" });
+/** A relation plus what deleting it would take: the fields that view it and
+* how many links it holds. */
+const relationWithUsageSchema = relationDefSchema.extend({
+	boundFields: z.array(z.object({
+		collectionSlug: z.string(),
+		fieldSlug: z.string(),
+		side: z.enum(["parent", "child"])
+	})),
+	linkCount: z.number().int()
+}).meta({ id: "RelationWithUsage" });
+const relationListResponseSchema = z.object({ relations: z.array(relationWithUsageSchema) }).meta({ id: "RelationListResponse" });
+const relationResponseSchema = z.object({ relation: relationWithUsageSchema }).meta({ id: "RelationResponse" });
+const entryRefSchema = z.object({
+	id: z.string(),
+	slug: z.string().nullable(),
+	collection: z.string(),
+	title: z.string().nullable(),
+	locale: z.string().nullable(),
+	translationGroup: z.string().nullable(),
+	sortOrder: z.number().int().optional()
+}).meta({ id: "ReferenceEntryRef" });
+const referenceChildrenResponseSchema = z.object({
+	children: z.array(entryRefSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "ReferenceChildrenResponse" });
+const referenceParentsResponseSchema = z.object({
+	parents: z.array(entryRefSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "ReferenceParentsResponse" });
+
+//#endregion
+//#region src/api/schemas/content.ts
+const contentDateTime = z.iso.datetime({
+	offset: true,
+	message: "must be an ISO 8601 datetime"
+}).or(z.iso.datetime({
+	offset: true,
+	precision: -1,
+	message: "must be an ISO 8601 datetime"
+}));
+/** SEO input — per-content meta fields */
+const contentSeoInput = z.object({
+	title: z.string().max(200).nullish(),
+	description: z.string().max(500).nullish(),
+	image: z.string().nullish(),
+	canonical: httpUrl.nullish(),
+	noIndex: z.boolean().optional()
+}).meta({ id: "ContentSeoInput" });
+/** ISO 8601 date or datetime bound for the content-list date range filter. */
+const contentDateBound = z.union([contentDateTime, z.iso.date({ message: "must be an ISO 8601 date" })]).optional();
+/**
+* Byline ids for the content-list filter: either the literal `none` or a
+* comma-separated list, parsed into an array.
+*
+* The 25-id cap keeps the `IN (...)` clause clear of D1's bound-parameter
+* ceiling once the rest of the list query's placeholders are counted
+* (`SQL_BATCH_SIZE` is 50 for a query binding nothing else).
+*/
+const bylineFilterParam = z.string().trim().min(1).max(2e3).optional().transform((value) => value === void 0 ? void 0 : value === "none" ? "none" : [...new Set(value.split(",").map((id) => id.trim()))].filter((id) => id.length > 0)).refine((value) => value === void 0 || value === "none" || value.length <= 25, { message: "at most 25 bylines may be selected" }).refine((value) => value === void 0 || value === "none" || value.length > 0, { message: "must contain at least one byline id" });
+/** Query-string boolean. Explicit values only — `z.coerce.boolean()` reads "false" as true. */
+const booleanParam = z.enum([
+	"1",
+	"0",
+	"true",
+	"false"
+]).optional().transform((value) => value === "1" || value === "true");
+const contentFieldComparable = z.union([z.string().max(2048), z.number()]);
+const contentFieldFilterScalar = z.union([
+	contentFieldComparable,
+	z.boolean(),
+	z.null()
+]);
+const contentFieldFilterValue = z.union([
+	contentFieldFilterScalar,
+	z.object({ in: z.array(z.union([contentFieldComparable, z.boolean()])).min(1).max(SQL_BATCH_SIZE) }).strict(),
+	z.object({
+		gt: contentFieldComparable.optional(),
+		gte: contentFieldComparable.optional(),
+		lt: contentFieldComparable.optional(),
+		lte: contentFieldComparable.optional()
+	}).strict().refine((value) => Object.values(value).some((bound) => bound !== void 0), { message: "Range filter must include at least one bound" })
+]);
+function contentFieldFilterOperandCount(value) {
+	if (value === null) return 0;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return 1;
+	if ("in" in value && Array.isArray(value.in)) return value.in.length;
+	return Object.values(value).filter((bound) => bound !== void 0).length;
+}
+/** AND-combined filters over custom fields explicitly marked as indexed. */
+const contentFieldFiltersSchema = z.record(z.string().max(128).regex(/^[a-z][a-z0-9_]*$/, "must be a safe field identifier"), contentFieldFilterValue).refine((filters) => Object.keys(filters).length <= 20, { message: "At most 20 indexed field filters are allowed" }).refine((filters) => Object.values(filters).reduce((total, value) => total + contentFieldFilterOperandCount(value), 0) <= SQL_BATCH_SIZE, { message: `Indexed field filters have a total operand budget of ${SQL_BATCH_SIZE}` });
+const contentFieldFiltersQuery = z.string().max(8192).transform((value, ctx) => {
+	try {
+		return JSON.parse(value);
+	} catch {
+		ctx.addIssue({
+			code: "custom",
+			message: "must be valid JSON"
+		});
+		return z.NEVER;
+	}
+}).pipe(contentFieldFiltersSchema);
+/** Statuses the content list can filter by. */
+const CONTENT_STATUSES = [
+	"draft",
+	"published",
+	"scheduled",
+	"archived",
+	"pending",
+	"private",
+	"future"
+];
+const contentListQuery = cursorPaginationQuery.extend({
+	status: z.enum([...CONTENT_STATUSES, "all"]).optional().transform((status) => status === "all" ? void 0 : status),
+	orderBy: z.string().optional(),
+	order: z.enum(["asc", "desc"]).optional(),
+	locale: localeCode.optional(),
+	q: z.string().trim().min(1).max(200).optional(),
+	authorId: z.string().min(1).max(64).optional(),
+	dateField: z.enum([
+		"createdAt",
+		"updatedAt",
+		"publishedAt"
+	]).optional(),
+	dateFrom: contentDateBound,
+	dateTo: contentDateBound,
+	bylines: bylineFilterParam,
+	includeInferredBylines: booleanParam,
+	fieldFilters: contentFieldFiltersQuery.optional()
+}).transform(({ bylines, ...rest }) => ({
+	...rest,
+	bylinesNone: bylines === "none",
+	bylines: bylines === "none" ? void 0 : bylines
+})).meta({ id: "ContentListQuery" });
+/** ISO 8601 datetime for `publishedAt` / `createdAt`. Routes gate writes behind `content:publish_any`. */
+const contentDateOverride = contentDateTime.nullish();
+const overrideLockFlag = z.boolean().optional().meta({ description: "Write even though another editor holds this entry's edit lock. Without it the write is refused with 409 ENTRY_LOCKED." });
+const contentCreateBody = z.object({
+	data: z.record(z.string(), z.unknown()),
+	slug: z.string().nullish(),
+	status: z.enum(["draft"]).optional(),
+	bylines: z.array(contentBylineInputSchema).optional(),
+	locale: localeCode.optional(),
+	translationOf: z.string().optional(),
+	seo: contentSeoInput.optional(),
+	taxonomies: z.record(z.string(), z.array(z.string())).optional().meta({ description: "Taxonomy term assignments as { taxonomyName: [termSlug, ...] }, resolved in the entry's locale." }),
+	references: z.record(z.string(), z.array(z.string()).max(1e3)).optional().meta({ description: "Reference selections as { fieldSlug: [entryId, ...] }, in display order. Written as content-reference links in the same transaction as the entry. A field bound to the child end of its relation selects the entries pointing at this one, which carry no order." }),
+	publishedAt: contentDateOverride,
+	createdAt: contentDateOverride,
+	migrateBlocks: z.boolean().optional(),
+	replaceBlocks: z.boolean().optional()
+}).meta({ id: "ContentCreateBody" });
+const contentUpdateBody = z.object({
+	data: z.record(z.string(), z.unknown()).optional(),
+	slug: z.string().nullish(),
+	status: z.enum(["draft"]).optional(),
+	authorId: z.string().nullish(),
+	bylines: z.array(contentBylineInputSchema).optional(),
+	_rev: z.string().optional().meta({ description: "Opaque revision token for optimistic concurrency" }),
+	skipRevision: z.boolean().optional(),
+	overrideLock: overrideLockFlag,
+	seo: contentSeoInput.optional(),
+	taxonomies: z.record(z.string(), z.array(z.string())).optional().meta({ description: "Replace taxonomy assignments as { taxonomyName: [termSlug, ...] }. Only named taxonomies are touched; pass an empty array to clear a taxonomy." }),
+	references: z.record(z.string(), z.array(z.string()).max(1e3)).optional().meta({ description: "Reference selections as { fieldSlug: [entryId, ...] }, in display order. Written as content-reference links in the same transaction as the entry. A field bound to the child end of its relation selects the entries pointing at this one, which carry no order." }),
+	publishedAt: contentDateOverride,
+	migrateBlocks: z.boolean().optional(),
+	replaceBlocks: z.boolean().optional()
+}).meta({ id: "ContentUpdateBody" });
+const contentScheduleBody = z.object({
+	scheduledAt: contentDateTime.meta({
+		description: "ISO 8601 datetime with Z or an explicit offset for scheduled publishing",
+		examples: ["2025-06-15T09:00:00Z"]
+	}),
+	overrideLock: overrideLockFlag,
+	_rev: z.string().optional().meta({ description: "Opaque revision token for optimistic concurrency" })
+}).meta({ id: "ContentScheduleBody" });
+const contentRevisionConditionBody = z.object({
+	_rev: z.string().optional().meta({ description: "Opaque revision token for optimistic concurrency" }),
+	overrideLock: overrideLockFlag
+}).meta({ id: "ContentRevisionConditionBody" });
+const revisionRestoreBody = z.object({ overrideLock: overrideLockFlag });
+const contentPublishBody = contentRevisionConditionBody.extend({ publishedAt: contentDateTime.optional().meta({ description: "Optional ISO 8601 datetime to backdate the publish (e.g. when migrating content). Requires content:publish_any permission. Without this, existing published_at is preserved on re-publish." }) }).meta({ id: "ContentPublishBody" });
+const contentPreviewUrlBody = z.object({
+	expiresIn: z.union([z.string(), z.number()]).optional(),
+	pathPattern: z.string().optional()
+}).meta({ id: "ContentPreviewUrlBody" });
+const contentTermsBody = z.object({ termIds: z.array(z.string()) }).meta({ id: "ContentTermsBody" });
+/** A single term variant returned as part of an entry's term assignments. */
+const contentEntryTermSchema = z.object({
+	id: z.string(),
+	name: z.string().meta({ description: "Taxonomy name" }),
+	slug: z.string(),
+	label: z.string(),
+	parentId: z.string().nullable(),
+	locale: localeCode,
+	translationGroup: z.string().nullable()
+}).meta({ id: "ContentEntryTerm" });
+/** Term assignments response for the content terms endpoint. */
+const contentTermsResponseSchema = z.object({
+	terms: z.array(contentEntryTermSchema),
+	unresolved: z.array(z.object({
+		translationGroup: z.string(),
+		availableLocales: z.array(localeCode),
+		translations: z.array(z.object({
+			id: z.string(),
+			slug: z.string(),
+			locale: localeCode
+		}))
+	})),
+	entryLocale: localeCode,
+	defaultLocale: localeCode,
+	implicitDefaultLocale: z.boolean()
+}).meta({ id: "ContentTermsResponse" });
+const contentTrashQuery = cursorPaginationQuery.extend({ locale: localeCode.optional().meta({ description: "Restrict the trash listing to entries in this locale" }) }).meta({ id: "ContentTrashQuery" });
+/** SEO metadata on a content item */
+const contentSeoSchema = z.object({
+	title: z.string().nullable(),
+	description: z.string().nullable(),
+	image: z.string().nullable(),
+	canonical: z.string().nullable(),
+	noIndex: z.boolean()
+}).meta({ id: "ContentSeo" });
+/** A single content item as returned by the API */
+const contentItemSchema = z.object({
+	id: z.string(),
+	type: z.string().meta({ description: "Collection slug this item belongs to" }),
+	slug: z.string().nullable(),
+	status: z.string().meta({ description: "draft, published, or scheduled" }),
+	data: z.record(z.string(), z.unknown()).meta({ description: "User-defined field values" }),
+	authorId: z.string().nullable(),
+	primaryBylineId: z.string().nullable(),
+	byline: bylineSummarySchema.nullable().optional(),
+	bylines: z.array(bylineCreditSchema).optional(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	publishedAt: z.string().nullable(),
+	scheduledAt: z.string().nullable(),
+	liveRevisionId: z.string().nullable(),
+	draftRevisionId: z.string().nullable(),
+	version: z.number().int(),
+	locale: z.string().nullable(),
+	translationGroup: z.string().nullable(),
+	seo: contentSeoSchema.optional(),
+	references: z.record(z.string(), referenceChildrenResponseSchema).optional()
+}).meta({ id: "ContentItem" });
+/** Response for single content item endpoints (get, create, update) */
+const contentResponseSchema = z.object({
+	item: contentItemSchema,
+	_rev: z.string().optional().meta({ description: "Opaque revision token for optimistic concurrency" })
+}).meta({ id: "ContentResponse" });
+/** Response for restoring an item from trash */
+const contentRestoreResponseSchema = z.object({
+	restored: z.literal(true),
+	item: contentItemSchema,
+	_rev: z.string().meta({ description: "Opaque revision token for optimistic concurrency" })
+}).meta({ id: "ContentRestoreResponse" });
+/** Response for content list endpoints */
+const contentListResponseSchema = z.object({
+	items: z.array(contentItemSchema),
+	nextCursor: z.string().optional(),
+	total: z.number().int().nonnegative().optional()
+}).meta({ id: "ContentListResponse" });
+/** A distinct content author for the admin author filter */
+const contentAuthorSchema = z.object({
+	id: z.string(),
+	name: z.string().nullable(),
+	email: z.string(),
+	avatarUrl: z.string().nullable()
+}).meta({ id: "ContentAuthor" });
+/** Response for the content authors endpoint */
+const contentAuthorsResponseSchema = z.object({ items: z.array(contentAuthorSchema) }).meta({ id: "ContentAuthorsResponse" });
+/** Trashed content item */
+const trashedContentItemSchema = z.object({
+	id: z.string(),
+	type: z.string(),
+	slug: z.string().nullable(),
+	status: z.string(),
+	locale: z.string().nullable(),
+	translationGroup: z.string().nullable(),
+	data: z.record(z.string(), z.unknown()),
+	authorId: z.string().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	publishedAt: z.string().nullable(),
+	deletedAt: z.string()
+}).meta({ id: "TrashedContentItem" });
+/** Response for trashed content list */
+const trashedContentListResponseSchema = z.object({
+	items: z.array(trashedContentItemSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "TrashedContentListResponse" });
+/** Response for content compare (live vs draft) */
+const contentCompareResponseSchema = z.object({
+	hasChanges: z.boolean(),
+	live: z.record(z.string(), z.unknown()).nullable(),
+	draft: z.record(z.string(), z.unknown()).nullable()
+}).meta({ id: "ContentCompareResponse" });
+/** Translation summary for a content item */
+const contentTranslationSchema = z.object({
+	id: z.string(),
+	locale: z.string().nullable(),
+	slug: z.string().nullable(),
+	status: z.string(),
+	updatedAt: z.string()
+});
+/** Response for content translations endpoint */
+const contentTranslationsResponseSchema = z.object({
+	translationGroup: z.string(),
+	translations: z.array(contentTranslationSchema)
+}).meta({ id: "ContentTranslationsResponse" });
+
+//#endregion
+//#region src/api/schemas/schema.ts
+const collectionSupportValues = z.enum([
+	"drafts",
+	"revisions",
+	"preview",
+	"scheduling",
+	"search",
+	"seo"
+]);
+const collectionSourcePattern = /^(template:.+|import:.+|manual|discovered|seed)$/;
+const collectionListColumns = z.array(z.string().min(1).max(63).regex(slugPattern$1, "Invalid field slug format"));
+const collectionAdminInputConfig = z.object({
+	listColumns: collectionListColumns.max(MAX_COLLECTION_LIST_COLUMNS, `At most ${MAX_COLLECTION_LIST_COLUMNS} list columns are allowed`).optional(),
+	quickCreate: z.boolean().optional()
+});
+const collectionAdminResponseConfig = z.object({
+	listColumns: collectionListColumns.optional(),
+	quickCreate: z.boolean().optional()
+});
+const fieldTypeValues = z.enum([
+	"string",
+	"text",
+	"url",
+	"number",
+	"integer",
+	"boolean",
+	"datetime",
+	"select",
+	"multiSelect",
+	"portableText",
+	"image",
+	"file",
+	"reference",
+	"json",
+	"slug",
+	"repeater",
+	"blocks"
+]);
+const repeaterSubFieldSchema = z.object({
+	slug: z.string().min(1).max(63).regex(slugPattern$1, "Invalid slug format"),
+	type: z.enum([
+		"string",
+		"text",
+		"url",
+		"number",
+		"integer",
+		"boolean",
+		"datetime",
+		"select",
+		"image"
+	]),
+	label: z.string().min(1),
+	required: z.boolean().optional(),
+	options: z.array(z.string()).optional()
+});
+const urlPatternValue = z.string().superRefine((pattern, ctx) => {
+	try {
+		compileUrlPattern(pattern);
+	} catch (error) {
+		ctx.addIssue({
+			code: "custom",
+			message: error instanceof Error ? error.message : "Invalid URL pattern"
+		});
+	}
+});
+const fieldValidation = z.object({
+	required: z.boolean().optional(),
+	min: z.number().optional(),
+	max: z.number().optional(),
+	minLength: z.number().int().min(0).optional(),
+	maxLength: z.number().int().min(0).optional(),
+	pattern: z.string().optional(),
+	options: z.array(z.string()).optional(),
+	subFields: z.array(repeaterSubFieldSchema).min(1).optional(),
+	minItems: z.number().int().min(0).optional(),
+	maxItems: z.number().int().min(1).optional(),
+	allowedMimeTypes: z.array(z.string().regex(/^[a-z0-9][a-z0-9!#$&^_+\-.]*\/[a-z0-9!#$&^_+\-.]*$/i, "Invalid MIME type")).min(1, "allowedMimeTypes must not be empty — omit the field to allow all types").max(64, "allowedMimeTypes may contain at most 64 entries").optional(),
+	targetCollection: z.string().min(1).optional(),
+	multiple: z.boolean().optional(),
+	relation: z.string().min(1).max(63).regex(slugPattern$1, "Invalid relation slug format").optional(),
+	relationSide: z.enum(["parent", "child"]).optional(),
+	allowedTypes: z.array(z.string().min(1).max(63).regex(slugPattern$1)).optional(),
+	retiredTypes: z.array(z.string().min(1).max(63).regex(slugPattern$1)).optional()
+}).superRefine((validation, ctx) => {
+	for (const [minimum, maximum] of [
+		["min", "max"],
+		["minLength", "maxLength"],
+		["minItems", "maxItems"]
+	]) {
+		const minimumValue = validation[minimum];
+		const maximumValue = validation[maximum];
+		if (minimumValue !== void 0 && maximumValue !== void 0 && minimumValue > maximumValue) ctx.addIssue({
+			code: "custom",
+			path: [maximum],
+			message: `${maximum} must be greater than or equal to ${minimum}`
+		});
+	}
+	if (validation.pattern !== void 0) try {
+		RegExp(validation.pattern);
+	} catch {
+		ctx.addIssue({
+			code: "custom",
+			path: ["pattern"],
+			message: "Invalid validation pattern"
+		});
+	}
+}).optional();
+const fieldWidgetOptions = z.record(z.string(), z.unknown()).optional();
+/** Admin sidebar folder label; an empty string clears it like `null`. */
+const navGroupValue = z.string().trim().max(MAX_COLLECTION_GROUP_LENGTH);
+const createCollectionBody = z.object({
+	slug: z.string().min(1).max(63).regex(slugPattern$1, "Invalid slug format"),
+	label: z.string().min(1),
+	labelSingular: z.string().optional(),
+	description: z.string().optional(),
+	icon: z.string().trim().max(MAX_COLLECTION_ICON_LENGTH).optional(),
+	admin: collectionAdminInputConfig.optional(),
+	supports: z.array(collectionSupportValues).optional(),
+	source: z.string().regex(collectionSourcePattern).optional(),
+	urlPattern: urlPatternValue.optional(),
+	routable: z.boolean().optional(),
+	hasSeo: z.boolean().optional(),
+	hidden: z.boolean().optional(),
+	sortOrder: z.number().int().nullish(),
+	editLocking: z.boolean().optional(),
+	group: navGroupValue.nullish()
+}).meta({ id: "CreateCollectionBody" });
+const updateCollectionBody = z.object({
+	label: z.string().min(1).optional(),
+	labelSingular: z.string().optional(),
+	description: z.string().optional(),
+	icon: z.string().trim().max(MAX_COLLECTION_ICON_LENGTH).optional(),
+	admin: collectionAdminInputConfig.optional(),
+	supports: z.array(collectionSupportValues).optional(),
+	urlPattern: z.string().nullish(),
+	routable: z.boolean().optional(),
+	hasSeo: z.boolean().optional(),
+	hidden: z.boolean().optional(),
+	sortOrder: z.number().int().nullish(),
+	group: navGroupValue.nullish(),
+	commentsEnabled: z.boolean().optional(),
+	commentsModeration: z.enum([
+		"all",
+		"first_time",
+		"none"
+	]).optional(),
+	commentsClosedAfterDays: z.number().int().min(0).optional(),
+	commentsAutoApproveUsers: z.boolean().optional(),
+	editLocking: z.boolean().optional(),
+	titleField: z.string().min(1).max(63).regex(slugPattern$1, "Invalid field slug format").nullish(),
+	dateField: z.string().min(1).max(63).regex(slugPattern$1, "Invalid field slug format").nullish()
+}).meta({ id: "UpdateCollectionBody" });
+const createFieldBody = z.object({
+	slug: z.string().min(1).max(63).regex(slugPattern$1, "Invalid slug format"),
+	label: z.string().min(1),
+	type: fieldTypeValues,
+	required: z.boolean().optional(),
+	unique: z.boolean().optional(),
+	defaultValue: z.unknown().optional(),
+	validation: fieldValidation.nullable(),
+	widget: z.string().optional(),
+	options: fieldWidgetOptions,
+	sortOrder: z.number().int().min(0).optional(),
+	searchable: z.boolean().optional(),
+	indexed: z.boolean().optional(),
+	translatable: z.boolean().optional()
+}).meta({ id: "CreateFieldBody" });
+const updateFieldBody = z.object({
+	label: z.string().min(1).optional(),
+	type: fieldTypeValues.optional(),
+	required: z.boolean().optional(),
+	unique: z.boolean().optional(),
+	defaultValue: z.unknown().optional(),
+	validation: fieldValidation.nullable(),
+	widget: z.string().optional(),
+	options: fieldWidgetOptions,
+	sortOrder: z.number().int().min(0).optional(),
+	searchable: z.boolean().optional(),
+	indexed: z.boolean().optional(),
+	translatable: z.boolean().optional()
+}).meta({ id: "UpdateFieldBody" });
+const fieldReorderBody = z.object({ fieldSlugs: z.array(z.string().min(1)) }).meta({ id: "FieldReorderBody" });
+const collectionReorderBody = z.object({ slugs: z.array(z.string().min(1)) }).meta({ id: "CollectionReorderBody" });
+const orphanRegisterBody = z.object({
+	label: z.string().optional(),
+	labelSingular: z.string().optional(),
+	description: z.string().optional()
+}).meta({ id: "OrphanRegisterBody" });
+const schemaExportQuery = z.object({ format: z.string().optional() });
+const blockFieldTypeValues = z.enum([
+	"string",
+	"text",
+	"url",
+	"number",
+	"integer",
+	"boolean",
+	"datetime",
+	"select",
+	"multiSelect",
+	"portableText",
+	"image",
+	"file",
+	"repeater"
+]);
+const blockFieldValidation = z.object({
+	min: z.number().optional(),
+	max: z.number().optional(),
+	minLength: z.number().int().min(0).optional(),
+	maxLength: z.number().int().min(0).optional(),
+	pattern: z.string().optional(),
+	options: z.array(z.string()).optional(),
+	subFields: z.array(repeaterSubFieldSchema).min(1).optional(),
+	minItems: z.number().int().min(0).optional(),
+	maxItems: z.number().int().min(1).optional(),
+	allowedMimeTypes: z.array(z.string()).min(1).max(64).optional()
+}).strict().optional();
+const blockFieldDefinitionSchema = z.object({
+	slug: z.string().min(1).max(63).regex(slugPattern$1, "Invalid field slug format"),
+	label: z.string().min(1).max(200),
+	type: blockFieldTypeValues,
+	required: z.boolean().optional(),
+	defaultValue: z.unknown().optional(),
+	validation: blockFieldValidation,
+	options: z.object({ darkVariant: z.boolean().optional() }).strict().optional()
+}).strict();
+const createBlockTypeBody = z.object({
+	slug: z.string().min(1).max(63).regex(slugPattern$1, "Invalid block type slug format"),
+	label: z.string().min(1).max(200),
+	description: z.string().optional(),
+	icon: z.string().optional(),
+	category: z.string().optional(),
+	fields: z.array(blockFieldDefinitionSchema)
+}).strict().meta({ id: "CreateBlockTypeBody" });
+const updateBlockTypeBody = z.object({
+	expectedFingerprint: z.string().min(1),
+	label: z.string().min(1).max(200).optional(),
+	description: z.string().nullish(),
+	icon: z.string().nullish(),
+	category: z.string().nullish(),
+	fields: z.array(blockFieldDefinitionSchema).optional(),
+	breaking: z.boolean().optional()
+}).strict().meta({ id: "UpdateBlockTypeBody" });
+const activateBlockTypeVersionBody = z.object({ expectedFingerprint: z.string().min(1) }).strict().meta({ id: "ActivateBlockTypeVersionBody" });
+const collectionGetQuery = z.object({ includeFields: z.string().transform((v) => v === "true").optional() });
+const collectionSchema = z.object({
+	id: z.string(),
+	slug: z.string(),
+	label: z.string(),
+	labelSingular: z.string().nullable(),
+	description: z.string().nullable(),
+	icon: z.string().nullable(),
+	admin: collectionAdminResponseConfig.optional(),
+	supports: z.array(z.string()),
+	source: z.string().nullable(),
+	urlPattern: z.string().nullable(),
+	routable: z.boolean(),
+	hasSeo: z.boolean(),
+	hidden: z.boolean(),
+	sortOrder: z.number().int().nullable(),
+	editLocking: z.boolean(),
+	group: z.string().nullish(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	titleField: z.string().nullish(),
+	dateField: z.string().nullish()
+}).meta({ id: "Collection" });
+const fieldSchema = z.object({
+	id: z.string(),
+	collectionId: z.string(),
+	slug: z.string(),
+	label: z.string(),
+	type: fieldTypeValues,
+	required: z.boolean(),
+	unique: z.boolean(),
+	defaultValue: z.unknown().nullable(),
+	validation: z.record(z.string(), z.unknown()).nullable(),
+	widget: z.string().nullable(),
+	options: z.record(z.string(), z.unknown()).nullable(),
+	blockTypes: z.array(z.lazy(() => blockTypeSchema)).optional(),
+	blockTypeFingerprint: z.string().optional(),
+	sortOrder: z.number().int(),
+	searchable: z.boolean(),
+	indexed: z.boolean(),
+	translatable: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+}).meta({ id: "Field" });
+const collectionResponseSchema = z.object({ item: collectionSchema }).meta({ id: "CollectionResponse" });
+const collectionWithFieldsResponseSchema = z.object({ item: collectionSchema.extend({ fields: z.array(fieldSchema) }) }).meta({ id: "CollectionWithFieldsResponse" });
+const collectionListResponseSchema = z.object({ items: z.array(collectionSchema) }).meta({ id: "CollectionListResponse" });
+const fieldResponseSchema = z.object({ item: fieldSchema }).meta({ id: "FieldResponse" });
+const fieldListResponseSchema = z.object({ items: z.array(fieldSchema) }).meta({ id: "FieldListResponse" });
+const blockTypeVersionSchema = z.object({
+	id: z.string(),
+	blockTypeId: z.string(),
+	version: z.number().int().positive(),
+	fields: z.array(blockFieldDefinitionSchema),
+	fingerprint: z.string(),
+	active: z.boolean(),
+	unsupportedTypes: z.array(z.object({
+		type: z.string(),
+		path: z.string()
+	}).strict()).optional(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+}).meta({ id: "BlockTypeVersion" });
+const blockTypeSchema = z.object({
+	id: z.string(),
+	slug: z.string(),
+	label: z.string(),
+	description: z.string().optional(),
+	icon: z.string().optional(),
+	category: z.string().optional(),
+	currentVersion: z.number().int().positive(),
+	source: z.enum(["user", "seed"]),
+	versions: z.array(blockTypeVersionSchema),
+	createdAt: z.string(),
+	updatedAt: z.string()
+}).meta({ id: "BlockType" });
+const blockTypeResponseSchema = z.object({ item: blockTypeSchema }).meta({ id: "BlockTypeResponse" });
+const blockTypeListResponseSchema = z.object({ items: z.array(blockTypeSchema) }).meta({ id: "BlockTypeListResponse" });
+const orphanedTableSchema = z.object({
+	slug: z.string(),
+	tableName: z.string(),
+	rowCount: z.number().int()
+}).meta({ id: "OrphanedTable" });
+const orphanedTableListResponseSchema = z.object({ items: z.array(orphanedTableSchema) }).meta({ id: "OrphanedTableListResponse" });
+
+//#endregion
+//#region src/api/schemas/taxonomies.ts
+const collectionSlug = z.string().min(1).max(63).regex(/^[a-z][a-z0-9_]*$/, "Invalid collection slug format");
+const createTaxonomyDefBody = z.object({
+	name: z.string().min(1).max(63).regex(/^[a-z][a-z0-9_]*$/, "Name must be lowercase alphanumeric with underscores"),
+	label: z.string().min(1).max(200),
+	labelSingular: z.string().min(1).max(200).optional(),
+	hierarchical: z.boolean().optional(),
+	collections: z.array(collectionSlug).max(100).optional(),
+	locale: localeCode.optional(),
+	translationOf: z.string().min(1).optional()
+}).meta({ id: "CreateTaxonomyDefBody" });
+/**
+* `name` and `locale` are absent on purpose: both identify the definition row
+* being written, and `.strict()` turns an attempt to change either into a 400
+* rather than a silently ignored field.
+*/
+const updateTaxonomyDefBody = z.object({
+	label: z.string().min(1).max(200).optional(),
+	labelSingular: z.string().min(1).max(200).nullish(),
+	hierarchical: z.boolean().optional(),
+	collections: z.array(collectionSlug).max(100).optional()
+}).strict().meta({ id: "UpdateTaxonomyDefBody" });
+const createTermBody = z.object({
+	slug: z.string().min(1).optional().meta({ description: "Term slug. Omit to derive a unique slug from the label." }),
+	label: z.string().min(1),
+	parentId: z.string().nullish(),
+	description: z.string().optional(),
+	locale: localeCode.optional(),
+	translationOf: z.string().min(1).optional()
+}).meta({ id: "CreateTermBody" });
+const bulkTagBody = z.object({
+	termId: z.string().min(1),
+	apply: z.boolean().default(false),
+	refreshOnly: z.boolean().optional(),
+	items: z.array(z.union([z.object({
+		collection: collectionSlug,
+		id: z.string().min(1)
+	}).strict(), z.object({ url: z.string().min(1).max(2048) }).strict()])).min(1).max(50)
+}).strict().meta({ id: "BulkTagBody" });
+const updateTermBody = z.object({
+	slug: z.string().min(1).optional(),
+	label: z.string().min(1).optional(),
+	parentId: z.string().nullish(),
+	description: z.string().optional()
+}).meta({ id: "UpdateTermBody" });
+const reorderTermsBody = z.object({
+	parentId: z.string().min(1).nullish().meta({ description: "Parent term whose children are being ordered (translation_group or row id). Omit or null for the top level, which for a flat taxonomy is every term." }),
+	ids: z.array(z.string().min(1)).max(100).meta({ description: "Terms to move, in the desired order — each a row id or translation_group. May be a subset of the group: the listed terms are permuted within the positions they already occupy and every other member keeps its place. An id outside the group is rejected with REORDER_MISMATCH." })
+}).strict().meta({ id: "ReorderTermsBody" });
+const termListQuery = z.object({
+	locale: localeCode.optional(),
+	includeCounts: z.enum(["true", "false"]).transform((v) => v === "true").optional().default(true).meta({ description: "Include each term's visible-usage count. Pass false to skip the aggregate; `count` is then absent from every term." }),
+	resolveFallback: z.enum(["true", "false"]).transform((value) => value === "true").optional().default(false).meta({ description: "Resolve one term per translation group, preferring the requested locale and then the configured default locale." })
+}).meta({ id: "TermListQuery" });
+const taxonomyDefSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	label: z.string(),
+	labelSingular: z.string().optional(),
+	hierarchical: z.boolean(),
+	collections: z.array(z.string()),
+	locale: z.string(),
+	translationGroup: z.string().nullable()
+}).meta({ id: "TaxonomyDef" });
+const taxonomyDefTranslationsSchema = z.object({
+	translationGroup: z.string().nullable(),
+	translations: z.array(z.object({
+		id: z.string(),
+		name: z.string(),
+		label: z.string(),
+		locale: z.string()
+	}))
+}).meta({ id: "TaxonomyDefTranslations" });
+const taxonomyListResponseSchema = z.object({ taxonomies: z.array(taxonomyDefSchema) }).meta({ id: "TaxonomyListResponse" });
+const taxonomyResponseSchema = z.object({ taxonomy: taxonomyDefSchema }).meta({ id: "TaxonomyResponse" });
+const termSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	slug: z.string(),
+	label: z.string(),
+	parentId: z.string().nullable(),
+	description: z.string().optional(),
+	locale: z.string(),
+	translationGroup: z.string().nullable()
+}).meta({ id: "Term" });
+const termTranslationsSchema = z.object({
+	translationGroup: z.string().nullable(),
+	translations: z.array(z.object({
+		id: z.string(),
+		slug: z.string(),
+		label: z.string(),
+		locale: z.string()
+	}))
+}).meta({ id: "TermTranslations" });
+const termWithCountSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	slug: z.string(),
+	label: z.string(),
+	parentId: z.string().nullable(),
+	description: z.string().optional(),
+	count: z.number().int().optional(),
+	children: z.array(z.lazy(() => termWithCountSchema)),
+	locale: z.string(),
+	translationGroup: z.string().nullable()
+}).meta({ id: "TermWithCount" });
+const termListResponseSchema = z.object({ terms: z.array(termWithCountSchema) }).meta({ id: "TermListResponse" });
+const termResponseSchema = z.object({ term: termSchema }).meta({ id: "TermResponse" });
+const termReorderResponseSchema = z.object({ reordered: z.literal(true) }).meta({ id: "TermReorderResponse" });
+const termGetResponseSchema = z.object({ term: termSchema.extend({
+	count: z.number().int(),
+	children: z.array(z.object({
+		id: z.string(),
+		slug: z.string(),
+		label: z.string()
+	}))
+}) }).meta({ id: "TermGetResponse" });
+
+//#endregion
+//#region src/api/schemas/sections.ts
+const sectionSource = z.enum([
+	"theme",
+	"user",
+	"import"
+]);
+const sectionsListQuery = z.object({
+	source: sectionSource.optional(),
+	search: z.string().optional(),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+	cursor: z.string().max(2048).optional()
+}).meta({ id: "SectionsListQuery" });
+const createSectionBody = z.object({
+	slug: z.string().min(1),
+	title: z.string().min(1),
+	description: z.string().optional(),
+	keywords: z.array(z.string()).optional(),
+	content: z.array(z.record(z.string(), z.unknown())),
+	previewMediaId: z.string().optional(),
+	source: z.enum(["user", "import"]).optional(),
+	themeId: z.string().optional()
+}).meta({ id: "CreateSectionBody" });
+const updateSectionBody = z.object({
+	slug: z.string().min(1).optional(),
+	title: z.string().min(1).optional(),
+	description: z.string().optional(),
+	keywords: z.array(z.string()).optional(),
+	content: z.array(z.record(z.string(), z.unknown())).optional(),
+	previewMediaId: z.string().nullish()
+}).meta({ id: "UpdateSectionBody" });
+const sectionSchema = z.object({
+	id: z.string(),
+	slug: z.string(),
+	title: z.string(),
+	description: z.string().nullable(),
+	keywords: z.array(z.string()).nullable(),
+	content: z.array(z.record(z.string(), z.unknown())),
+	previewMediaId: z.string().nullable(),
+	source: z.string(),
+	themeId: z.string().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+}).meta({ id: "Section" });
+const sectionListResponseSchema = z.object({
+	items: z.array(sectionSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "SectionListResponse" });
+
+//#endregion
+//#region src/api/schemas/settings.ts
+const mediaReferenceInput = z.object({
+	mediaId: z.string(),
+	alt: z.string().optional()
+});
+const socialSettings = z.object({
+	twitter: z.string().optional(),
+	github: z.string().optional(),
+	facebook: z.string().optional(),
+	instagram: z.string().optional(),
+	linkedin: z.string().optional(),
+	youtube: z.string().optional()
+});
+const seoSettingsInput = z.object({
+	titleSeparator: z.string().max(10).optional(),
+	defaultOgImage: mediaReferenceInput.nullable().optional(),
+	robotsTxt: z.string().max(5e3).optional(),
+	googleVerification: z.string().max(100).optional(),
+	bingVerification: z.string().max(100).optional()
+});
+const settingsUpdateBody = z.object({
+	title: z.string().optional(),
+	tagline: z.string().optional(),
+	logo: mediaReferenceInput.nullable().optional(),
+	favicon: mediaReferenceInput.nullable().optional(),
+	url: z.union([httpUrl, z.literal("")]).optional(),
+	postsPerPage: z.number().int().min(1).max(100).optional(),
+	dateFormat: z.string().optional(),
+	timezone: z.string().optional(),
+	social: socialSettings.optional(),
+	seo: seoSettingsInput.optional()
+}).meta({ id: "SettingsUpdateBody" });
+const mediaReferenceResponse = z.object({
+	mediaId: z.string(),
+	alt: z.string().optional(),
+	url: z.string().optional(),
+	contentType: z.string().optional(),
+	width: z.number().int().optional(),
+	height: z.number().int().optional()
+});
+const seoSettingsResponse = z.object({
+	titleSeparator: z.string().max(10).optional(),
+	defaultOgImage: mediaReferenceResponse.optional(),
+	robotsTxt: z.string().max(5e3).optional(),
+	googleVerification: z.string().max(100).optional(),
+	bingVerification: z.string().max(100).optional()
+});
+const siteSettingsSchema = z.object({
+	title: z.string().optional(),
+	tagline: z.string().optional(),
+	logo: mediaReferenceResponse.optional(),
+	favicon: mediaReferenceResponse.optional(),
+	url: z.string().optional(),
+	postsPerPage: z.number().int().optional(),
+	dateFormat: z.string().optional(),
+	timezone: z.string().optional(),
+	social: socialSettings.optional(),
+	seo: seoSettingsResponse.optional()
+}).meta({ id: "SiteSettings" });
+
+//#endregion
+//#region src/api/schemas/search.ts
+const searchQuery = z.object({
+	q: z.string().min(1),
+	collections: z.string().optional(),
+	status: z.string().optional(),
+	locale: localeCode.optional(),
+	limit: z.coerce.number().int().min(1).max(100).optional(),
+	cursor: z.string().optional(),
+	scope: z.enum(["all", "title"]).optional().meta({ description: "Which indexed fields to match against. 'title' matches only the collection's title field; collections without an indexed title field return no results. Defaults to 'all'." })
+}).meta({ id: "SearchQuery" });
+const searchSuggestQuery = z.object({
+	q: z.string().min(1),
+	collections: z.string().optional(),
+	locale: localeCode.optional(),
+	limit: z.coerce.number().int().min(1).max(20).optional()
+}).meta({ id: "SearchSuggestQuery" });
+const searchRebuildBody = z.object({ collection: z.string().min(1) }).meta({ id: "SearchRebuildBody" });
+const searchEnableBody = z.object({
+	collection: z.string().min(1),
+	enabled: z.boolean(),
+	weights: z.record(z.string(), z.number()).optional(),
+	tokenize: z.enum(SEARCH_TOKENIZERS).optional()
+}).meta({ id: "SearchEnableBody" });
+const searchResultSchema = z.object({
+	collection: z.string(),
+	id: z.string(),
+	slug: z.string().nullable(),
+	locale: z.string(),
+	title: z.string().optional(),
+	snippet: z.string().optional(),
+	score: z.number()
+}).meta({ id: "SearchResult" });
+const searchResponseSchema = z.object({
+	items: z.array(searchResultSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "SearchResponse" });
+
+//#endregion
+//#region src/api/schemas/users.ts
+const usersListQuery = z.object({
+	search: z.string().optional(),
+	role: z.string().optional(),
+	cursor: z.string().max(2048).optional(),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50)
+}).meta({ id: "UsersListQuery" });
+const userUpdateBody = z.object({
+	name: z.string().optional(),
+	email: z.email().optional(),
+	role: roleLevel.optional()
+}).meta({ id: "UserUpdateBody" });
+const allowedDomainCreateBody = z.object({
+	domain: z.string().min(1),
+	defaultRole: roleLevel
+}).meta({ id: "AllowedDomainCreateBody" });
+const allowedDomainUpdateBody = z.object({
+	enabled: z.boolean().optional(),
+	defaultRole: roleLevel.optional()
+}).meta({ id: "AllowedDomainUpdateBody" });
+const userSchema = z.object({
+	id: z.string(),
+	email: z.string(),
+	name: z.string().nullable(),
+	avatarUrl: z.string().nullable(),
+	role: z.number().int(),
+	emailVerified: z.boolean(),
+	disabled: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	lastLogin: z.string().nullable(),
+	credentialCount: z.number().int().optional(),
+	oauthProviders: z.array(z.string()).optional()
+}).meta({ id: "User" });
+const userListResponseSchema = z.object({
+	items: z.array(userSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "UserListResponse" });
+const userDetailSchema = z.object({
+	id: z.string(),
+	email: z.string(),
+	name: z.string().nullable(),
+	avatarUrl: z.string().nullable(),
+	role: z.number().int(),
+	emailVerified: z.boolean(),
+	disabled: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	lastLogin: z.string().nullable(),
+	credentials: z.array(z.object({
+		id: z.string(),
+		name: z.string().nullable(),
+		deviceType: z.string().nullable(),
+		createdAt: z.string(),
+		lastUsedAt: z.string()
+	})),
+	oauthAccounts: z.array(z.object({
+		provider: z.string(),
+		createdAt: z.string()
+	}))
+}).meta({ id: "UserDetail" });
+
+//#endregion
+//#region src/api/schemas/widgets.ts
+const widgetType = z.enum([
+	"content",
+	"menu",
+	"component"
+]);
+const createWidgetAreaBody = z.object({
+	name: z.string().min(1),
+	label: z.string().min(1),
+	description: z.string().optional()
+}).meta({ id: "CreateWidgetAreaBody" });
+const createWidgetBody = z.object({
+	type: widgetType,
+	title: z.string().optional(),
+	content: z.array(z.record(z.string(), z.unknown())).optional(),
+	menuName: z.string().optional(),
+	componentId: z.string().optional(),
+	componentProps: z.record(z.string(), z.unknown()).optional()
+}).meta({ id: "CreateWidgetBody" });
+const updateWidgetBody = z.object({
+	type: widgetType.optional(),
+	title: z.string().optional(),
+	content: z.array(z.record(z.string(), z.unknown())).optional(),
+	menuName: z.string().optional(),
+	componentId: z.string().optional(),
+	componentProps: z.record(z.string(), z.unknown()).optional()
+}).meta({ id: "UpdateWidgetBody" });
+const reorderWidgetsBody = z.object({ widgetIds: z.array(z.string().min(1)) }).meta({ id: "ReorderWidgetsBody" });
+const widgetAreaSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	label: z.string(),
+	description: z.string().nullable(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).meta({ id: "WidgetArea" });
+const widgetSchema = z.object({
+	id: z.string(),
+	type: widgetType,
+	title: z.string().optional(),
+	content: z.array(z.record(z.string(), z.unknown())).optional(),
+	menuName: z.string().optional(),
+	componentId: z.string().optional(),
+	componentProps: z.record(z.string(), z.unknown()).optional()
+}).meta({ id: "Widget" });
+const widgetAreaWithWidgetsSchema = widgetAreaSchema.extend({ widgets: z.array(widgetSchema) }).meta({ id: "WidgetAreaWithWidgets" });
+const widgetAreaWithWidgetsAndCountSchema = widgetAreaWithWidgetsSchema.extend({ widgetCount: z.number().int() }).meta({ id: "WidgetAreaWithWidgetsAndCount" });
+
+//#endregion
+//#region src/api/schemas/entry-lock.ts
+const entryLockAcquireBody = z.object({
+	takeover: z.boolean().optional().meta({ description: "Take the lock from whoever holds it. Their next heartbeat or save reports the new holder." }),
+	token: z.string().min(1).max(128).optional().meta({ description: "Identifies the caller's editing session. Send the same value on DELETE so a release from one tab does not drop a lock another tab of the same account still relies on." })
+}).meta({ id: "EntryLockAcquireBody" });
+const entryLockHolderSchema = z.object({
+	userId: z.string(),
+	userName: z.string().nullable(),
+	acquiredAt: z.string(),
+	expiresAt: z.string()
+}).meta({ id: "EntryLockHolder" });
+const entryLockStatusSchema = z.object({
+	enabled: z.boolean().meta({ description: "Whether the collection takes edit locks at all" }),
+	holder: entryLockHolderSchema.nullable(),
+	heldByCaller: z.boolean()
+}).meta({ id: "EntryLockStatus" });
+const entryLockReleaseResponseSchema = z.object({ released: z.boolean() }).meta({ id: "EntryLockReleaseResponse" });
+const entryLockConflictSchema = z.object({
+	success: z.literal(false),
+	error: z.object({
+		code: z.literal("ENTRY_LOCKED"),
+		message: z.string(),
+		details: entryLockHolderSchema
+	})
+});
+const entryMutationConflictSchema = z.object({
+	success: z.literal(false),
+	error: z.object({
+		code: z.string().meta({ examples: ["CONFLICT", "ENTRY_LOCKED"] }),
+		message: z.string(),
+		details: entryLockHolderSchema.optional()
+	})
+});
+
+//#endregion
+export { activateBlockTypeVersionBody as $, referenceParentsResponseSchema as $t, createSectionBody as A, contentItemSchema as At, taxonomyDefTranslationsSchema as B, contentSeoSchema as Bt, searchQuery as C, updateCollectionBody as Ct, searchSuggestQuery as D, contentCompareResponseSchema as Dt, searchResultSchema as E, contentAuthorsResponseSchema as Et, bulkTagBody as F, contentResponseSchema as Ft, termListResponseSchema as G, contentTrashQuery as Gt, taxonomyResponseSchema as H, contentTermsResponseSchema as Ht, createTaxonomyDefBody as I, contentRestoreResponseSchema as It, termSchema as J, trashedContentItemSchema as Jt, termReorderResponseSchema as K, contentUpdateBody as Kt, createTermBody as L, contentRevisionConditionBody as Lt, sectionSchema as M, contentListResponseSchema as Mt, sectionsListQuery as N, contentPreviewUrlBody as Nt, settingsUpdateBody as O, contentCreateBody as Ot, updateSectionBody as P, contentPublishBody as Pt, updateTermBody as Q, referenceChildrenResponseSchema as Qt, reorderTermsBody as R, contentScheduleBody as Rt, searchEnableBody as S, updateBlockTypeBody as St, searchResponseSchema as T, contentAuthorSchema as Tt, termGetResponseSchema as U, contentTranslationSchema as Ut, taxonomyListResponseSchema as V, contentTermsBody as Vt, termListQuery as W, contentTranslationsResponseSchema as Wt, termWithCountSchema as X, createRelationBody as Xt, termTranslationsSchema as Y, trashedContentListResponseSchema as Yt, updateTaxonomyDefBody as Z, entryRefSchema as Zt, userDetailSchema as _, fieldSchema as _t, entryLockStatusSchema as a, updateRelationBody as an, collectionGetQuery as at, userUpdateBody as b, orphanedTableSchema as bt, createWidgetBody as c, bylineListResponseSchema as cn, collectionResponseSchema as ct, widgetAreaSchema as d, bylineTranslationsResponseSchema as dn, createBlockTypeBody as dt, relationDefSchema as en, blockFieldDefinitionSchema as et, widgetAreaWithWidgetsAndCountSchema as f, bylineUpdateBody as fn, createCollectionBody as ft, allowedDomainUpdateBody as g, fieldResponseSchema as gt, allowedDomainCreateBody as h, fieldReorderBody as ht, entryLockReleaseResponseSchema as i, relationWithUsageSchema as in, blockTypeVersionSchema as it, sectionListResponseSchema as j, contentListQuery as jt, siteSettingsSchema as k, contentFieldFiltersSchema as kt, reorderWidgetsBody as l, bylineSummarySchema as ln, collectionSchema as lt, widgetSchema as m, contentBylineInputSchema as mn, fieldListResponseSchema as mt, entryLockConflictSchema as n, relationListResponseSchema as nn, blockTypeResponseSchema as nt, entryMutationConflictSchema as o, bylineCreateBody as on, collectionListResponseSchema as ot, widgetAreaWithWidgetsSchema as p, bylinesListQuery as pn, createFieldBody as pt, termResponseSchema as q, revisionRestoreBody as qt, entryLockHolderSchema as r, relationResponseSchema as rn, blockTypeSchema as rt, createWidgetAreaBody as s, bylineCreditSchema as sn, collectionReorderBody as st, entryLockAcquireBody as t, relationListQuery as tn, blockTypeListResponseSchema as tt, updateWidgetBody as u, bylineTranslationCreateBody as un, collectionWithFieldsResponseSchema as ut, userListResponseSchema as v, orphanRegisterBody as vt, searchRebuildBody as w, updateFieldBody as wt, usersListQuery as x, schemaExportQuery as xt, userSchema as y, orphanedTableListResponseSchema as yt, taxonomyDefSchema as z, contentSeoInput as zt };
+//# sourceMappingURL=entry-lock-PP1JCXBB.mjs.map