dineway 0.1.9 → 0.1.12

package/dist/redirects-lrlmYXVE.mjs

@@ -0,0 +1,1023 @@
+import { t as isSafeHref } from "./url-DNjT2abR.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().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());
+/** 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" });
+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. Requires content:publish_any permission. Without this, existing published_at is preserved on re-publish." }),
+	reviewRequestId: z.string().optional().meta({ description: "Approved review request ID for token-authenticated publish execution." }),
+	review_request_id: z.string().optional().meta({ description: "Snake-case alias for reviewRequestId." })
+}).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()
+}).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
+const mediaListQuery = cursorPaginationQuery.extend({ mimeType: z.string().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`;
+}
+function mediaUploadUrlBody(maxSize) {
+	if (!Number.isFinite(maxSize) || maxSize <= 0) throw new Error(`Dineway: 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"),
+		size: z.number().int().positive().max(maxSize, `File size must not exceed ${formatFileSize(maxSize)}`),
+		contentHash: 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: z.string().optional()
+}).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 urlPatternSchema = z.string().refine((value) => !value || value.includes("{slug}"), "URL pattern must include a {slug} placeholder");
+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"
+	]),
+	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()
+}).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: urlPatternSchema.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: urlPatternSchema.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,
+	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,
+	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/api/schemas/menus.ts
+const menuItemType = z.string().min(1);
+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)
+}).meta({ id: "CreateMenuBody" });
+const updateMenuBody = z.object({ label: z.string().min(1).optional() }).meta({ id: "UpdateMenuBody" });
+const createMenuItemBody = z.object({
+	type: menuItemType,
+	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()
+}).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()
+}).meta({ id: "UpdateMenuItemBody" });
+const menuItemDeleteQuery = z.object({ id: z.string().min(1) });
+const menuItemUpdateQuery = z.object({ id: z.string().min(1) });
+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(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).meta({ id: "Menu" });
+const menuItemSchema = z.object({
+	id: z.string(),
+	menu_id: z.string(),
+	parent_id: z.string().nullable(),
+	sort_order: z.number().int(),
+	type: z.string(),
+	reference_collection: z.string().nullable(),
+	reference_id: z.string().nullable(),
+	custom_url: z.string().nullable(),
+	label: z.string(),
+	title_attr: z.string().nullable(),
+	target: z.string().nullable(),
+	css_classes: z.string().nullable(),
+	created_at: z.string()
+}).meta({ id: "MenuItem" });
+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),
+	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([])
+}).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()
+}).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())
+}).meta({ id: "TaxonomyDef" });
+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()
+}).meta({ id: "Term" });
+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))
+}).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 mediaReference = z.object({
+	mediaId: z.string(),
+	alt: z.string().optional()
+});
+const resolvedMediaReference = mediaReference.extend({
+	url: z.string().optional(),
+	contentType: z.string().optional(),
+	width: z.number().optional(),
+	height: z.number().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 seoSettings = z.object({
+	titleSeparator: z.string().max(10).optional(),
+	defaultOgImage: mediaReference.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: mediaReference.optional(),
+	favicon: mediaReference.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: seoSettings.optional()
+}).meta({ id: "SettingsUpdateBody" });
+const siteSettingsSchema = z.object({
+	title: z.string().optional(),
+	tagline: z.string().optional(),
+	logo: resolvedMediaReference.optional(),
+	favicon: resolvedMediaReference.optional(),
+	url: z.string().optional(),
+	postsPerPage: z.number().int().optional(),
+	dateFormat: z.string().optional(),
+	timezone: z.string().optional(),
+	social: socialSettings.optional(),
+	seo: seoSettings.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 { menuItemDeleteQuery as $, contentPreviewUrlBody as $t, searchRebuildBody as A, orphanedTableListResponseSchema as At, updateSectionBody as B, mediaItemSchema as Bt, userDetailSchema as C, deleteResponseSchema as Cn, createCollectionBody as Ct, usersListQuery as D, roleLevel as Dn, fieldResponseSchema as Dt, userUpdateBody as E, offsetPaginationQuery as En, fieldReorderBody as Et, siteSettingsSchema as F, DEFAULT_MAX_UPLOAD_SIZE as Ft, termGetResponseSchema as G, mediaUpdateBody as Gt, createTermBody as H, mediaListResponseSchema as Ht, createSectionBody as I, formatFileSize as It, termSchema as J, contentCompareResponseSchema as Jt, termListResponseSchema as K, mediaUploadUrlBody as Kt, sectionListResponseSchema as L, mediaConfirmBody as Lt, searchResultSchema as M, schemaExportQuery as Mt, searchSuggestQuery as N, updateCollectionBody as Nt, searchEnableBody as O, slugPattern as On, fieldSchema as Ot, settingsUpdateBody as P, updateFieldBody as Pt, createMenuItemBody as Q, contentListResponseSchema as Qt, sectionSchema as R, mediaConfirmResponseSchema as Rt, allowedDomainUpdateBody as S, cursorPaginationQuery as Sn, collectionWithFieldsResponseSchema as St, userSchema as T, localeCode as Tn, fieldListResponseSchema as Tt, taxonomyDefSchema as U, mediaProviderListQuery as Ut, createTaxonomyDefBody as V, mediaListQuery as Vt, taxonomyListResponseSchema as W, mediaResponseSchema as Wt, updateTermBody as X, contentItemSchema as Xt, termWithCountSchema as Y, contentCreateBody as Yt, createMenuBody as Z, contentListQuery as Zt, widgetAreaSchema as _, bylinesListQuery as _n, publicCommentSchema as _t, notFoundPruneBody as a, contentTermsBody as an, reorderMenuItemsBody as at, widgetSchema as b, apiErrorSchema as bn, collectionResponseSchema as bt, notFoundSummarySchema as c, contentTrashQuery as cn, adminCommentListResponseSchema as ct, redirectsListQuery as d, trashedContentListResponseSchema as dn, commentCountsResponseSchema as dt, contentPublishBody as en, menuItemSchema as et, updateRedirectBody as f, bylineCreateBody as fn, commentListQuery as ft, updateWidgetBody as g, bylineUpdateBody as gn, publicCommentListResponseSchema as gt, reorderWidgetsBody as h, bylineSummarySchema as hn, createCommentBody as ht, notFoundListResponseSchema as i, contentSeoSchema as in, menuWithItemsSchema as it, searchResponseSchema as j, orphanedTableSchema as jt, searchQuery as k, successEnvelope as kn, orphanRegisterBody as kt, redirectListResponseSchema as l, contentUpdateBody as ln, commentBulkBody as lt, createWidgetBody as m, bylineListResponseSchema as mn, commentStatusBody as mt, notFoundEntrySchema as n, contentScheduleBody as nn, menuListItemSchema as nt, notFoundSummaryQuery as o, contentTranslationSchema as on, updateMenuBody as ot, createWidgetAreaBody as p, bylineCreditSchema as pn, commentSchema as pt, termResponseSchema as q, mediaUploadUrlResponseSchema as qt, notFoundListQuery as r, contentSeoInput as rn, menuSchema as rt, notFoundSummaryResponseSchema as s, contentTranslationsResponseSchema as sn, updateMenuItemBody as st, createRedirectBody as t, contentResponseSchema as tn, menuItemUpdateQuery as tt, redirectSchema as u, trashedContentItemSchema as un, commentBulkResponseSchema as ut, widgetAreaWithWidgetsAndCountSchema as v, contentBylineInputSchema as vn, collectionGetQuery as vt, userListResponseSchema as w, httpUrl as wn, createFieldBody as wt, allowedDomainCreateBody as x, countResponseSchema as xn, collectionSchema as xt, widgetAreaWithWidgetsSchema as y, VALID_ROLE_LEVELS as yn, collectionListResponseSchema as yt, sectionsListQuery as z, mediaExistingResponseSchema as zt };