emdash 1.0.1 → 1.1.0

package/dist/entry-lock-sxz2PGAT.mjs

@@ -0,0 +1,1197 @@
+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-zlGB5IQP.mjs";
+import { t as SEARCH_TOKENIZERS } from "./types-Cj0_yZkn.mjs";
+import { t as compileUrlPattern } from "./url-pattern-hVbqpXs6.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" });
+const MAX_CALENDAR_RANGE_MS = 1488 * 60 * 60 * 1e3;
+/** Canonical UTC form, so bounds compare as text against stored timestamps. */
+const calendarBound = z.iso.datetime({
+	offset: true,
+	message: "must be an ISO 8601 datetime"
+}).transform((value) => new Date(value).toISOString());
+/** Calendar range: `from` inclusive, `to` exclusive, at most 62 days apart. */
+const calendarQuery = cursorPaginationQuery.extend({
+	from: calendarBound,
+	to: calendarBound
+}).refine((query) => query.from < query.to, {
+	message: "to must be after from",
+	path: ["to"]
+}).refine((query) => Date.parse(query.to) - Date.parse(query.from) <= MAX_CALENDAR_RANGE_MS, {
+	message: "the range can span at most 62 days",
+	path: ["to"]
+});
+/** 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 $, referenceChildrenResponseSchema as $t, createSectionBody as A, contentFieldFiltersSchema as At, taxonomyDefTranslationsSchema as B, contentSeoInput as Bt, searchQuery as C, updateCollectionBody as Ct, searchSuggestQuery as D, contentAuthorsResponseSchema as Dt, searchResultSchema as E, contentAuthorSchema as Et, bulkTagBody as F, contentPublishBody as Ft, termListResponseSchema as G, contentTranslationsResponseSchema as Gt, taxonomyResponseSchema as H, contentTermsBody as Ht, createTaxonomyDefBody as I, contentResponseSchema as It, termSchema as J, revisionRestoreBody as Jt, termReorderResponseSchema as K, contentTrashQuery as Kt, createTermBody as L, contentRestoreResponseSchema as Lt, sectionSchema as M, contentListQuery as Mt, sectionsListQuery as N, contentListResponseSchema as Nt, settingsUpdateBody as O, contentCompareResponseSchema as Ot, updateSectionBody as P, contentPreviewUrlBody as Pt, updateTermBody as Q, entryRefSchema as Qt, reorderTermsBody as R, contentRevisionConditionBody as Rt, searchEnableBody as S, updateBlockTypeBody as St, searchResponseSchema as T, calendarQuery as Tt, termGetResponseSchema as U, contentTermsResponseSchema as Ut, taxonomyListResponseSchema as V, contentSeoSchema as Vt, termListQuery as W, contentTranslationSchema as Wt, termWithCountSchema as X, trashedContentListResponseSchema as Xt, termTranslationsSchema as Y, trashedContentItemSchema as Yt, updateTaxonomyDefBody as Z, createRelationBody as Zt, userDetailSchema as _, fieldSchema as _t, entryLockStatusSchema as a, relationWithUsageSchema as an, collectionGetQuery as at, userUpdateBody as b, orphanedTableSchema as bt, createWidgetBody as c, bylineCreditSchema as cn, collectionResponseSchema as ct, widgetAreaSchema as d, bylineTranslationCreateBody as dn, createBlockTypeBody as dt, referenceParentsResponseSchema as en, blockFieldDefinitionSchema as et, widgetAreaWithWidgetsAndCountSchema as f, bylineTranslationsResponseSchema as fn, createCollectionBody as ft, allowedDomainUpdateBody as g, fieldResponseSchema as gt, allowedDomainCreateBody as h, contentBylineInputSchema as hn, fieldReorderBody as ht, entryLockReleaseResponseSchema as i, relationResponseSchema as in, blockTypeVersionSchema as it, sectionListResponseSchema as j, contentItemSchema as jt, siteSettingsSchema as k, contentCreateBody as kt, reorderWidgetsBody as l, bylineListResponseSchema as ln, collectionSchema as lt, widgetSchema as m, bylinesListQuery as mn, fieldListResponseSchema as mt, entryLockConflictSchema as n, relationListQuery as nn, blockTypeResponseSchema as nt, entryMutationConflictSchema as o, updateRelationBody as on, collectionListResponseSchema as ot, widgetAreaWithWidgetsSchema as p, bylineUpdateBody as pn, createFieldBody as pt, termResponseSchema as q, contentUpdateBody as qt, entryLockHolderSchema as r, relationListResponseSchema as rn, blockTypeSchema as rt, createWidgetAreaBody as s, bylineCreateBody as sn, collectionReorderBody as st, entryLockAcquireBody as t, relationDefSchema as tn, blockTypeListResponseSchema as tt, updateWidgetBody as u, bylineSummarySchema 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, contentScheduleBody as zt };
+//# sourceMappingURL=entry-lock-sxz2PGAT.mjs.map