@zeropress/preview-data-validator 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ZeroPress
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# @zeropress/preview-data-validator
+
+Shared validation core for ZeroPress preview data v0.2.
+
+This package is the canonical runtime contract for preview payloads consumed by:
+
+- `zeropress-theme dev`
+- `zeropress-admin-api-v2`
+
+## Install
+
+```bash
+npm install @zeropress/preview-data-validator
+```
+
+## Exports
+
+```js
+import {
+  PREVIEW_DATA_VERSION,
+  assertPreviewData,
+  isPreviewData,
+  validatePreviewData,
+} from '@zeropress/preview-data-validator';
+```
+
+Schema export:
+
+```js
+import schemaUrl from '@zeropress/preview-data-validator/preview-data.v0.2.schema.json';
+```
+
+## API
+
+### `validatePreviewData(data)`
+
+Returns:
+
+```js
+{
+  ok: true,
+  errors: [],
+  warnings: []
+}
+```
+
+### `assertPreviewData(data)`
+
+Throws when the payload is invalid.
+
+### `isPreviewData(data)`
+
+Returns `true` when the payload is valid.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@zeropress/preview-data-validator",
+  "version": "0.1.0",
+  "description": "Shared ZeroPress preview data validation core",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": "./src/index.js",
+    "./preview-data.v0.2.schema.json": "./src/preview-data.v0.2.schema.json"
+  },
+  "types": "./src/index.d.ts",
+  "files": [
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zeropress-app/zeropress-preview-data-validator.git"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,121 @@
+export type PreviewStatus = 'published' | 'draft';
+
+export interface ValidationIssue {
+  code: string;
+  path: string;
+  message: string;
+  severity: 'error' | 'warning';
+}
+
+export interface PreviewSiteData {
+  title: string;
+  description: string;
+  url: string;
+  language: string;
+  logo?: string;
+  social?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+export interface PreviewPostData {
+  id: string;
+  public_id: number;
+  title: string;
+  slug: string;
+  html: string;
+  excerpt: string;
+  published_at: string;
+  updated_at: string;
+  published_at_iso: string;
+  updated_at_iso: string;
+  reading_time: string;
+  author_name: string;
+  author_avatar?: string;
+  featured_image?: string;
+  categories_html: string;
+  tags_html: string;
+  comments_html: string;
+  status: PreviewStatus;
+}
+
+export interface PreviewPageData {
+  id: string;
+  title: string;
+  slug: string;
+  html: string;
+  status: PreviewStatus;
+}
+
+export interface PreviewCategoryData {
+  id: string;
+  name: string;
+  slug: string;
+  description?: string;
+  postCount: number;
+}
+
+export interface PreviewTagData {
+  id: string;
+  name: string;
+  slug: string;
+  postCount: number;
+}
+
+export interface PreviewRouteBlocks {
+  posts: string;
+  pagination: string;
+  categories?: string;
+  tags?: string;
+}
+
+export interface PreviewCategoryRouteData {
+  slug: string;
+  posts: string;
+  pagination: string;
+  categories?: string;
+}
+
+export interface PreviewTagRouteData {
+  slug: string;
+  posts: string;
+  pagination: string;
+  tags?: string;
+}
+
+export interface PreviewContentData {
+  posts: PreviewPostData[];
+  pages: PreviewPageData[];
+  categories: PreviewCategoryData[];
+  tags: PreviewTagData[];
+}
+
+export interface PreviewRoutesData {
+  index: PreviewRouteBlocks & {
+    categories: string;
+    tags: string;
+  };
+  archive: PreviewRouteBlocks;
+  categories: PreviewCategoryRouteData[];
+  tags: PreviewTagRouteData[];
+}
+
+export interface PreviewDataV02 {
+  version: '0.2';
+  generator: string;
+  generated_at: string;
+  site: PreviewSiteData;
+  content: PreviewContentData;
+  routes: PreviewRoutesData;
+}
+
+export interface PreviewDataValidationResult {
+  ok: boolean;
+  errors: ValidationIssue[];
+  warnings: ValidationIssue[];
+}
+
+export const PREVIEW_DATA_VERSION: '0.2';
+
+export function validatePreviewData(data: unknown): PreviewDataValidationResult;
+export function assertPreviewData<T>(data: T): T;
+export function isPreviewData(data: unknown): data is PreviewDataV02;

package/src/index.js

@@ -0,0 +1,355 @@
+export const PREVIEW_DATA_VERSION = '0.2';
+
+export function validatePreviewData(data) {
+  const errors = [];
+
+  validateClosedObject(data, '', errors, ['version', 'generator', 'generated_at', 'site', 'content', 'routes']);
+
+  if (!errors.length) {
+    validateLiteral(data.version, '0.2', 'version', 'INVALID_VERSION', errors);
+    validateNonEmptyString(data.generator, 'generator', 'INVALID_GENERATOR', errors);
+    validateDateTimeString(data.generated_at, 'generated_at', 'INVALID_GENERATED_AT', errors);
+
+    validateSite(data.site, 'site', errors);
+    validateContent(data.content, 'content', errors);
+    validateRoutes(data.routes, 'routes', errors);
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings: [],
+  };
+}
+
+export function assertPreviewData(data) {
+  const result = validatePreviewData(data);
+  if (!result.ok) {
+    const first = result.errors[0];
+    throw new Error(first ? `${first.code} ${first.path}: ${first.message}` : 'Invalid preview data');
+  }
+  return data;
+}
+
+export function isPreviewData(data) {
+  return validatePreviewData(data).ok;
+}
+
+function validateSite(site, path, errors) {
+  validateObject(site, path, 'INVALID_SITE', errors);
+  if (!isObject(site)) {
+    return;
+  }
+
+  validateNonEmptyString(site.title, `${path}.title`, 'INVALID_SITE_TITLE', errors);
+  validateString(site.description, `${path}.description`, 'INVALID_SITE_DESCRIPTION', errors);
+  validateUri(site.url, `${path}.url`, 'INVALID_SITE_URL', errors);
+  validateNonEmptyString(site.language, `${path}.language`, 'INVALID_SITE_LANGUAGE', errors);
+
+  if (site.logo !== undefined) {
+    validateUri(site.logo, `${path}.logo`, 'INVALID_SITE_LOGO', errors);
+  }
+
+  if (site.social !== undefined) {
+    validateObject(site.social, `${path}.social`, 'INVALID_SITE_SOCIAL', errors);
+    if (isObject(site.social)) {
+      for (const [key, value] of Object.entries(site.social)) {
+        validateString(value, `${path}.social.${key}`, 'INVALID_SITE_SOCIAL_VALUE', errors);
+      }
+    }
+  }
+}
+
+function validateContent(content, path, errors) {
+  validateClosedObject(content, path, errors, ['posts', 'pages', 'categories', 'tags']);
+  if (!isObject(content)) {
+    return;
+  }
+
+  validateArray(content.posts, `${path}.posts`, 'INVALID_POSTS', errors, (entry, index) => {
+    validatePreviewPost(entry, `${path}.posts[${index}]`, errors);
+  });
+  validateArray(content.pages, `${path}.pages`, 'INVALID_PAGES', errors, (entry, index) => {
+    validatePreviewPage(entry, `${path}.pages[${index}]`, errors);
+  });
+  validateArray(content.categories, `${path}.categories`, 'INVALID_CATEGORIES', errors, (entry, index) => {
+    validatePreviewCategory(entry, `${path}.categories[${index}]`, errors);
+  });
+  validateArray(content.tags, `${path}.tags`, 'INVALID_TAGS', errors, (entry, index) => {
+    validatePreviewTag(entry, `${path}.tags[${index}]`, errors);
+  });
+}
+
+function validateRoutes(routes, path, errors) {
+  validateClosedObject(routes, path, errors, ['index', 'archive', 'categories', 'tags']);
+  if (!isObject(routes)) {
+    return;
+  }
+
+  validateRouteBlocks(routes.index, `${path}.index`, errors, {
+    requiredKeys: ['posts', 'pagination', 'categories', 'tags'],
+    allowKeys: ['posts', 'pagination', 'categories', 'tags'],
+  });
+  validateRouteBlocks(routes.archive, `${path}.archive`, errors, {
+    requiredKeys: ['posts', 'pagination'],
+    allowKeys: ['posts', 'pagination', 'categories', 'tags'],
+  });
+  validateArray(routes.categories, `${path}.categories`, 'INVALID_CATEGORY_ROUTES', errors, (entry, index) => {
+    validateCategoryRoute(entry, `${path}.categories[${index}]`, errors);
+  });
+  validateArray(routes.tags, `${path}.tags`, 'INVALID_TAG_ROUTES', errors, (entry, index) => {
+    validateTagRoute(entry, `${path}.tags[${index}]`, errors);
+  });
+}
+
+function validatePreviewPost(post, path, errors) {
+  validateClosedObject(post, path, errors, [
+    'id',
+    'public_id',
+    'title',
+    'slug',
+    'html',
+    'excerpt',
+    'published_at',
+    'updated_at',
+    'published_at_iso',
+    'updated_at_iso',
+    'reading_time',
+    'author_name',
+    'author_avatar',
+    'featured_image',
+    'categories_html',
+    'tags_html',
+    'comments_html',
+    'status',
+  ]);
+  if (!isObject(post)) {
+    return;
+  }
+
+  validateNonEmptyString(post.id, `${path}.id`, 'INVALID_POST_ID', errors);
+  validateInteger(post.public_id, `${path}.public_id`, 'INVALID_POST_PUBLIC_ID', errors, { minimum: 1 });
+  validateNonEmptyString(post.title, `${path}.title`, 'INVALID_POST_TITLE', errors);
+  validateNonEmptyString(post.slug, `${path}.slug`, 'INVALID_POST_SLUG', errors);
+  validateString(post.html, `${path}.html`, 'INVALID_POST_HTML', errors);
+  validateString(post.excerpt, `${path}.excerpt`, 'INVALID_POST_EXCERPT', errors);
+  validateNonEmptyString(post.published_at, `${path}.published_at`, 'INVALID_POST_PUBLISHED_AT', errors);
+  validateNonEmptyString(post.updated_at, `${path}.updated_at`, 'INVALID_POST_UPDATED_AT', errors);
+  validateDateTimeString(post.published_at_iso, `${path}.published_at_iso`, 'INVALID_POST_PUBLISHED_AT_ISO', errors);
+  validateDateTimeString(post.updated_at_iso, `${path}.updated_at_iso`, 'INVALID_POST_UPDATED_AT_ISO', errors);
+  validateNonEmptyString(post.reading_time, `${path}.reading_time`, 'INVALID_POST_READING_TIME', errors);
+  validateNonEmptyString(post.author_name, `${path}.author_name`, 'INVALID_POST_AUTHOR_NAME', errors);
+  validateString(post.categories_html, `${path}.categories_html`, 'INVALID_POST_CATEGORIES_HTML', errors);
+  validateString(post.tags_html, `${path}.tags_html`, 'INVALID_POST_TAGS_HTML', errors);
+  validateString(post.comments_html, `${path}.comments_html`, 'INVALID_POST_COMMENTS_HTML', errors);
+  validateEnum(post.status, `${path}.status`, 'INVALID_POST_STATUS', errors, ['published', 'draft']);
+
+  if (post.author_avatar !== undefined) {
+    validateUri(post.author_avatar, `${path}.author_avatar`, 'INVALID_POST_AUTHOR_AVATAR', errors);
+  }
+  if (post.featured_image !== undefined) {
+    validateUri(post.featured_image, `${path}.featured_image`, 'INVALID_POST_FEATURED_IMAGE', errors);
+  }
+}
+
+function validatePreviewPage(page, path, errors) {
+  validateClosedObject(page, path, errors, ['id', 'title', 'slug', 'html', 'status']);
+  if (!isObject(page)) {
+    return;
+  }
+
+  validateNonEmptyString(page.id, `${path}.id`, 'INVALID_PAGE_ID', errors);
+  validateNonEmptyString(page.title, `${path}.title`, 'INVALID_PAGE_TITLE', errors);
+  validateNonEmptyString(page.slug, `${path}.slug`, 'INVALID_PAGE_SLUG', errors);
+  validateString(page.html, `${path}.html`, 'INVALID_PAGE_HTML', errors);
+  validateEnum(page.status, `${path}.status`, 'INVALID_PAGE_STATUS', errors, ['published', 'draft']);
+}
+
+function validatePreviewCategory(category, path, errors) {
+  validateClosedObject(category, path, errors, ['id', 'name', 'slug', 'description', 'postCount']);
+  if (!isObject(category)) {
+    return;
+  }
+
+  validateNonEmptyString(category.id, `${path}.id`, 'INVALID_CATEGORY_ID', errors);
+  validateNonEmptyString(category.name, `${path}.name`, 'INVALID_CATEGORY_NAME', errors);
+  validateNonEmptyString(category.slug, `${path}.slug`, 'INVALID_CATEGORY_SLUG', errors);
+  validateInteger(category.postCount, `${path}.postCount`, 'INVALID_CATEGORY_POST_COUNT', errors, { minimum: 0 });
+  if (category.description !== undefined) {
+    validateString(category.description, `${path}.description`, 'INVALID_CATEGORY_DESCRIPTION', errors);
+  }
+}
+
+function validatePreviewTag(tag, path, errors) {
+  validateClosedObject(tag, path, errors, ['id', 'name', 'slug', 'postCount']);
+  if (!isObject(tag)) {
+    return;
+  }
+
+  validateNonEmptyString(tag.id, `${path}.id`, 'INVALID_TAG_ID', errors);
+  validateNonEmptyString(tag.name, `${path}.name`, 'INVALID_TAG_NAME', errors);
+  validateNonEmptyString(tag.slug, `${path}.slug`, 'INVALID_TAG_SLUG', errors);
+  validateInteger(tag.postCount, `${path}.postCount`, 'INVALID_TAG_POST_COUNT', errors, { minimum: 0 });
+}
+
+function validateCategoryRoute(route, path, errors) {
+  validateClosedObject(route, path, errors, ['slug', 'posts', 'pagination', 'categories']);
+  if (!isObject(route)) {
+    return;
+  }
+
+  validateNonEmptyString(route.slug, `${path}.slug`, 'INVALID_CATEGORY_ROUTE_SLUG', errors);
+  validateString(route.posts, `${path}.posts`, 'INVALID_CATEGORY_ROUTE_POSTS', errors);
+  validateString(route.pagination, `${path}.pagination`, 'INVALID_CATEGORY_ROUTE_PAGINATION', errors);
+  if (route.categories !== undefined) {
+    validateString(route.categories, `${path}.categories`, 'INVALID_CATEGORY_ROUTE_CATEGORIES', errors);
+  }
+}
+
+function validateTagRoute(route, path, errors) {
+  validateClosedObject(route, path, errors, ['slug', 'posts', 'pagination', 'tags']);
+  if (!isObject(route)) {
+    return;
+  }
+
+  validateNonEmptyString(route.slug, `${path}.slug`, 'INVALID_TAG_ROUTE_SLUG', errors);
+  validateString(route.posts, `${path}.posts`, 'INVALID_TAG_ROUTE_POSTS', errors);
+  validateString(route.pagination, `${path}.pagination`, 'INVALID_TAG_ROUTE_PAGINATION', errors);
+  if (route.tags !== undefined) {
+    validateString(route.tags, `${path}.tags`, 'INVALID_TAG_ROUTE_TAGS', errors);
+  }
+}
+
+function validateRouteBlocks(blocks, path, errors, options) {
+  validateClosedObject(blocks, path, errors, options.allowKeys);
+  if (!isObject(blocks)) {
+    return;
+  }
+
+  for (const key of options.requiredKeys) {
+    validateString(blocks[key], `${path}.${key}`, `INVALID_ROUTE_${key.toUpperCase()}`, errors);
+  }
+
+  for (const key of options.allowKeys) {
+    if (blocks[key] !== undefined) {
+      validateString(blocks[key], `${path}.${key}`, `INVALID_ROUTE_${key.toUpperCase()}`, errors);
+    }
+  }
+}
+
+function validateArray(value, path, code, errors, itemValidator) {
+  if (!Array.isArray(value)) {
+    errors.push(issue(code, path, 'Expected an array'));
+    return;
+  }
+
+  value.forEach((entry, index) => itemValidator(entry, index));
+}
+
+function validateClosedObject(value, path, errors, allowedKeys) {
+  validateObject(value, path, 'INVALID_OBJECT', errors);
+  if (!isObject(value)) {
+    return;
+  }
+
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.includes(key)) {
+      errors.push(issue('UNKNOWN_PROPERTY', path ? `${path}.${key}` : key, 'Unexpected property'));
+    }
+  }
+
+  for (const key of allowedKeys) {
+    if (!(key in value) && !isOptionalKey(path, key)) {
+      errors.push(issue('MISSING_REQUIRED_PROPERTY', path ? `${path}.${key}` : key, 'Missing required property'));
+    }
+  }
+}
+
+function isOptionalKey(path, key) {
+  if (path === 'site') return key === 'logo' || key === 'social';
+  if (path.endsWith('.index')) return false;
+  if (path.endsWith('.archive')) return key === 'categories' || key === 'tags';
+  if (path.includes('categories[')) return key === 'categories';
+  if (path.includes('tags[')) return key === 'tags';
+  if (path.includes('.posts[')) return key === 'author_avatar' || key === 'featured_image';
+  if (path.includes('.categories[')) return key === 'description';
+  return false;
+}
+
+function validateObject(value, path, code, errors) {
+  if (!isObject(value)) {
+    errors.push(issue(code, path, 'Expected an object'));
+  }
+}
+
+function validateLiteral(value, expected, path, code, errors) {
+  if (value !== expected) {
+    errors.push(issue(code, path, `Expected '${expected}'`));
+  }
+}
+
+function validateNonEmptyString(value, path, code, errors) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    errors.push(issue(code, path, 'Expected a non-empty string'));
+  }
+}
+
+function validateString(value, path, code, errors) {
+  if (typeof value !== 'string') {
+    errors.push(issue(code, path, 'Expected a string'));
+  }
+}
+
+function validateInteger(value, path, code, errors, options = {}) {
+  if (!Number.isInteger(value)) {
+    errors.push(issue(code, path, 'Expected an integer'));
+    return;
+  }
+  if (options.minimum !== undefined && value < options.minimum) {
+    errors.push(issue(code, path, `Expected an integer >= ${options.minimum}`));
+  }
+}
+
+function validateEnum(value, path, code, errors, allowedValues) {
+  if (!allowedValues.includes(value)) {
+    errors.push(issue(code, path, `Expected one of: ${allowedValues.join(', ')}`));
+  }
+}
+
+function validateUri(value, path, code, errors) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    errors.push(issue(code, path, 'Expected a URI string'));
+    return;
+  }
+
+  try {
+    new URL(value);
+  } catch {
+    errors.push(issue(code, path, 'Expected a valid URI'));
+  }
+}
+
+function validateDateTimeString(value, path, code, errors) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    errors.push(issue(code, path, 'Expected an ISO date-time string'));
+    return;
+  }
+
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) {
+    errors.push(issue(code, path, 'Expected a valid ISO date-time string'));
+  }
+}
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function issue(code, path, message) {
+  return {
+    code,
+    path,
+    message,
+    severity: 'error',
+  };
+}

