@xleddyl/nuxt-cms 0.2.2 → 0.3.0

package/dist/runtime/server/utils/graphql.js

@@ -20,6 +20,8 @@ import { cmsDialect, useDb } from "#cms-db";
 import * as cmsTables from "#cms-tables";
 import { useRuntimeConfig } from "#imports";
 import {
+  CONTENT_SLUG_FIELD,
+  CONTENT_PUBLISHED_AT_FIELD,
   decodeTranslatableMedia,
   entryFieldsFor,
   hasTranslatableBlockFields,
@@ -29,6 +31,7 @@ import {
   mediaPublicUrl,
   mediaTypeFor,
   pickTranslatedMedia,
+  publicBlocks,
   translatableFieldKeys
 } from "../../shared/index.js";
 import {
@@ -41,6 +44,7 @@ import { normalizeTimestampFields } from "../../shared/timestamps.js";
 import { useMediaIndex } from "./media-index.js";
 import { readPages } from "./page-storage.js";
 import { getContentI18n, resolveTable, tableColumns } from "./registry.js";
+import { visibilityConditions } from "./visibility.js";
 const MAX_LIMIT = 100;
 const DEFAULT_LIMIT = 50;
 const LOCALE = Symbol("locale");
@@ -85,9 +89,7 @@ function tableFor(name) {
   return table;
 }
 function publishedFilter(entry, table) {
-  if (!entry.drafts) return [];
-  const status = tableColumns(table).status;
-  return status ? [eq(status, "published")] : [];
+  return visibilityConditions(entry, tableColumns(table));
 }
 function localeOf(parent) {
   return parent[LOCALE] ?? getContentI18n().defaultLocale;
@@ -116,8 +118,9 @@ function localizeRow(entry, row, locale) {
     result[key] = value?.[locale] ?? value?.[defaultLocale] ?? null;
   }
   for (const [key, field] of Object.entries(fields)) {
-    if (isPrivateField(field) || !hasTranslatableBlockFields(field)) continue;
-    result[key] = localizeBlocks(field, result[key], locale, defaultLocale);
+    if (isPrivateField(field) || field.type !== "blocks") continue;
+    const visible = publicBlocks(field, result[key]);
+    result[key] = hasTranslatableBlockFields(field) ? localizeBlocks(field, visible, locale, defaultLocale) : visible;
   }
   return result;
 }
@@ -162,7 +165,7 @@ function filterConditions(table, filters) {
   }
   return conditions;
 }
-function sortOrder(table, sort) {
+function sortOrder(entry, table, sort) {
   const order = [];
   for (const part of sort ?? []) {
     const column = columnFor(table, part.field);
@@ -170,7 +173,10 @@ function sortOrder(table, sort) {
     order.push(part.direction === "desc" ? desc(column) : asc(column));
   }
   if (!order.length) {
-    const fallback = tableColumns(table).createdAt ?? tableColumns(table).id;
+    const columns = tableColumns(table);
+    const published = entry.kind === "content" ? columns[CONTENT_PUBLISHED_AT_FIELD] : void 0;
+    if (published) order.push(desc(published));
+    const fallback = columns.createdAt ?? columns.id;
     if (fallback) order.push(desc(fallback));
   }
   return order;
@@ -350,7 +356,7 @@ export function buildCmsSchema() {
       const where = [...publishedFilter(entry, table), ...filterConditions(table, args.filters)];
       const limit = Math.min(MAX_LIMIT, Math.max(0, args.limit ?? DEFAULT_LIMIT));
       const offset = Math.max(0, args.offset ?? 0);
-      const rows = await useDb().select().from(table).where(where.length ? and(...where) : void 0).orderBy(...sortOrder(table, args.sort)).limit(limit).offset(offset);
+      const rows = await useDb().select().from(table).where(where.length ? and(...where) : void 0).orderBy(...sortOrder(entry, table, args.sort)).limit(limit).offset(offset);
       return rows.map((row) => localizeRow(entry, row, locale));
     };
     queryResolvers[`${name}ById`] = async (_, args) => {
@@ -359,6 +365,15 @@ export function buildCmsSchema() {
       const [row] = await useDb().select().from(table).where(and(eq(tableColumns(table).id, args.id), ...publishedFilter(entry, table))).limit(1);
       return row ? localizeRow(entry, row, locale) : null;
     };
+    if (entry.kind === "content") {
+      queryResolvers[`${name}BySlug`] = async (_, args) => {
+        const locale = resolveLocaleArg(args.locale);
+        const table = tableFor(name);
+        const slug = tableColumns(table)[CONTENT_SLUG_FIELD];
+        const [row] = await useDb().select().from(table).where(and(eq(slug, args.slug), ...publishedFilter(entry, table))).limit(1);
+        return row ? localizeRow(entry, row, locale) : null;
+      };
+    }
     queryResolvers[`${name}Count`] = async (_, args) => {
       const table = tableFor(name);
       const where = [...publishedFilter(entry, table), ...filterConditions(table, args.filters)];

package/dist/runtime/server/utils/media-download.d.ts

@@ -0,0 +1 @@
+export declare function attachmentDisposition(filename: string): string;

package/dist/runtime/server/utils/media-download.js

@@ -0,0 +1,8 @@
+export function attachmentDisposition(filename) {
+  const fallback = filename.replace(/[^\x20-\x7e]|["\\%]/g, "_");
+  const encoded = encodeURIComponent(filename).replace(
+    /['()*]/g,
+    (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+  return `attachment; filename="${fallback}"; filename*=UTF-8''${encoded}`;
+}

package/dist/runtime/server/utils/media.d.ts

@@ -32,6 +32,7 @@ export declare function useMediaConfig(event: H3Event): {
     publicUrl: (key: string) => string | null;
 };
 export declare function mediaUploadPath(key: string): string;
+export declare function presignedDownloadUrl(media: MediaConfig, key: string, disposition: string): Promise<string>;
 export declare function useMediaStorage(event: H3Event): {
     media: MediaConfig;
     store: MediaStore;

package/dist/runtime/server/utils/media.js

@@ -94,14 +94,29 @@ function filesystemStore(dir) {
     remove: (key) => removeMediaFile(dir, key)
   };
 }
-function s3Store(media) {
-  const client = new AwsClient({
+function s3Client(media) {
+  return new AwsClient({
     accessKeyId: media.accessKeyId,
     secretAccessKey: media.secretAccessKey,
     region: media.region,
     service: "s3"
   });
-  const bucketUrl = `${media.endpoint.replace(/\/+$/, "")}/${media.bucket}`;
+}
+function s3BucketUrl(media) {
+  return `${media.endpoint.replace(/\/+$/, "")}/${media.bucket}`;
+}
+export async function presignedDownloadUrl(media, key, disposition) {
+  const url = new URL(`${s3BucketUrl(media)}/${encodeKey(key)}`);
+  url.searchParams.set("X-Amz-Expires", String(media.presignExpiry));
+  url.searchParams.set("response-content-disposition", disposition);
+  const signed = await s3Client(media).sign(new Request(url, { method: "GET" }), {
+    aws: { signQuery: true }
+  });
+  return signed.url;
+}
+function s3Store(media) {
+  const client = s3Client(media);
+  const bucketUrl = s3BucketUrl(media);
   return {
     async uploadTarget(key, contentType, size) {
       const url = new URL(`${bucketUrl}/${key}`);

package/dist/runtime/server/utils/registry.d.ts

@@ -23,4 +23,5 @@ export declare function buildValidator(entry: CmsEntry, path?: string): z.ZodObj
 export declare function requirePageRoute(entry: CmsEntry, key: string): CmsPageRoute;
 export declare function encodeColumnValues(entry: CmsEntry, values: Record<string, unknown>): Record<string, unknown>;
 export declare function decodeRows<T extends Record<string, unknown>>(entry: CmsEntry, rows: T[]): T[];
+export declare function withContentDefaults(entry: CmsEntry, values: Record<string, unknown>): Record<string, unknown>;
 export declare function parseId(event: H3Event): string;

package/dist/runtime/server/utils/registry.js

@@ -4,6 +4,7 @@ import cmsConfig from "#cms-config";
 import * as cmsTables from "#cms-tables";
 import { useRuntimeConfig } from "#imports";
 import {
+  CONTENT_PUBLISHED_AT_FIELD,
   decodeEntryTranslatableMedia,
   encodeEntryTranslatableMedia,
   pageFields,
@@ -69,6 +70,11 @@ export function decodeRows(entry, rows) {
   for (const row of rows) normalizeTimestampFields(row);
   return decodeEntryTranslatableMedia(entry, rows, getContentI18n().defaultLocale);
 }
+export function withContentDefaults(entry, values) {
+  if (entry.kind !== "content" || values.status !== "published") return values;
+  if (!values[CONTENT_PUBLISHED_AT_FIELD]) values[CONTENT_PUBLISHED_AT_FIELD] = nowTimestamp();
+  return values;
+}
 export function parseId(event) {
   return z.string().min(1).parse(getRouterParam(event, "id"));
 }

package/dist/runtime/server/utils/search.d.ts

@@ -0,0 +1,20 @@
+import type { SQL } from 'drizzle-orm';
+import type { AnySQLiteColumn, BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import type { CmsConfig, CmsI18n } from '../../shared/index.js';
+import type { CmsSearchHit, CmsSearchResponse } from '../../shared/search.js';
+export type SearchDb = Pick<BaseSQLiteDatabase<'sync' | 'async', unknown>, 'select' | 'selectDistinct'>;
+export type SearchDialect = 'sqlite' | 'postgres';
+export interface CmsSearchOptions {
+    db: SearchDb;
+    dialect: SearchDialect;
+    config: CmsConfig;
+    tables: Record<string, unknown>;
+    i18n: CmsI18n;
+    query: string;
+}
+export declare function searchLikeCondition(dialect: SearchDialect, column: AnySQLiteColumn, pattern: string): SQL;
+export declare function searchCmsValues(options: CmsSearchOptions): Promise<{
+    hits: CmsSearchHit[];
+    truncated: boolean;
+}>;
+export declare function searchCms(options: CmsSearchOptions): Promise<CmsSearchResponse>;

package/dist/runtime/server/utils/search.js

@@ -0,0 +1,233 @@
+import { desc, inArray, or, sql } from "drizzle-orm";
+import {
+  decodeTranslatableValue,
+  isMultiSelect,
+  isTranslatableField,
+  mediaFilename,
+  pageColumnFields,
+  pageFields,
+  pageFieldsTableName,
+  pageMediaTableName,
+  pageRouteOf
+} from "../../shared/index.js";
+import {
+  CMS_SEARCH_HITS_PER_ROW,
+  CMS_SEARCH_MIN_LENGTH,
+  CMS_SEARCH_ROWS_PER_ENTRY,
+  CMS_SEARCH_VALUE_LIMIT,
+  cmsSearchLink,
+  normalizeSearchQuery,
+  searchCmsLabels,
+  searchFieldPath,
+  searchLikePattern,
+  searchSnippet,
+  stripMarkup
+} from "../../shared/search.js";
+import { decodePageRows, selectPages } from "./page-rows.js";
+const VALUE_TYPES = /* @__PURE__ */ new Set(["text", "richtext", "email", "slug", "select", "json", "blocks"]);
+function isSearchableField(field) {
+  return VALUE_TYPES.has(field.type);
+}
+function columnsOf(table) {
+  return table;
+}
+function tableOf(context, name) {
+  const entry = context.config[name];
+  return entry?.table ?? context.tables[name];
+}
+export function searchLikeCondition(dialect, column, pattern) {
+  const text = dialect === "postgres" ? sql`cast(${column} as text)` : sql`${column}`;
+  return sql`lower(${text}) like ${pattern} escape '\\'`;
+}
+function plainText(field, value) {
+  return field.type === "richtext" ? stripMarkup(value) : value;
+}
+function fieldTexts(field, value, defaultLocale) {
+  if (value == null || value === "") return [];
+  if (isTranslatableField(field)) {
+    return Object.entries(decodeTranslatableValue(value, defaultLocale) ?? {}).filter((pair) => typeof pair[1] === "string" && !!pair[1]).map(([locale, text]) => ({ locale, text: plainText(field, text) }));
+  }
+  if (isMultiSelect(field) && Array.isArray(value)) {
+    return [{ locale: null, text: value.map(String).join(", ") }];
+  }
+  if (typeof value === "string") return [{ locale: null, text: plainText(field, value) }];
+  return [{ locale: null, text: JSON.stringify(value) }];
+}
+function rowHits(fields, row, term, defaultLocale) {
+  const hits = [];
+  const collect = (field, value, hit) => {
+    for (const { locale, text } of fieldTexts(field, value, defaultLocale)) {
+      if (hits.length >= CMS_SEARCH_HITS_PER_ROW) return;
+      const snippet = searchSnippet(text, term);
+      if (snippet) hits.push({ ...hit, locale, snippet });
+    }
+  };
+  for (const [key, field] of Object.entries(fields)) {
+    if (hits.length >= CMS_SEARCH_HITS_PER_ROW) break;
+    if (!isSearchableField(field)) continue;
+    const value = row[key];
+    if (field.type !== "blocks") {
+      collect(field, value, { field: key, block: null, fieldLabel: field.label });
+      continue;
+    }
+    if (!Array.isArray(value)) continue;
+    value.forEach((item, index) => {
+      const block = item ? field.blocks?.[String(item.type)] : void 0;
+      if (!item || !block) return;
+      for (const [blockKey, blockField] of Object.entries(block.fields)) {
+        if (!isSearchableField(blockField)) continue;
+        collect(blockField, item[blockKey], {
+          field: key,
+          block: index,
+          fieldLabel: searchFieldPath(field.label, block.label, blockField.label)
+        });
+      }
+    });
+  }
+  return hits;
+}
+function titleOf(entry, row, defaultLocale) {
+  if (entry.kind === "single" || !entry.titleField) return null;
+  const value = row[entry.titleField];
+  if (value == null) return null;
+  if (typeof value === "object") {
+    const values = value;
+    const text = [values[defaultLocale], ...Object.values(values)].find(
+      (candidate) => typeof candidate === "string" && !!candidate
+    );
+    return text ?? null;
+  }
+  return String(value) || null;
+}
+async function tableRows(context, entry, table) {
+  const columns = columnsOf(table);
+  const conditions = Object.entries(entry.fields).filter(([key, field]) => isSearchableField(field) && Object.hasOwn(columns, key)).map(([key]) => searchLikeCondition(context.dialect, columns[key], context.pattern));
+  if (!conditions.length) return [];
+  const query = context.db.select().from(table).where(or(...conditions));
+  const ordered = columns.updatedAt ? query.orderBy(desc(columns.updatedAt)) : query;
+  return await ordered.limit(CMS_SEARCH_ROWS_PER_ENTRY);
+}
+async function pageRows(context, name, entry, table) {
+  const fields = tableOf(context, pageFieldsTableName(name));
+  const media = tableOf(context, pageMediaTableName(name));
+  if (!fields || !media) return [];
+  const pageColumns = columnsOf(table);
+  const fieldColumns = columnsOf(fields);
+  const matched = await context.db.selectDistinct({ id: fieldColumns.pageId }).from(fields).where(searchLikeCondition(context.dialect, fieldColumns.value, context.pattern)).limit(CMS_SEARCH_ROWS_PER_ENTRY);
+  const conditions = Object.entries(pageColumnFields(entry)).filter(([key, field]) => isSearchableField(field) && Object.hasOwn(pageColumns, key)).map(([key]) => searchLikeCondition(context.dialect, pageColumns[key], context.pattern));
+  if (conditions.length) {
+    matched.push(
+      ...await context.db.select({ id: pageColumns.id }).from(table).where(or(...conditions)).limit(CMS_SEARCH_ROWS_PER_ENTRY)
+    );
+  }
+  const ids = [...new Set(matched.map((row) => String(row.id)))].slice(
+    0,
+    CMS_SEARCH_ROWS_PER_ENTRY
+  );
+  if (!ids.length) return [];
+  const rows = await selectPages(context.db, context.dialect, {
+    page: table,
+    fields,
+    media
+  }).where(inArray(pageColumns.id, ids));
+  return decodePageRows(entry, rows);
+}
+function itemPath(name, entry, row) {
+  if (entry.kind === "single") return `/cms/${name}`;
+  if (entry.kind === "page") {
+    const route = pageRouteOf(entry, String(row.id));
+    return route ? `/cms/${name}/${route.key}` : null;
+  }
+  return row.id == null ? null : `/cms/${name}/${String(row.id)}`;
+}
+function entryHits(context, name, entry, rows) {
+  const { defaultLocale } = context.i18n;
+  const hits = [];
+  for (const row of rows) {
+    const path = itemPath(name, entry, row);
+    if (!path) continue;
+    const route = entry.kind === "page" ? pageRouteOf(entry, String(row.id)) : void 0;
+    const fields = route ? pageFields(entry, route.path) : entry.fields;
+    const title = route ? route.label : titleOf(entry, row, defaultLocale);
+    for (const hit of rowHits(fields, row, context.term, defaultLocale)) {
+      hits.push({
+        type: "value",
+        collection: name,
+        entryLabel: entry.label,
+        kind: entry.kind,
+        id: entry.kind === "single" ? null : String(row.id),
+        title,
+        field: hit.field,
+        fieldLabel: hit.fieldLabel,
+        locale: hit.locale,
+        snippet: hit.snippet,
+        to: cmsSearchLink(path, {
+          field: hit.field,
+          locale: hit.locale,
+          block: hit.block
+        })
+      });
+    }
+  }
+  return hits;
+}
+async function mediaHits(context) {
+  const table = context.tables.cms_media;
+  const columns = table ? columnsOf(table) : void 0;
+  if (!table || !columns?.alt || !columns.key || !columns.folder) return [];
+  const rows = await context.db.select({ key: columns.key, alt: columns.alt, folder: columns.folder }).from(table).where(searchLikeCondition(context.dialect, columns.alt, context.pattern)).limit(CMS_SEARCH_ROWS_PER_ENTRY);
+  return rows.flatMap((row) => {
+    const snippet = row.alt ? searchSnippet(row.alt, context.term) : null;
+    if (!snippet) return [];
+    const folder = row.folder ?? "";
+    return [
+      {
+        type: "media",
+        collection: null,
+        entryLabel: "Media",
+        kind: "media",
+        id: row.key,
+        title: mediaFilename(row.key),
+        field: "alt",
+        fieldLabel: "Alt text",
+        locale: null,
+        snippet,
+        to: folder ? `/cms/media?${new URLSearchParams({ folder })}` : "/cms/media"
+      }
+    ];
+  });
+}
+export async function searchCmsValues(options) {
+  const term = normalizeSearchQuery(options.query);
+  if (term.length < CMS_SEARCH_MIN_LENGTH) return { hits: [], truncated: false };
+  const context = {
+    ...options,
+    term,
+    pattern: searchLikePattern(term.toLowerCase())
+  };
+  const hits = [];
+  let truncated = false;
+  for (const [name, entry] of Object.entries(options.config)) {
+    const table = tableOf(context, name);
+    if (!table) continue;
+    const rows = entry.kind === "page" ? await pageRows(context, name, entry, table) : await tableRows(context, entry, table);
+    if (rows.length >= CMS_SEARCH_ROWS_PER_ENTRY) truncated = true;
+    hits.push(...entryHits(context, name, entry, rows));
+  }
+  const media = await mediaHits(context);
+  if (media.length >= CMS_SEARCH_ROWS_PER_ENTRY) truncated = true;
+  hits.push(...media);
+  if (hits.length > CMS_SEARCH_VALUE_LIMIT) truncated = true;
+  return { hits: hits.slice(0, CMS_SEARCH_VALUE_LIMIT), truncated };
+}
+export async function searchCms(options) {
+  const query = normalizeSearchQuery(options.query);
+  if (query.length < CMS_SEARCH_MIN_LENGTH) return { query, hits: [], truncated: false };
+  const labels = searchCmsLabels(options.config, query);
+  const values = await searchCmsValues({ ...options, query });
+  return {
+    query,
+    hits: [...labels.hits, ...values.hits],
+    truncated: labels.truncated || values.truncated
+  };
+}

package/dist/runtime/server/utils/visibility.d.ts

@@ -0,0 +1,4 @@
+import type { SQL } from 'drizzle-orm';
+import type { AnySQLiteColumn } from 'drizzle-orm/sqlite-core';
+import type { CmsEntry } from '../../shared/index.js';
+export declare function visibilityConditions(entry: Pick<CmsEntry, 'kind' | 'drafts'>, columns: Record<string, AnySQLiteColumn>, now?: string): SQL[];

package/dist/runtime/server/utils/visibility.js

@@ -0,0 +1,12 @@
+import { eq, isNotNull, lte } from "drizzle-orm";
+import { CONTENT_PUBLISHED_AT_FIELD } from "../../shared/index.js";
+import { nowTimestamp } from "../../shared/timestamps.js";
+export function visibilityConditions(entry, columns, now = nowTimestamp()) {
+  if (!entry.drafts) return [];
+  const conditions = [];
+  if (columns.status) conditions.push(eq(columns.status, "published"));
+  const publishedAt = columns[CONTENT_PUBLISHED_AT_FIELD];
+  if (entry.kind === "content" && publishedAt)
+    conditions.push(isNotNull(publishedAt), lte(publishedAt, now));
+  return conditions;
+}

package/dist/runtime/shared/graphql-sdl.js

@@ -2,6 +2,7 @@ import {
   PAGE_PATH_FIELD,
   blockTypeName,
   blocksFieldTypeName,
+  isCollectionKind,
   isPrivateField,
   isRequiredField,
   isTranslatableField,
@@ -72,7 +73,7 @@ function entrySdl(config, name, entry) {
     if (isPrivateField(field)) continue;
     lines.push(fieldSdl(config, name, key, field));
   }
-  if (entry.kind === "collection") lines.push("  createdAt: String!");
+  if (isCollectionKind(entry)) lines.push("  createdAt: String!");
   lines.push("  updatedAt: String!");
   return `type ${typeName(name)} {
 ${lines.join("\n")}
@@ -171,6 +172,8 @@ export function renderGraphqlSdl(config) {
     );
     queryLines.push(`  ${name}ById(id: ID!, locale: String): ${gqlType}`);
     queryLines.push(`  ${name}Count(filters: ${gqlType}Filters): Int!`);
+    if (entry.kind === "content")
+      queryLines.push(`  ${name}BySlug(slug: String!, locale: String): ${gqlType}`);
   }
   return [
     ...COMMON_SDL,

package/dist/runtime/shared/index.d.ts

@@ -2,7 +2,7 @@ import type { PgTable } from 'drizzle-orm/pg-core';
 import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
 import type { CmsLayoutBlock, CmsListInput } from './layout.js';
 export type CmsTable = SQLiteTable | PgTable;
-export type FieldType = 'text' | 'richtext' | 'number' | 'boolean' | 'date' | 'email' | 'slug' | 'select' | 'json' | 'media' | 'relation' | 'blocks';
+export type FieldType = 'text' | 'richtext' | 'number' | 'boolean' | 'date' | 'datetime' | 'email' | 'slug' | 'select' | 'json' | 'media' | 'relation' | 'blocks';
 export interface CmsI18n {
     locales: string[];
     defaultLocale: string;
@@ -76,6 +76,9 @@ export interface MediaUsageGroup {
 export declare function mediaUsageGroups(usage: Record<string, MediaUsage[]>, keys: string[]): MediaUsageGroup[];
 export interface BlockConfig {
     label: string;
+    component?: string;
+    icon?: string;
+    description?: string;
     fields: Record<string, FieldConfig>;
 }
 export type ConditionValue = string | number | boolean;
@@ -129,10 +132,14 @@ export declare function isMultiSelect(field: FieldConfig): boolean;
 export declare function translatableFieldKeys(entry: EntryLike): string[];
 export declare function translatableBlockFieldKeys(block: BlockConfig): string[];
 export declare function hasTranslatableBlockFields(field: FieldConfig): boolean;
+export declare const BLOCK_HIDDEN_KEY = "hidden";
+export declare function declaresHiddenField(block: BlockConfig | undefined): boolean;
+export declare function isHiddenBlock(item: unknown): boolean;
+export declare function publicBlocks(field: FieldConfig, value: unknown): unknown;
 export declare function localizeBlock(field: FieldConfig, item: unknown, locale: string, defaultLocale: string): unknown;
 export declare function localizeBlocks(field: FieldConfig, value: unknown, locale: string, defaultLocale: string): unknown;
 export declare const CMS_GRAPHQL_BATCH_LIMIT = 20;
-export type CmsEntryKind = 'collection' | 'single' | 'page';
+export type CmsEntryKind = 'collection' | 'single' | 'page' | 'content';
 export interface CmsPageRoute {
     path: string;
     key: string;
@@ -158,10 +165,35 @@ export interface CmsEntry {
     icon?: string;
     layout?: CmsLayoutBlock[];
     list?: CmsListInput;
+    blocks?: Record<string, BlockConfig>;
+    preview?: CmsPreviewOptions;
+    declared?: CmsContentDeclared;
+}
+export interface CmsPreviewOptions {
+    component?: string;
+}
+export interface CmsContentDeclared {
+    fields: string[];
+    titleField?: unknown;
+    drafts?: unknown;
 }
 export declare const MOBILE_MEDIA_SUFFIX = "Mobile";
 export declare function mobileMediaKey(key: string): string;
 export declare function expandMobileMedia<T extends Record<string, unknown>>(config: T): T;
+export declare const CONTENT_TITLE_FIELD = "title";
+export declare const CONTENT_SLUG_FIELD = "slug";
+export declare const CONTENT_PUBLISHED_AT_FIELD = "publishedAt";
+export declare const CONTENT_BODY_FIELD = "body";
+export declare const CONTENT_SYSTEM_FIELDS: readonly ["title", "slug", "publishedAt", "excerpt", "cover", "body", "seoTitle", "seoDescription", "seoImage"];
+export type CmsContentSystemField = (typeof CONTENT_SYSTEM_FIELDS)[number];
+export declare const CONTENT_LIST_COLUMNS: string[];
+export declare function isContentEntry(entry: Pick<CmsEntry, 'kind'>): boolean;
+export declare function isCollectionKind(entry: Pick<CmsEntry, 'kind'>): boolean;
+export declare function normalizeContentEntries<T extends Record<string, unknown>>(config: T, i18n?: Pick<CmsI18n, 'locales'>): T;
+export declare function normalizeCmsConfig<T extends Record<string, unknown>>(config: T, i18n?: Pick<CmsI18n, 'locales'>): T;
+export declare function slugSourceValue(source: FieldConfig | undefined, value: unknown, defaultLocale: string): string | null;
+export declare function isScheduledContent(row: Record<string, unknown> | null | undefined, now?: Date): boolean;
+export declare function resolveBlocksMedia(field: FieldConfig, value: unknown, resolve: (key: string) => unknown): unknown;
 export declare function entryTabs(entry: Pick<CmsEntry, 'tabs'>): CmsTab[];
 export declare function fieldTab(field: FieldConfig, tabs: CmsTab[]): string | undefined;
 export declare function fieldsByTab(fields: Record<string, FieldConfig>, tabs: CmsTab[]): Record<string, Record<string, FieldConfig>>;
@@ -214,6 +246,9 @@ export interface BooleanFieldInput extends FieldInputBase {
 export interface DateFieldInput extends FieldInputBase {
     type: 'date';
 }
+export interface DateTimeFieldInput extends FieldInputBase {
+    type: 'datetime';
+}
 export interface EmailFieldInput extends FieldInputBase {
     type: 'email';
 }
@@ -243,16 +278,19 @@ export interface RelationFieldInput extends FieldInputBase {
     onDelete?: 'set null' | 'cascade' | 'restrict';
 }
 type BlockField<T> = Omit<T, 'private' | 'showIf' | 'tab'>;
-export type BlockFieldInput = BlockField<TextFieldInput> | BlockField<RichtextFieldInput> | BlockField<NumberFieldInput> | BlockField<BooleanFieldInput> | BlockField<DateFieldInput> | BlockField<EmailFieldInput> | BlockField<SelectFieldInput> | BlockField<JsonFieldInput> | Omit<BlockField<MediaFieldInput>, 'mobile'>;
+export type BlockFieldInput = BlockField<TextFieldInput> | BlockField<RichtextFieldInput> | BlockField<NumberFieldInput> | BlockField<BooleanFieldInput> | BlockField<DateFieldInput> | BlockField<DateTimeFieldInput> | BlockField<EmailFieldInput> | BlockField<SelectFieldInput> | BlockField<JsonFieldInput> | Omit<BlockField<MediaFieldInput>, 'mobile'>;
 export interface BlockInput {
     label: string;
+    component?: string;
+    icon?: string;
+    description?: string;
     fields: Record<string, BlockFieldInput>;
 }
 export interface BlocksFieldInput extends FieldInputBase {
     type: 'blocks';
     blocks: Record<string, BlockInput>;
 }
-export type CmsFieldInput = TextFieldInput | RichtextFieldInput | NumberFieldInput | BooleanFieldInput | DateFieldInput | EmailFieldInput | SlugFieldInput | SelectFieldInput | JsonFieldInput | MediaFieldInput | RelationFieldInput | BlocksFieldInput;
+export type CmsFieldInput = TextFieldInput | RichtextFieldInput | NumberFieldInput | BooleanFieldInput | DateFieldInput | DateTimeFieldInput | EmailFieldInput | SlugFieldInput | SelectFieldInput | JsonFieldInput | MediaFieldInput | RelationFieldInput | BlocksFieldInput;
 interface CmsEntryInputBase {
     id: string;
     label: string;
@@ -283,8 +321,24 @@ export interface CmsPageInput extends CmsEntryInputBase {
     overrides?: Record<string, Record<string, CmsFieldInput | null>>;
     columns?: string[];
 }
-export type CmsEntryInput = CmsCollectionInput | CmsSingleInput | CmsPageInput;
+export interface CmsContentInput {
+    id: string;
+    label: string;
+    kind: 'content';
+    icon?: string;
+    blocks: Record<string, BlockInput>;
+    fields?: Record<string, CmsFieldInput>;
+    labels?: Partial<Record<CmsContentSystemField, string>>;
+    tabs?: CmsTab[];
+    layout?: CmsLayoutBlock[];
+    list?: CmsListInput;
+    preview?: CmsPreviewOptions;
+    titleField?: never;
+    drafts?: never;
+}
+export type CmsEntryInput = CmsCollectionInput | CmsSingleInput | CmsPageInput | CmsContentInput;
 export type CmsConfigInput = Record<string, CmsEntryInput>;
 export declare function defineCmsConfig<T extends CmsConfigInput>(config: T): T;
+export declare function defineCmsBlocks<T extends Record<string, BlockInput>>(blocks: T): T;
 export * from './layout.js';
 export * from './users.js';