import { n as isTerminalStatus, t as REDIRECT_RULE_STATUSES } from "./status-CqJQX1QN.mjs";
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(),
	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: z.string().min(1).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: z.string().min(1).optional(),
	translationOf: z.string().min(1).optional(),
	customFields: z.record(z.string(), z.unknown()).optional()
}).meta({ id: "BylineCreateBody" });
const bylineTranslationCreateBody = z.object({
	locale: z.string().min(1),
	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/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" });
/** ISO 8601 date or datetime bound for the content-list date range filter. */
const contentDateBound = z.union([z.iso.datetime({
	offset: true,
	message: "must be an ISO 8601 datetime"
}), z.iso.date({ message: "must be an ISO 8601 date" })]).optional();
const contentListQuery = cursorPaginationQuery.extend({
	status: z.string().optional(),
	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
}).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" });
/** 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(),
	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,
	q: z.string().trim().min(1).max(200).optional()
}).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",
		"url",
		"number",
		"integer",
		"boolean",
		"datetime",
		"select",
		"image"
	]),
	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(),
	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(),
	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 createReactionBody = z.object({
	commentId: z.string().min(1),
	reaction: z.string().min(1).max(20).default("like"),
	website_url: z.string().optional()
}).meta({ id: "CreateReactionBody" });
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) => REDIRECT_RULE_STATUSES.includes(n), { message: "Redirect type must be 301, 302, 307, 308, 410, or 451" });
/** 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: z.union([urlPath, z.literal("")]).optional(),
	type: redirectType.optional().default(301),
	enabled: z.boolean().optional().default(true),
	groupName: z.string().nullish()
}).refine((o) => isTerminalStatus(o.type ?? 301) || !!o.destination, {
	message: "destination is required for redirect types (301, 302, 307, 308)",
	path: ["destination"]
}).meta({ id: "CreateRedirectBody" });
const updateRedirectBody = z.object({
	source: urlPath.optional(),
	destination: z.union([urlPath, z.literal("")]).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 $, contentAuthorSchema as $t, searchRebuildBody as A, countResponseSchema as An, fieldListResponseSchema as At, updateSectionBody as B, DEFAULT_MAX_UPLOAD_SIZE as Bt, userDetailSchema as C, bylineTranslationCreateBody as Cn, collectionGetQuery as Ct, usersListQuery as D, contentBylineInputSchema as Dn, collectionWithFieldsResponseSchema as Dt, userUpdateBody as E, bylinesListQuery as En, collectionSchema as Et, siteSettingsSchema as F, localeFilterQuery as Fn, orphanedTableListResponseSchema as Ft, taxonomyListResponseSchema as G, mediaItemSchema as Gt, createTermBody as H, mediaConfirmBody as Ht, createSectionBody as I, offsetPaginationQuery as In, orphanedTableSchema as It, termResponseSchema as J, mediaProviderListQuery as Jt, termGetResponseSchema as K, mediaListQuery as Kt, sectionListResponseSchema as L, roleLevel as Ln, schemaExportQuery as Lt, searchResultSchema as M, deleteResponseSchema as Mn, fieldResponseSchema as Mt, searchSuggestQuery as N, httpUrl as Nn, fieldSchema as Nt, searchEnableBody as O, VALID_ROLE_LEVELS as On, createCollectionBody as Ot, settingsUpdateBody as P, localeCode as Pn, orphanRegisterBody as Pt, updateTermBody as Q, mediaUploadUrlResponseSchema as Qt, sectionSchema as R, slugPattern as Rn, updateCollectionBody as Rt, allowedDomainUpdateBody as S, bylineSummarySchema as Sn, publicCommentSchema as St, userSchema as T, bylineUpdateBody as Tn, collectionResponseSchema as Tt, taxonomyDefSchema as U, mediaConfirmResponseSchema as Ut, createTaxonomyDefBody as V, formatFileSize as Vt, taxonomyDefTranslationsSchema as W, mediaExistingResponseSchema as Wt, termTranslationsSchema as X, mediaUpdateBody as Xt, termSchema as Y, mediaResponseSchema as Yt, termWithCountSchema as Z, mediaUploadUrlBody as Zt, widgetAreaSchema as _, trashedContentItemSchema as _n, commentSchema as _t, notFoundPruneBody as a, contentListResponseSchema as an, menuTranslationsSchema as at, widgetSchema as b, bylineCreditSchema as bn, createReactionBody as bt, notFoundSummarySchema as c, contentResponseSchema as cn, updateMenuBody as ct, redirectsListQuery as d, contentSeoSchema as dn, sanitizeHref as dt, contentAuthorsResponseSchema as en, createMenuItemBody as et, updateRedirectBody as f, contentTermsBody as fn, adminCommentListResponseSchema as ft, updateWidgetBody as g, contentUpdateBody as gn, commentListQuery as gt, reorderWidgetsBody as h, contentTrashQuery as hn, commentCountsResponseSchema as ht, notFoundListResponseSchema as i, contentListQuery as in, menuSchema as it, searchResponseSchema as j, cursorPaginationQuery as jn, fieldReorderBody as jt, searchQuery as k, apiErrorSchema as kn, createFieldBody as kt, redirectListResponseSchema as l, contentScheduleBody as ln, updateMenuItemBody as lt, createWidgetBody as m, contentTranslationsResponseSchema as mn, commentBulkResponseSchema as mt, notFoundEntrySchema as n, contentCreateBody as nn, menuItemTypeEnum as nt, notFoundSummaryQuery as o, contentPreviewUrlBody as on, menuWithItemsSchema as ot, createWidgetAreaBody as p, contentTranslationSchema as pn, commentBulkBody as pt, termListResponseSchema as q, mediaListResponseSchema as qt, notFoundListQuery as r, contentItemSchema as rn, menuListItemSchema as rt, notFoundSummaryResponseSchema as s, contentPublishBody as sn, reorderMenuItemsBody as st, createRedirectBody as t, contentCompareResponseSchema as tn, menuItemSchema as tt, redirectSchema as u, contentSeoInput as un, isSafeHref as ut, widgetAreaWithWidgetsAndCountSchema as v, trashedContentListResponseSchema as vn, commentStatusBody as vt, userListResponseSchema as w, bylineTranslationsResponseSchema as wn, collectionListResponseSchema as wt, allowedDomainCreateBody as x, bylineListResponseSchema as xn, publicCommentListResponseSchema as xt, widgetAreaWithWidgetsSchema as y, bylineCreateBody as yn, createCommentBody as yt, sectionsListQuery as z, successEnvelope as zn, updateFieldBody as zt };
//# sourceMappingURL=redirects-DXEXBAII.mjs.map