package/src/preview-data.v0.2.schema.json

@@ -0,0 +1,215 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://zeropress.dev/schemas/preview-data.v0.2.schema.json",
+  "title": "ZeroPress Theme Preview Data v0.2",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["version", "generator", "generated_at", "site", "content", "routes"],
+  "properties": {
+    "version": {
+      "const": "0.2"
+    },
+    "generator": {
+      "type": "string",
+      "minLength": 1
+    },
+    "generated_at": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "site": {
+      "$ref": "#/$defs/site"
+    },
+    "content": {
+      "$ref": "#/$defs/content"
+    },
+    "routes": {
+      "$ref": "#/$defs/routes"
+    }
+  },
+  "$defs": {
+    "site": {
+      "type": "object",
+      "required": ["title", "description", "url", "language"],
+      "properties": {
+        "title": { "type": "string", "minLength": 1 },
+        "description": { "type": "string" },
+        "url": { "type": "string", "format": "uri" },
+        "language": { "type": "string", "minLength": 2 },
+        "logo": { "type": "string", "format": "uri" },
+        "social": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        }
+      },
+      "additionalProperties": true
+    },
+    "previewPost": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "public_id",
+        "title",
+        "slug",
+        "html",
+        "excerpt",
+        "published_at",
+        "updated_at",
+        "published_at_iso",
+        "updated_at_iso",
+        "reading_time",
+        "author_name",
+        "categories_html",
+        "tags_html",
+        "comments_html",
+        "status"
+      ],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "public_id": { "type": "integer", "minimum": 1 },
+        "title": { "type": "string", "minLength": 1 },
+        "slug": { "type": "string", "minLength": 1 },
+        "html": { "type": "string" },
+        "excerpt": { "type": "string" },
+        "published_at": { "type": "string" },
+        "updated_at": { "type": "string" },
+        "published_at_iso": { "type": "string", "format": "date-time" },
+        "updated_at_iso": { "type": "string", "format": "date-time" },
+        "reading_time": { "type": "string", "minLength": 1 },
+        "author_name": { "type": "string", "minLength": 1 },
+        "author_avatar": { "type": "string", "format": "uri" },
+        "featured_image": { "type": "string", "format": "uri" },
+        "categories_html": { "type": "string" },
+        "tags_html": { "type": "string" },
+        "comments_html": { "type": "string" },
+        "status": {
+          "type": "string",
+          "enum": ["published", "draft"]
+        }
+      }
+    },
+    "previewPage": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "title", "slug", "html", "status"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "title": { "type": "string", "minLength": 1 },
+        "slug": { "type": "string", "minLength": 1 },
+        "html": { "type": "string" },
+        "status": {
+          "type": "string",
+          "enum": ["published", "draft"]
+        }
+      }
+    },
+    "previewCategory": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "name", "slug", "postCount"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "name": { "type": "string", "minLength": 1 },
+        "slug": { "type": "string", "minLength": 1 },
+        "description": { "type": "string" },
+        "postCount": { "type": "integer", "minimum": 0 }
+      }
+    },
+    "previewTag": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "name", "slug", "postCount"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "name": { "type": "string", "minLength": 1 },
+        "slug": { "type": "string", "minLength": 1 },
+        "postCount": { "type": "integer", "minimum": 0 }
+      }
+    },
+    "content": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["posts", "pages", "categories", "tags"],
+      "properties": {
+        "posts": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/previewPost" }
+        },
+        "pages": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/previewPage" }
+        },
+        "categories": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/previewCategory" }
+        },
+        "tags": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/previewTag" }
+        }
+      }
+    },
+    "routeBlocks": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["posts", "pagination"],
+      "properties": {
+        "posts": { "type": "string" },
+        "pagination": { "type": "string" },
+        "categories": { "type": "string" },
+        "tags": { "type": "string" }
+      }
+    },
+    "categoryRoute": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["slug", "posts", "pagination"],
+      "properties": {
+        "slug": { "type": "string", "minLength": 1 },
+        "posts": { "type": "string" },
+        "pagination": { "type": "string" },
+        "categories": { "type": "string" }
+      }
+    },
+    "tagRoute": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["slug", "posts", "pagination"],
+      "properties": {
+        "slug": { "type": "string", "minLength": 1 },
+        "posts": { "type": "string" },
+        "pagination": { "type": "string" },
+        "tags": { "type": "string" }
+      }
+    },
+    "routes": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["index", "archive", "categories", "tags"],
+      "properties": {
+        "index": {
+          "allOf": [
+            { "$ref": "#/$defs/routeBlocks" },
+            {
+              "required": ["posts", "categories", "tags", "pagination"]
+            }
+          ]
+        },
+        "archive": {
+          "$ref": "#/$defs/routeBlocks"
+        },
+        "categories": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/categoryRoute" }
+        },
+        "tags": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/tagRoute" }
+        }
+      }
+    }
+  }
+}