emdash 0.12.0 → 0.13.0

package/dist/redirects-Dmj6KRU3.mjs

@@ -0,0 +1,1141 @@
+import { z } from "zod";
+
+//#region src/api/schemas/common.ts
+/** Valid role level values */
+const VALID_ROLE_LEVELS = new Set([
+	10,
+	20,
+	30,
+	40,
+	50
+]);
+/** Role level — coerces string/number to valid RoleLevel (10|20|30|40|50) */
+const roleLevel = z.coerce.number().int().refine((n) => VALID_ROLE_LEVELS.has(n), { message: "Invalid role level. Must be 10, 20, 30, 40, or 50" });
+/** Pagination query params — cursor-based */
+const cursorPaginationQuery = z.object({
+	cursor: z.string().max(2048).optional().meta({ description: "Opaque cursor for pagination" }),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50).meta({ description: "Maximum number of items to return (1-100, default 50)" })
+}).meta({ id: "CursorPaginationQuery" });
+/** Pagination query params — offset-based */
+const offsetPaginationQuery = z.object({
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+	offset: z.coerce.number().int().min(0).optional().default(0)
+}).meta({ id: "OffsetPaginationQuery" });
+/** Slug pattern: lowercase letters, digits, underscores; starts with letter */
+const slugPattern = /^[a-z][a-z0-9_]*$/;
+/** Matches http(s) scheme at start of URL */
+const HTTP_SCHEME_RE = /^https?:\/\//i;
+/** Validates that a URL string uses http or https scheme. Rejects javascript:/data: URI XSS vectors. */
+const httpUrl = z.string().url().refine((url) => HTTP_SCHEME_RE.test(url), "URL must use http or https");
+/** BCP 47 locale code — language with optional script/region subtags (e.g. en, en-US, pt-BR, es-419, zh-Hant) */
+const localeCode = z.string().regex(/^[a-z]{2,3}(-[a-z0-9]{2,8})*$/i, "Invalid locale code").transform((v) => v.toLowerCase());
+/** Shared `?locale=xx` query shape for endpoints that filter by locale. */
+const localeFilterQuery = z.object({ locale: z.string().min(1).optional() }).meta({ id: "LocaleFilterQuery" });
+/** Standard API error response */
+const apiErrorSchema = z.object({ error: z.object({
+	code: z.string().meta({
+		description: "Machine-readable error code",
+		example: "NOT_FOUND"
+	}),
+	message: z.string().meta({ description: "Human-readable error message" })
+}) }).meta({ id: "ApiError" });
+/** Wrap a data schema in the standard success envelope: { data: T } */
+function successEnvelope(dataSchema) {
+	return z.object({ data: dataSchema });
+}
+/** Standard delete response */
+const deleteResponseSchema = z.object({ deleted: z.literal(true) }).meta({ id: "DeleteResponse" });
+/** Standard count response */
+const countResponseSchema = z.object({ count: z.number().int().min(0) }).meta({ id: "CountResponse" });
+
+//#endregion
+//#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(),
+	websiteUrl: z.string().nullable(),
+	userId: z.string().nullable(),
+	isGuest: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+}).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()
+}).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()
+}).meta({ id: "BylineCreateBody" });
+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()
+}).meta({ id: "BylineUpdateBody" });
+const bylineListResponseSchema = z.object({
+	items: z.array(bylineSummarySchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "BylineListResponse" });
+
+//#endregion
+//#region src/api/schemas/content.ts
+/** 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" });
+const contentListQuery = cursorPaginationQuery.extend({
+	status: z.string().optional(),
+	orderBy: z.string().optional(),
+	order: z.enum(["asc", "desc"]).optional(),
+	locale: localeCode.optional()
+}).meta({ id: "ContentListQuery" });
+/** ISO 8601 datetime for `publishedAt` / `createdAt`. Routes gate writes behind `content:publish_any`. */
+const contentDateOverride = z.iso.datetime({
+	offset: true,
+	message: "must be an ISO 8601 datetime"
+}).nullish();
+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(),
+	publishedAt: contentDateOverride,
+	createdAt: contentDateOverride
+}).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(),
+	seo: contentSeoInput.optional(),
+	publishedAt: contentDateOverride
+}).meta({ id: "ContentUpdateBody" });
+const contentScheduleBody = z.object({ scheduledAt: z.string().min(1, "scheduledAt is required").meta({
+	description: "ISO 8601 datetime for scheduled publishing",
+	example: "2025-06-15T09:00:00Z"
+}) }).meta({ id: "ContentScheduleBody" });
+const contentPublishBody = z.object({ publishedAt: z.iso.datetime({
+	offset: true,
+	message: "must be an ISO 8601 datetime"
+}).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" });
+const contentTrashQuery = cursorPaginationQuery;
+/** 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()
+}).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 content list endpoints */
+const contentListResponseSchema = z.object({
+	items: z.array(contentItemSchema),
+	nextCursor: z.string().optional(),
+	total: z.number().int().nonnegative().optional()
+}).meta({ id: "ContentListResponse" });
+/** Trashed content item */
+const trashedContentItemSchema = z.object({
+	id: z.string(),
+	type: z.string(),
+	slug: z.string().nullable(),
+	status: z.string(),
+	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/media.ts
+/**
+* Accepts a comma-separated string (from URL query params) or an array of
+* strings (from JSON body or programmatic use) and normalises to string[].
+*/
+const mimeTypeFilter = z.union([z.string(), z.array(z.string())]).transform((v) => {
+	return (Array.isArray(v) ? v : v.split(",")).map((s) => s.trim()).filter((s) => s.length > 0);
+}).optional();
+const mediaListQuery = cursorPaginationQuery.extend({ mimeType: mimeTypeFilter }).meta({ id: "MediaListQuery" });
+const mediaUpdateBody = z.object({
+	alt: z.string().optional(),
+	caption: z.string().optional(),
+	width: z.number().int().positive().optional(),
+	height: z.number().int().positive().optional()
+}).meta({ id: "MediaUpdateBody" });
+/** Default maximum allowed file upload size (50 MB). */
+const DEFAULT_MAX_UPLOAD_SIZE = 50 * 1024 * 1024;
+function formatFileSize(bytes) {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${Math.floor(bytes / 1024)}KB`;
+	return `${Math.floor(bytes / 1024 / 1024)}MB`;
+}
+const CONTENT_TYPE_RE = /^[a-z0-9][a-z0-9!#$&^_+\-.]*\/[a-z0-9!#$&^_+\-.]+(\s*;[^\r\n]*)?$/i;
+function mediaUploadUrlBody(maxSize) {
+	if (!Number.isFinite(maxSize) || maxSize <= 0) throw new Error(`EmDash: maxUploadSize must be a positive finite number, got ${maxSize}`);
+	return z.object({
+		filename: z.string().min(1, "filename is required"),
+		contentType: z.string().min(1, "contentType is required").regex(CONTENT_TYPE_RE, "Invalid content type"),
+		size: z.number().int().positive().max(maxSize, `File size must not exceed ${formatFileSize(maxSize)}`),
+		contentHash: z.string().optional(),
+		fieldId: z.string().optional()
+	}).meta({ id: "MediaUploadUrlBody" });
+}
+const mediaConfirmBody = z.object({
+	size: z.number().int().positive().optional(),
+	width: z.number().int().positive().optional(),
+	height: z.number().int().positive().optional()
+}).meta({ id: "MediaConfirmBody" });
+const mediaProviderListQuery = cursorPaginationQuery.extend({
+	query: z.string().optional(),
+	mimeType: mimeTypeFilter
+}).meta({ id: "MediaProviderListQuery" });
+const mediaStatusSchema = z.enum([
+	"pending",
+	"ready",
+	"failed"
+]);
+const mediaItemSchema = z.object({
+	id: z.string(),
+	filename: z.string(),
+	mimeType: z.string(),
+	size: z.number().nullable(),
+	width: z.number().nullable(),
+	height: z.number().nullable(),
+	alt: z.string().nullable(),
+	caption: z.string().nullable(),
+	storageKey: z.string(),
+	status: mediaStatusSchema,
+	contentHash: z.string().nullable(),
+	blurhash: z.string().nullable(),
+	dominantColor: z.string().nullable(),
+	createdAt: z.string(),
+	authorId: z.string().nullable()
+}).meta({ id: "MediaItem" });
+const mediaResponseSchema = z.object({ item: mediaItemSchema }).meta({ id: "MediaResponse" });
+const mediaListResponseSchema = z.object({
+	items: z.array(mediaItemSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "MediaListResponse" });
+const mediaUploadUrlResponseSchema = z.object({
+	uploadUrl: z.string(),
+	method: z.literal("PUT"),
+	headers: z.record(z.string(), z.string()),
+	mediaId: z.string(),
+	storageKey: z.string(),
+	expiresAt: z.string()
+}).meta({ id: "MediaUploadUrlResponse" });
+const mediaExistingResponseSchema = z.object({
+	existing: z.literal(true),
+	mediaId: z.string(),
+	storageKey: z.string(),
+	url: z.string()
+}).meta({ id: "MediaExistingResponse" });
+const mediaConfirmResponseSchema = z.object({ item: mediaItemSchema.extend({ url: z.string() }) }).meta({ id: "MediaConfirmResponse" });
+
+//#endregion
+//#region src/api/schemas/schema.ts
+const collectionSupportValues = z.enum([
+	"drafts",
+	"revisions",
+	"preview",
+	"scheduling",
+	"search"
+]);
+const collectionSourcePattern = /^(template:.+|import:.+|manual|discovered|seed)$/;
+const fieldTypeValues = z.enum([
+	"string",
+	"text",
+	"url",
+	"number",
+	"integer",
+	"boolean",
+	"datetime",
+	"select",
+	"multiSelect",
+	"portableText",
+	"image",
+	"file",
+	"reference",
+	"json",
+	"slug",
+	"repeater"
+]);
+const repeaterSubFieldSchema = z.object({
+	slug: z.string().min(1).max(63).regex(slugPattern, "Invalid slug format"),
+	type: z.enum([
+		"string",
+		"text",
+		"number",
+		"integer",
+		"boolean",
+		"datetime",
+		"select"
+	]),
+	label: z.string().min(1),
+	required: z.boolean().optional(),
+	options: z.array(z.string()).optional()
+});
+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()
+}).optional();
+const fieldWidgetOptions = z.record(z.string(), z.unknown()).optional();
+const createCollectionBody = z.object({
+	slug: z.string().min(1).max(63).regex(slugPattern, "Invalid slug format"),
+	label: z.string().min(1),
+	labelSingular: z.string().optional(),
+	description: z.string().optional(),
+	icon: z.string().optional(),
+	supports: z.array(collectionSupportValues).optional(),
+	source: z.string().regex(collectionSourcePattern).optional(),
+	urlPattern: z.string().optional(),
+	hasSeo: z.boolean().optional()
+}).meta({ id: "CreateCollectionBody" });
+const updateCollectionBody = z.object({
+	label: z.string().min(1).optional(),
+	labelSingular: z.string().optional(),
+	description: z.string().optional(),
+	icon: z.string().optional(),
+	supports: z.array(collectionSupportValues).optional(),
+	urlPattern: z.string().nullish(),
+	hasSeo: z.boolean().optional(),
+	commentsEnabled: z.boolean().optional(),
+	commentsModeration: z.enum([
+		"all",
+		"first_time",
+		"none"
+	]).optional(),
+	commentsClosedAfterDays: z.number().int().min(0).optional(),
+	commentsAutoApproveUsers: z.boolean().optional()
+}).meta({ id: "UpdateCollectionBody" });
+const createFieldBody = z.object({
+	slug: z.string().min(1).max(63).regex(slugPattern, "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(),
+	translatable: z.boolean().optional()
+}).meta({ id: "CreateFieldBody" });
+const updateFieldBody = z.object({
+	label: z.string().min(1).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(),
+	translatable: z.boolean().optional()
+}).meta({ id: "UpdateFieldBody" });
+const fieldReorderBody = z.object({ fieldSlugs: z.array(z.string().min(1)) }).meta({ id: "FieldReorderBody" });
+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 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(),
+	supports: z.array(z.string()),
+	source: z.string().nullable(),
+	urlPattern: z.string().nullable(),
+	hasSeo: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+}).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(),
+	sortOrder: z.number().int(),
+	searchable: 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 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/comments.ts
+const createCommentBody = z.object({
+	authorName: z.string().min(1).max(100),
+	authorEmail: z.string().email(),
+	body: z.string().min(1).max(5e3),
+	parentId: z.string().optional(),
+	website_url: z.string().optional()
+}).meta({ id: "CreateCommentBody" });
+const commentStatusBody = z.object({ status: z.enum([
+	"approved",
+	"pending",
+	"spam",
+	"trash"
+]) }).meta({ id: "CommentStatusBody" });
+const commentBulkBody = z.object({
+	ids: z.array(z.string().min(1)).min(1).max(100),
+	action: z.enum([
+		"approve",
+		"spam",
+		"trash",
+		"delete"
+	])
+}).meta({ id: "CommentBulkBody" });
+const commentListQuery = z.object({
+	status: z.enum([
+		"pending",
+		"approved",
+		"spam",
+		"trash"
+	]).optional(),
+	collection: z.string().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: "CommentListQuery" });
+const commentStatusValues = z.enum([
+	"pending",
+	"approved",
+	"spam",
+	"trash"
+]);
+/**
+* Public-facing comment (no email/IP).
+*
+* `replies` is recursive in practice (each reply can have replies), but we
+* model it as a single level here to avoid circular type inference issues
+* with tsgo. OpenAPI consumers should treat replies as the same shape.
+*/
+const publicCommentSchema = z.object({
+	id: z.string(),
+	authorName: z.string(),
+	isRegisteredUser: z.boolean(),
+	body: z.string(),
+	parentId: z.string().nullable(),
+	createdAt: z.string(),
+	replies: z.array(z.any()).optional()
+}).meta({ id: "PublicComment" });
+/** Admin comment with full details */
+const commentSchema = z.object({
+	id: z.string(),
+	collection: z.string(),
+	contentId: z.string(),
+	authorName: z.string(),
+	authorEmail: z.string(),
+	body: z.string(),
+	status: commentStatusValues,
+	parentId: z.string().nullable(),
+	ipHash: z.string().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+}).meta({ id: "Comment" });
+const publicCommentListResponseSchema = z.object({
+	items: z.array(publicCommentSchema),
+	nextCursor: z.string().optional(),
+	total: z.number().int()
+}).meta({ id: "PublicCommentListResponse" });
+const adminCommentListResponseSchema = z.object({
+	items: z.array(commentSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "AdminCommentListResponse" });
+const commentCountsResponseSchema = z.object({
+	pending: z.number().int(),
+	approved: z.number().int(),
+	spam: z.number().int(),
+	trash: z.number().int()
+}).meta({ id: "CommentCountsResponse" });
+const commentBulkResponseSchema = z.object({ affected: z.number().int() }).meta({ id: "CommentBulkResponse" });
+
+//#endregion
+//#region src/utils/url.ts
+/**
+* URL scheme validation utilities
+*
+* Prevents XSS via dangerous URL schemes (javascript:, data:, vbscript:, etc.)
+* by allowlisting known-safe schemes before rendering into href attributes.
+*/
+/**
+* Matches URLs that are safe to render in href attributes.
+*
+* Allowed:
+* - http:// and https://
+* - mailto: and tel:
+* - Relative paths (starting with /)
+* - Fragment links (starting with #)
+* - Protocol-relative URLs are NOT allowed (starting with //) as they can
+*   redirect to attacker-controlled hosts.
+*/
+const SAFE_URL_SCHEME_RE = /^(https?:|mailto:|tel:|\/(?!\/)|#)/i;
+/**
+* Returns the URL unchanged if it uses a safe scheme, otherwise returns "#".
+*
+* Use this at the render layer as the primary defense against XSS via
+* dangerous URL schemes like `javascript:`, `data:`, or `vbscript:`.
+*
+* @example
+* ```ts
+* sanitizeHref("https://example.com")        // "https://example.com"
+* sanitizeHref("/about")                      // "/about"
+* sanitizeHref("#section")                    // "#section"
+* sanitizeHref("mailto:a@b.com")              // "mailto:a@b.com"
+* sanitizeHref("javascript:alert(1)")         // "#"
+* sanitizeHref("data:text/html,<script>")     // "#"
+* sanitizeHref("")                            // "#"
+* ```
+*/
+function sanitizeHref(url) {
+	if (!url) return "#";
+	return SAFE_URL_SCHEME_RE.test(url) ? url : "#";
+}
+/**
+* Returns true if the URL uses a safe scheme for rendering in href attributes.
+*/
+function isSafeHref(url) {
+	return SAFE_URL_SCHEME_RE.test(url);
+}
+
+//#endregion
+//#region src/api/schemas/menus.ts
+/**
+* Allowed menu item types. `custom` uses `customUrl`; the others resolve a URL
+* from `referenceCollection` + `referenceId` (a translation_group id).
+*/
+const menuItemTypeEnum = z.enum([
+	"custom",
+	"page",
+	"post",
+	"taxonomy",
+	"collection"
+]);
+const safeHref = z.string().trim().refine(isSafeHref, "URL must use http, https, mailto, tel, a relative path, or a fragment identifier");
+const createMenuBody = z.object({
+	name: z.string().min(1),
+	label: z.string().min(1),
+	locale: z.string().min(1).optional(),
+	translationOf: z.string().min(1).optional()
+}).strict().meta({ id: "CreateMenuBody" });
+const updateMenuBody = z.object({ label: z.string().min(1).optional() }).strict().meta({ id: "UpdateMenuBody" });
+const createMenuItemBody = z.object({
+	type: menuItemTypeEnum,
+	label: z.string().min(1),
+	referenceCollection: z.string().optional(),
+	referenceId: z.string().optional(),
+	customUrl: safeHref.optional(),
+	target: z.string().optional(),
+	titleAttr: z.string().optional(),
+	cssClasses: z.string().optional(),
+	parentId: z.string().optional(),
+	sortOrder: z.number().int().min(0).optional()
+}).strict().meta({ id: "CreateMenuItemBody" });
+const updateMenuItemBody = z.object({
+	label: z.string().min(1).optional(),
+	customUrl: safeHref.optional(),
+	target: z.string().optional(),
+	titleAttr: z.string().optional(),
+	cssClasses: z.string().optional(),
+	parentId: z.string().nullish(),
+	sortOrder: z.number().int().min(0).optional()
+}).strict().meta({ id: "UpdateMenuItemBody" });
+const reorderMenuItemsBody = z.object({ items: z.array(z.object({
+	id: z.string().min(1),
+	parentId: z.string().nullable(),
+	sortOrder: z.number().int().min(0)
+})) }).meta({ id: "ReorderMenuItemsBody" });
+const menuSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	label: z.string(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	locale: z.string(),
+	translationGroup: z.string().nullable()
+}).meta({ id: "Menu" });
+const menuItemSchema = z.object({
+	id: z.string(),
+	menuId: z.string(),
+	parentId: z.string().nullable(),
+	sortOrder: z.number().int(),
+	type: z.string(),
+	referenceCollection: z.string().nullable(),
+	referenceId: z.string().nullable(),
+	customUrl: z.string().nullable(),
+	label: z.string(),
+	titleAttr: z.string().nullable(),
+	target: z.string().nullable(),
+	cssClasses: z.string().nullable(),
+	createdAt: z.string(),
+	locale: z.string(),
+	translationGroup: z.string().nullable()
+}).meta({ id: "MenuItem" });
+const menuTranslationsSchema = z.object({
+	translationGroup: z.string().nullable(),
+	translations: z.array(z.object({
+		id: z.string(),
+		name: z.string(),
+		label: z.string(),
+		locale: z.string(),
+		updatedAt: z.string()
+	}))
+}).meta({ id: "MenuTranslations" });
+const menuListItemSchema = menuSchema.extend({ itemCount: z.number().int() }).meta({ id: "MenuListItem" });
+const menuWithItemsSchema = menuSchema.extend({ items: z.array(menuItemSchema) }).meta({ id: "MenuWithItems" });
+
+//#endregion
+//#region src/api/schemas/taxonomies.ts
+/** Collection slug format: lowercase alphanumeric + underscores, starts with letter */
+const collectionSlugPattern = /^[a-z][a-z0-9_]*$/;
+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().default(false),
+	collections: z.array(z.string().min(1).max(63).regex(collectionSlugPattern, "Invalid collection slug format")).max(100).optional().default([]),
+	locale: z.string().min(1).optional(),
+	translationOf: z.string().min(1).optional()
+}).meta({ id: "CreateTaxonomyDefBody" });
+const createTermBody = z.object({
+	slug: z.string().min(1),
+	label: z.string().min(1),
+	parentId: z.string().nullish(),
+	description: z.string().optional(),
+	locale: z.string().min(1).optional(),
+	translationOf: z.string().min(1).optional()
+}).meta({ id: "CreateTermBody" });
+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 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 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(),
+	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 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.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.optional(),
+	favicon: mediaReferenceInput.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()
+}).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()
+}).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.string().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/redirects.ts
+const redirectType = z.coerce.number().int().refine((n) => [
+	301,
+	302,
+	307,
+	308
+].includes(n), { message: "Redirect type must be 301, 302, 307, or 308" });
+/** Matches CR or LF characters */
+const CRLF = /[\r\n]/;
+/** Path must start with / and not be protocol-relative, contain no CRLF, and no path traversal */
+const urlPath = z.string().min(1).refine((s) => s.startsWith("/") && !s.startsWith("//"), { message: "Must be a path starting with / (no protocol-relative URLs)" }).refine((s) => !CRLF.test(s), { message: "URL must not contain newline characters" }).refine((s) => {
+	try {
+		return !decodeURIComponent(s).split("/").includes("..");
+	} catch {
+		return false;
+	}
+}, { message: "URL must not contain path traversal segments" });
+const createRedirectBody = z.object({
+	source: urlPath,
+	destination: urlPath,
+	type: redirectType.optional().default(301),
+	enabled: z.boolean().optional().default(true),
+	groupName: z.string().nullish()
+}).meta({ id: "CreateRedirectBody" });
+const updateRedirectBody = z.object({
+	source: urlPath.optional(),
+	destination: urlPath.optional(),
+	type: redirectType.optional(),
+	enabled: z.boolean().optional(),
+	groupName: z.string().nullish()
+}).refine((o) => Object.values(o).some((v) => v !== void 0), { message: "At least one field must be provided" }).meta({ id: "UpdateRedirectBody" });
+const redirectsListQuery = cursorPaginationQuery.extend({
+	search: z.string().optional(),
+	group: z.string().optional(),
+	enabled: z.enum(["true", "false"]).transform((v) => v === "true").optional(),
+	auto: z.enum(["true", "false"]).transform((v) => v === "true").optional()
+}).meta({ id: "RedirectsListQuery" });
+const notFoundListQuery = cursorPaginationQuery.extend({ search: z.string().optional() }).meta({ id: "NotFoundListQuery" });
+const notFoundSummaryQuery = z.object({ limit: z.coerce.number().int().min(1).max(100).optional().default(50) });
+const notFoundPruneBody = z.object({ olderThan: z.string().datetime({ message: "olderThan must be an ISO 8601 datetime" }) }).meta({ id: "NotFoundPruneBody" });
+const redirectSchema = z.object({
+	id: z.string(),
+	source: z.string(),
+	destination: z.string(),
+	type: z.number().int(),
+	isPattern: z.boolean(),
+	enabled: z.boolean(),
+	hits: z.number().int(),
+	lastHitAt: z.string().nullable(),
+	groupName: z.string().nullable(),
+	auto: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+}).meta({ id: "Redirect" });
+const redirectListResponseSchema = z.object({
+	items: z.array(redirectSchema),
+	nextCursor: z.string().optional(),
+	loopRedirectIds: z.array(z.string()).optional()
+}).meta({ id: "RedirectListResponse" });
+const notFoundEntrySchema = z.object({
+	id: z.string(),
+	path: z.string(),
+	referrer: z.string().nullable(),
+	userAgent: z.string().nullable(),
+	ip: z.string().nullable(),
+	createdAt: z.string()
+}).meta({ id: "NotFoundEntry" });
+const notFoundListResponseSchema = z.object({
+	items: z.array(notFoundEntrySchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "NotFoundListResponse" });
+const notFoundSummarySchema = z.object({
+	path: z.string(),
+	count: z.number().int(),
+	lastSeen: z.string(),
+	topReferrer: z.string().nullable()
+}).meta({ id: "NotFoundSummary" });
+const notFoundSummaryResponseSchema = z.object({ items: z.array(notFoundSummarySchema) }).meta({ id: "NotFoundSummaryResponse" });
+
+//#endregion
+export { createMenuBody as $, contentCreateBody as $t, searchRebuildBody as A, localeFilterQuery as An, fieldReorderBody as At, updateSectionBody as B, formatFileSize as Bt, userDetailSchema as C, VALID_ROLE_LEVELS as Cn, collectionListResponseSchema as Ct, usersListQuery as D, deleteResponseSchema as Dn, createCollectionBody as Dt, userUpdateBody as E, cursorPaginationQuery as En, collectionWithFieldsResponseSchema as Et, siteSettingsSchema as F, orphanedTableSchema as Ft, taxonomyListResponseSchema as G, mediaListQuery as Gt, createTermBody as H, mediaConfirmResponseSchema as Ht, createSectionBody as I, schemaExportQuery as It, termResponseSchema as J, mediaResponseSchema as Jt, termGetResponseSchema as K, mediaListResponseSchema as Kt, sectionListResponseSchema as L, updateCollectionBody as Lt, searchResultSchema as M, roleLevel as Mn, fieldSchema as Mt, searchSuggestQuery as N, slugPattern as Nn, orphanRegisterBody as Nt, searchEnableBody as O, httpUrl as On, createFieldBody as Ot, settingsUpdateBody as P, successEnvelope as Pn, orphanedTableListResponseSchema as Pt, updateTermBody as Q, contentCompareResponseSchema as Qt, sectionSchema as R, updateFieldBody as Rt, allowedDomainUpdateBody as S, contentBylineInputSchema as Sn, collectionGetQuery as St, userSchema as T, countResponseSchema as Tn, collectionSchema as Tt, taxonomyDefSchema as U, mediaExistingResponseSchema as Ut, createTaxonomyDefBody as V, mediaConfirmBody as Vt, taxonomyDefTranslationsSchema as W, mediaItemSchema as Wt, termTranslationsSchema as X, mediaUploadUrlBody as Xt, termSchema as Y, mediaUpdateBody as Yt, termWithCountSchema as Z, mediaUploadUrlResponseSchema as Zt, widgetAreaSchema as _, bylineCreditSchema as _n, commentSchema as _t, notFoundPruneBody as a, contentResponseSchema as an, menuTranslationsSchema as at, widgetSchema as b, bylineUpdateBody as bn, publicCommentListResponseSchema as bt, notFoundSummarySchema as c, contentSeoSchema as cn, updateMenuBody as ct, redirectsListQuery as d, contentTranslationsResponseSchema as dn, sanitizeHref as dt, contentItemSchema as en, createMenuItemBody as et, updateRedirectBody as f, contentTrashQuery as fn, adminCommentListResponseSchema as ft, updateWidgetBody as g, bylineCreateBody as gn, commentListQuery as gt, reorderWidgetsBody as h, trashedContentListResponseSchema as hn, commentCountsResponseSchema as ht, notFoundListResponseSchema as i, contentPublishBody as in, menuSchema as it, searchResponseSchema as j, offsetPaginationQuery as jn, fieldResponseSchema as jt, searchQuery as k, localeCode as kn, fieldListResponseSchema as kt, redirectListResponseSchema as l, contentTermsBody as ln, updateMenuItemBody as lt, createWidgetBody as m, trashedContentItemSchema as mn, commentBulkResponseSchema as mt, notFoundEntrySchema as n, contentListResponseSchema as nn, menuItemTypeEnum as nt, notFoundSummaryQuery as o, contentScheduleBody as on, menuWithItemsSchema as ot, createWidgetAreaBody as p, contentUpdateBody as pn, commentBulkBody as pt, termListResponseSchema as q, mediaProviderListQuery as qt, notFoundListQuery as r, contentPreviewUrlBody as rn, menuListItemSchema as rt, notFoundSummaryResponseSchema as s, contentSeoInput as sn, reorderMenuItemsBody as st, createRedirectBody as t, contentListQuery as tn, menuItemSchema as tt, redirectSchema as u, contentTranslationSchema as un, isSafeHref as ut, widgetAreaWithWidgetsAndCountSchema as v, bylineListResponseSchema as vn, commentStatusBody as vt, userListResponseSchema as w, apiErrorSchema as wn, collectionResponseSchema as wt, allowedDomainCreateBody as x, bylinesListQuery as xn, publicCommentSchema as xt, widgetAreaWithWidgetsSchema as y, bylineSummarySchema as yn, createCommentBody as yt, sectionsListQuery as z, DEFAULT_MAX_UPLOAD_SIZE as zt };
+//# sourceMappingURL=redirects-Dmj6KRU3.mjs.map