@xleddyl/nuxt-cms 0.9.4 → 0.10.0

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

@@ -6,8 +6,10 @@ import {
   isMultiValueField,
   isPrivateField,
   isRequiredField,
+  isRoutedContent,
   isTranslatableField,
   pageAllFields,
+  relationTarget,
   typeName
 } from "./index.js";
 export { blockTypeName, blocksFieldTypeName, typeName };
@@ -32,6 +34,7 @@ function filterScalarFor(field) {
   if (isMultiValueField(field)) return LIST_FILTER;
   switch (field.type) {
     case "json":
+    case "link":
       return null;
     case "blocks":
       return null;
@@ -54,12 +57,13 @@ function filterableKeys(entry) {
 }
 function fieldSdl(config, entryName, key, field) {
   if (field.type === "relation") {
-    const target = typeName(field.to);
+    const target = typeName(relationTarget(field));
     if (field.cardinality === "many-to-many") return `  ${key}: [${target}!]!`;
-    const nonNull = isRequiredField(field) && !config[field.to]?.drafts;
+    const nonNull = isRequiredField(field) && !config[relationTarget(field)]?.drafts;
     return `  ${key}: ${target}${nonNull ? "!" : ""}`;
   }
   if (field.type === "media") return `  ${key}: CmsMedia`;
+  if (field.type === "link") return `  ${key}: CmsLink`;
   if (field.type === "tags" || field.type === "select" && field.multiple)
     return `  ${key}: [String!]!`;
   if (field.type === "blocks")
@@ -69,6 +73,7 @@ function fieldSdl(config, entryName, key, field) {
 function entrySdl(config, name, entry) {
   const lines = ["  id: ID!"];
   if (entry.kind === "page") lines.push(`  ${PAGE_PATH_FIELD}: String!`);
+  if (isRoutedContent(entry)) lines.push("  path: String!", "  paths: [CmsLocalePath!]!");
   for (const [key, field] of Object.entries(entryFields(entry))) {
     if (isPrivateField(field)) continue;
     lines.push(fieldSdl(config, name, key, field));
@@ -79,42 +84,58 @@ function entrySdl(config, name, entry) {
 ${lines.join("\n")}
 }`;
 }
-function blockFieldSdl(field) {
-  return field.type === "media" ? "CmsMedia" : scalarFor(field);
+function blockFieldSdl(name, schemaPath, blockName, key, field) {
+  if (field.type === "media") return "CmsMedia";
+  if (field.type === "link") return "CmsLink";
+  if (field.type === "blocks")
+    return `[${blocksFieldTypeName(name, [...schemaPath, blockName, key])}!]`;
+  return scalarFor(field);
 }
-function sharedBlockFieldsSdl(field) {
-  const blocks = Object.values(field.blocks ?? {});
+function sharedBlockFieldsSdl(name, schemaPath, field) {
+  const blocks = Object.entries(field.blocks ?? {});
   const first = blocks[0];
   if (!first) return [];
   const lines = [];
-  for (const key of Object.keys(first.fields)) {
-    const rendered = blocks.map((block) => block.fields[key]);
-    if (rendered.some((blockField) => !blockField)) continue;
-    const types = rendered.map((blockField) => blockFieldSdl(blockField));
+  for (const key of Object.keys(first[1].fields)) {
+    if (blocks.some(([, block]) => !block.fields[key])) continue;
+    const types = blocks.map(
+      ([blockName, block]) => blockFieldSdl(name, schemaPath, blockName, key, block.fields[key])
+    );
     if (types.some((type) => type !== types[0])) continue;
     lines.push(`  ${key}: ${types[0]}`);
   }
   return lines;
 }
-function blocksSdl(name, key, field) {
+function blocksSdl(name, schemaPath, field) {
   const blocks = Object.entries(field.blocks ?? {});
   if (!blocks.length) return [];
-  const interfaceName = blocksFieldTypeName(name, key);
-  const shared = ["  type: String!", ...sharedBlockFieldsSdl(field)];
+  const interfaceName = blocksFieldTypeName(name, schemaPath);
+  const shared = ["  type: String!", ...sharedBlockFieldsSdl(name, schemaPath, field)];
   const defs = [`interface ${interfaceName} {
 ${shared.join("\n")}
 }`];
+  const nested = [];
   for (const [blockName, block] of blocks) {
     const lines = ["  type: String!"];
     for (const [blockFieldKey, blockField] of Object.entries(block.fields)) {
-      lines.push(`  ${blockFieldKey}: ${blockFieldSdl(blockField)}`);
+      lines.push(
+        `  ${blockFieldKey}: ${blockFieldSdl(
+          name,
+          schemaPath,
+          blockName,
+          blockFieldKey,
+          blockField
+        )}`
+      );
+      if (blockField.type === "blocks")
+        nested.push(...blocksSdl(name, [...schemaPath, blockName, blockFieldKey], blockField));
     }
-    const gqlType = blockTypeName(name, key, blockName);
+    const gqlType = blockTypeName(name, schemaPath, blockName);
     defs.push(`type ${gqlType} implements ${interfaceName} {
 ${lines.join("\n")}
 }`);
   }
-  return defs;
+  return [...defs, ...nested];
 }
 function filterSdl(name, entry) {
   const gqlType = typeName(name);
@@ -147,17 +168,22 @@ const COMMON_SDL = [
   isEmpty: Boolean
 }`,
   "enum CmsMediaType {\n  image\n  video\n  file\n}",
-  "type CmsMedia {\n  key: String!\n  url: String\n  type: CmsMediaType!\n  alt: String\n  folder: String\n  mime: String\n  size: Int\n  width: Int\n  height: Int\n}"
+  "type CmsMedia {\n  key: String!\n  url: String\n  type: CmsMediaType!\n  alt: String\n  folder: String\n  mime: String\n  size: Int\n  width: Int\n  height: Int\n  focalX: Float\n  focalY: Float\n}",
+  "type CmsLink {\n  href: String\n  label: String\n  newTab: Boolean!\n  external: Boolean!\n  entry: String\n  id: String\n}",
+  "type CmsSite {\n  name: String\n  titleTemplate: String\n  description: String\n  image: CmsMedia\n  hidden: Boolean!\n}"
 ];
+export const SITE_QUERY_FIELD = "cmsSite";
 export function renderGraphqlSdl(config) {
-  const queryLines = [];
+  const queryLines = [`  ${SITE_QUERY_FIELD}(locale: String): CmsSite!`];
   const types = [];
+  if (Object.values(config).some(isRoutedContent))
+    types.push("type CmsLocalePath {\n  locale: String!\n  path: String!\n}");
   for (const [name, entry] of Object.entries(config)) {
     const gqlType = typeName(name);
     types.push(entrySdl(config, name, entry));
     for (const [key, field] of Object.entries(entryFields(entry))) {
       if (field.type === "blocks" && !isPrivateField(field))
-        types.push(...blocksSdl(name, key, field));
+        types.push(...blocksSdl(name, [key], field));
     }
     if (entry.kind === "single") {
       queryLines.push(`  ${name}(locale: String): ${gqlType}`);
@@ -176,12 +202,10 @@ export function renderGraphqlSdl(config) {
     queryLines.push(`  ${name}Count(filters: ${gqlType}Filters): Int!`);
     if (entry.kind === "content")
       queryLines.push(`  ${name}BySlug(slug: String!, locale: String): ${gqlType}`);
+    if (isRoutedContent(entry))
+      queryLines.push(`  ${name}ByPath(path: String!, locale: String): ${gqlType}`);
   }
-  return [
-    ...COMMON_SDL,
-    ...types,
-    `type Query {
-${queryLines.length ? queryLines.join("\n") : "  _empty: Boolean"}
-}`
-  ].join("\n\n");
+  return [...COMMON_SDL, ...types, `type Query {
+${queryLines.join("\n")}
+}`].join("\n\n");
 }

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

@@ -0,0 +1,27 @@
+export declare const CMS_HISTORY_MAX = 100;
+export declare const CMS_HISTORY_DELAY = 400;
+export interface CmsHistoryStatus {
+    canUndo: boolean;
+    canRedo: boolean;
+}
+export interface CmsHistoryOptions<S = number | null> {
+    state: () => Record<string, unknown>;
+    selected: () => S;
+    restore: (state: Record<string, unknown>, selected: S) => void;
+    omit?: readonly string[];
+    max?: number;
+    delay?: number;
+    onUpdate?: (status: CmsHistoryStatus) => void;
+}
+export declare function createCmsHistory<S = number | null>(options: CmsHistoryOptions<S>): {
+    change: (key?: string, hold?: boolean) => void;
+    release: () => void;
+    observe: () => void;
+    undo: () => boolean;
+    redo: () => boolean;
+    reset: () => void;
+    flush: () => void;
+    dispose: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+};

package/dist/runtime/shared/history.js

@@ -0,0 +1,123 @@
+export const CMS_HISTORY_MAX = 100;
+export const CMS_HISTORY_DELAY = 400;
+export function createCmsHistory(options) {
+  const max = options.max ?? CMS_HISTORY_MAX;
+  const delay = options.delay ?? CMS_HISTORY_DELAY;
+  const omitted = new Set(options.omit ?? []);
+  const status = { canUndo: false, canRedo: false };
+  let entries = [];
+  let index = 0;
+  let intent = null;
+  let timer;
+  function serialize() {
+    const state = options.state();
+    return JSON.stringify(
+      Object.fromEntries(Object.entries(state).filter(([key]) => !omitted.has(key)))
+    );
+  }
+  function refresh() {
+    const pending = !!intent && serialize() !== entries[index].json;
+    const canUndo = index > 0 || pending;
+    const canRedo = !pending && index < entries.length - 1;
+    if (canUndo === status.canUndo && canRedo === status.canRedo) return;
+    status.canUndo = canUndo;
+    status.canRedo = canRedo;
+    options.onUpdate?.({ ...status });
+  }
+  function clearTimer() {
+    if (timer === void 0) return;
+    clearTimeout(timer);
+    timer = void 0;
+  }
+  function reset() {
+    clearTimer();
+    intent = null;
+    const selected = options.selected();
+    entries = [{ json: serialize(), selected, before: selected }];
+    index = 0;
+    refresh();
+  }
+  function flush() {
+    clearTimer();
+    const current = intent;
+    intent = null;
+    if (!current) return;
+    const json = serialize();
+    if (json !== entries[index].json) {
+      entries = entries.slice(0, index + 1);
+      entries.push({ json, selected: options.selected(), before: current.before });
+      if (entries.length > max + 1) entries = entries.slice(entries.length - max - 1);
+      index = entries.length - 1;
+    }
+    refresh();
+  }
+  function change(key, hold = false) {
+    const coalesce = key ?? null;
+    if (intent && (coalesce === null || intent.key !== coalesce)) flush();
+    if (!intent) intent = { key: coalesce, before: options.selected(), held: false };
+    if (hold && coalesce !== null) {
+      intent.held = true;
+      clearTimer();
+    }
+  }
+  function release() {
+    if (intent?.held) flush();
+  }
+  function observe() {
+    const json = serialize();
+    const entry = entries[index];
+    if (json === entry.json) {
+      if (intent && timer === void 0 && !intent.held) intent = null;
+      refresh();
+      return;
+    }
+    if (!intent) {
+      entry.json = json;
+      return;
+    }
+    if (intent.key === null) {
+      flush();
+      return;
+    }
+    if (intent.held) {
+      refresh();
+      return;
+    }
+    clearTimer();
+    timer = setTimeout(flush, delay);
+    refresh();
+  }
+  function apply(entry, selected) {
+    const values = JSON.parse(entry.json);
+    options.restore({ ...options.state(), ...values }, selected);
+    refresh();
+  }
+  function undo() {
+    flush();
+    if (index === 0) return false;
+    const from = entries[index];
+    index--;
+    apply(entries[index], from.before);
+    return true;
+  }
+  function redo() {
+    flush();
+    if (index >= entries.length - 1) return false;
+    index++;
+    apply(entries[index], entries[index].selected);
+    return true;
+  }
+  reset();
+  return {
+    change,
+    release,
+    observe,
+    undo,
+    redo,
+    reset,
+    flush,
+    dispose: clearTimer,
+    canUndo: () => status.canUndo,
+    canRedo: () => status.canRedo
+  };
+}

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

@@ -0,0 +1,45 @@
+import type { H3Event } from 'h3';
+import type { CmsEntryKind } from './index.js';
+import type { CmsUserRole } from './users.js';
+export declare const CMS_ENTRY_CHANGE_HOOK = "cms:entry:change";
+export declare const CMS_MEDIA_CHANGE_HOOK = "cms:media:change";
+export declare const CMS_ENTRY_ACTIONS: readonly ["create", "update", "delete", "publish", "unpublish", "import"];
+export declare const CMS_MEDIA_ACTIONS: readonly ["upload", "update", "move", "delete", "folder-create", "folder-rename", "folder-delete"];
+export type CmsEntryAction = (typeof CMS_ENTRY_ACTIONS)[number];
+export type CmsMediaAction = (typeof CMS_MEDIA_ACTIONS)[number];
+export type CmsEntryStatus = 'draft' | 'published';
+export interface CmsHookUser {
+    id: string | null;
+    email: string;
+    name: string | null;
+    role: CmsUserRole;
+}
+export interface CmsEntryChange {
+    entry: string;
+    kind: CmsEntryKind;
+    action: CmsEntryAction;
+    ids: string[];
+    path: string | null;
+    status: CmsEntryStatus | null;
+    item: Record<string, unknown> | null;
+    user: CmsHookUser;
+    at: string;
+}
+export interface CmsMediaChange {
+    action: CmsMediaAction;
+    keys: string[];
+    folder: string | null;
+    from: string | null;
+    user: CmsHookUser;
+    at: string;
+}
+export interface CmsHookContext {
+    event: H3Event;
+}
+export interface CmsRuntimeHooks {
+    [CMS_ENTRY_CHANGE_HOOK]: (change: CmsEntryChange, context: CmsHookContext) => void | Promise<void>;
+    [CMS_MEDIA_CHANGE_HOOK]: (change: CmsMediaChange, context: CmsHookContext) => void | Promise<void>;
+}
+export type CmsHookName = keyof CmsRuntimeHooks;
+export declare function entryStatus(value: unknown): CmsEntryStatus | null;
+export declare function entryWriteAction(created: boolean, previous: CmsEntryStatus | null, next: CmsEntryStatus | null): CmsEntryAction;

package/dist/runtime/shared/hooks.js

@@ -0,0 +1,28 @@
+export const CMS_ENTRY_CHANGE_HOOK = "cms:entry:change";
+export const CMS_MEDIA_CHANGE_HOOK = "cms:media:change";
+export const CMS_ENTRY_ACTIONS = [
+  "create",
+  "update",
+  "delete",
+  "publish",
+  "unpublish",
+  "import"
+];
+export const CMS_MEDIA_ACTIONS = [
+  "upload",
+  "update",
+  "move",
+  "delete",
+  "folder-create",
+  "folder-rename",
+  "folder-delete"
+];
+export function entryStatus(value) {
+  return value === "draft" || value === "published" ? value : null;
+}
+export function entryWriteAction(created, previous, next) {
+  if (created) return "create";
+  if (previous !== "published" && next === "published") return "publish";
+  if (previous === "published" && next === "draft") return "unpublish";
+  return "update";
+}

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

@@ -1,8 +1,10 @@
 import type { PgTable } from 'drizzle-orm/pg-core';
 import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { CmsShowIf } from './conditions.js';
+import type { CmsContentRoute } from './content-routes.js';
 import type { CmsLayoutBlock, CmsListInput } from './layout.js';
 export type CmsTable = SQLiteTable | PgTable;
-export type FieldType = 'text' | 'richtext' | 'number' | 'boolean' | 'date' | 'datetime' | 'email' | 'slug' | 'select' | 'tags' | 'json' | 'media' | 'relation' | 'blocks';
+export type FieldType = 'text' | 'richtext' | 'number' | 'boolean' | 'date' | 'datetime' | 'email' | 'slug' | 'select' | 'tags' | 'json' | 'media' | 'relation' | 'link' | 'blocks';
 export interface CmsI18n {
     locales: string[];
     defaultLocale: string;
@@ -42,6 +44,8 @@ export interface MediaItem {
     size: number | null;
     width: number | null;
     height: number | null;
+    focalX: number | null;
+    focalY: number | null;
     createdAt: string | null;
     type: MediaType;
     url: string | null;
@@ -52,10 +56,11 @@ export interface MediaSourceInfo {
     root: string;
     builtAt: string | null;
 }
+export type MediaUsageKind = CmsEntryKind | 'site';
 export interface MediaUsage {
     collection: string;
     label: string;
-    kind: CmsEntryKind;
+    kind: MediaUsageKind;
     id: string | null;
     title: string | null;
     field: string;
@@ -63,23 +68,32 @@ export interface MediaUsage {
 export interface MediaUsageEntry {
     collection: string;
     label: string;
-    kind: CmsEntryKind;
+    kind: MediaUsageKind;
     id: string | null;
     title: string | null;
     fields: string[];
 }
 export declare function groupMediaUsage(usage: MediaUsage[]): MediaUsageEntry[];
+export interface MediaUsageReport {
+    usage: Record<string, MediaUsage[]>;
+    hidden: Record<string, number>;
+}
 export interface MediaUsageGroup {
     key: string;
     entries: MediaUsageEntry[];
+    hidden: number;
 }
-export declare function mediaUsageGroups(usage: Record<string, MediaUsage[]>, keys: string[]): MediaUsageGroup[];
+export declare function mediaUsageGroups(usage: Record<string, MediaUsage[]>, keys: string[], hidden?: Record<string, number>): MediaUsageGroup[];
+export declare function otherEntriesLabel(count: number): string;
 export interface BlockConfig {
     label: string;
     component?: string;
     icon?: string;
     description?: string;
+    group?: string;
+    tags?: readonly string[];
     fields: Record<string, FieldConfig>;
+    layout?: CmsLayoutBlock[];
     validate?: CmsBlockValidate;
 }
 export type CmsValidationLevel = 'error' | 'warning';
@@ -95,6 +109,7 @@ export interface CmsValidateContext {
 }
 export interface CmsBlockValidateContext extends CmsValidateContext {
     index: number;
+    blockPath: string;
 }
 export type CmsValidateResult = readonly CmsValidationIssue[] | null | undefined | void;
 export type CmsValidate = (values: Record<string, unknown>, context: CmsValidateContext) => CmsValidateResult;
@@ -118,12 +133,6 @@ export declare function selectOptionValues(field: Pick<FieldConfig, 'options'>):
 export declare function selectOptionLabel(field: Pick<FieldConfig, 'options'>, value: unknown): string;
 export declare function selectValuesMatching(field: Pick<FieldConfig, 'options'>, term: string): string[];
 export declare function selectDisplayValue(field: Pick<FieldConfig, 'options'>, value: unknown): string;
-export type ConditionValue = string | number | boolean;
-export interface FieldCondition {
-    field: string;
-    eq?: ConditionValue;
-    in?: ConditionValue[];
-}
 export interface CmsTab {
     id: string;
     label: string;
@@ -136,6 +145,9 @@ export interface FieldConfig {
     tab?: string;
     required?: boolean;
     private?: boolean;
+    default?: unknown;
+    unique?: boolean;
+    immutable?: boolean;
     textarea?: boolean;
     integer?: boolean;
     translatable?: boolean;
@@ -150,16 +162,18 @@ export interface FieldConfig {
     accept?: string[];
     mobile?: boolean;
     mobileOf?: string;
-    to?: string;
+    to?: string | readonly string[];
+    external?: boolean;
+    withLabel?: boolean;
     cardinality?: 'many-to-one' | 'one-to-one' | 'many-to-many';
     onDelete?: 'set null' | 'cascade' | 'restrict';
-    showIf?: FieldCondition | FieldCondition[];
+    showIf?: CmsShowIf;
 }
+export declare function relationTarget(field: Pick<FieldConfig, 'to'>): string;
 export declare function isPrivateField(field: FieldConfig): boolean;
 export declare function isRequiredField(field: FieldConfig): boolean;
-export declare function fieldConditions(field: FieldConfig): FieldCondition[];
-export declare function isFieldVisible(field: FieldConfig, values: Record<string, unknown> | null | undefined): boolean;
 export declare function isTranslatableField(field: FieldConfig): boolean;
+export declare function isLocalizedLinkField(field: FieldConfig): boolean;
 export declare function isTranslatableMediaField(field: FieldConfig): boolean;
 export declare function defaultLocaleValue(value: unknown, defaultLocale: string): string | null;
 export declare function decodeTranslatableValue(value: unknown, defaultLocale: string): Record<string, string> | null;
@@ -215,6 +229,7 @@ export interface CmsEntry {
     list?: CmsListInput;
     blocks?: Record<string, BlockConfig>;
     preview?: CmsPreviewOptions;
+    route?: CmsContentRoute;
     declared?: CmsContentDeclared;
     validate?: CmsValidate;
 }
@@ -233,12 +248,14 @@ 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 declare const CONTENT_SYSTEM_FIELDS: readonly ["title", "slug", "publishedAt", "excerpt", "cover", "body", "seoTitle", "seoDescription", "seoImage", "seoNoindex"];
+export declare const CONTENT_NOINDEX_FIELD = "seoNoindex";
 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 boundBlockNesting<T extends Record<string, unknown>>(config: T): 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;
@@ -265,8 +282,9 @@ export declare function pageMediaTableName(name: string): string;
 type EntryLike = Pick<CmsEntry, 'fields'> & Partial<Pick<CmsEntry, 'kind' | 'overrides'>>;
 export declare function entryFieldsFor(entry: EntryLike, path?: string): Record<string, FieldConfig>;
 export declare function typeName(name: string): string;
-export declare function blocksFieldTypeName(entryName: string, fieldKey: string): string;
-export declare function blockTypeName(entryName: string, fieldKey: string, blockName: string): string;
+export declare function blocksTypePrefix(entryName: string, schemaPath: string | readonly string[]): string;
+export declare function blocksFieldTypeName(entryName: string, schemaPath: string | readonly string[]): string;
+export declare function blockTypeName(entryName: string, schemaPath: string | readonly string[], blockName: string): string;
 interface FieldInputBase {
     label: string;
     description?: string;
@@ -274,46 +292,70 @@ interface FieldInputBase {
     required?: boolean;
     private?: boolean;
     tab?: string;
-    showIf?: FieldCondition | FieldCondition[];
+    showIf?: CmsShowIf;
 }
 export interface TextFieldInput extends FieldInputBase {
     type: 'text';
     textarea?: boolean;
     translatable?: boolean;
+    default?: string;
+    min?: number;
+    max?: number;
+    unique?: boolean;
+    immutable?: boolean;
 }
 export interface RichtextFieldInput extends FieldInputBase {
     type: 'richtext';
     translatable?: boolean;
+    default?: string;
 }
 export interface NumberFieldInput extends FieldInputBase {
     type: 'number';
     integer?: boolean;
+    default?: number;
+    min?: number;
+    max?: number;
+    unique?: boolean;
+    immutable?: boolean;
 }
 export interface BooleanFieldInput extends FieldInputBase {
     type: 'boolean';
+    default?: boolean;
+    immutable?: boolean;
 }
 export interface DateFieldInput extends FieldInputBase {
     type: 'date';
+    default?: 'today' | (string & {});
+    immutable?: boolean;
 }
 export interface DateTimeFieldInput extends FieldInputBase {
     type: 'datetime';
+    default?: 'now' | (string & {});
+    immutable?: boolean;
 }
 export interface EmailFieldInput extends FieldInputBase {
     type: 'email';
+    default?: string;
+    unique?: boolean;
+    immutable?: boolean;
 }
 export interface SlugFieldInput extends FieldInputBase {
     type: 'slug';
     from: string;
+    immutable?: boolean;
 }
 export interface SelectFieldInput extends FieldInputBase {
     type: 'select';
     options: readonly SelectOptionInput[];
     multiple?: boolean;
+    default?: string | readonly string[];
+    immutable?: boolean;
 }
 export interface TagsFieldInput extends FieldInputBase {
     type: 'tags';
     max?: number;
     suggestions?: boolean;
+    default?: readonly string[];
 }
 export interface JsonFieldInput extends FieldInputBase {
     type: 'json';
@@ -330,15 +372,32 @@ export interface RelationFieldInput extends FieldInputBase {
     to: string;
     cardinality?: 'many-to-one' | 'one-to-one' | 'many-to-many';
     onDelete?: 'set null' | 'cascade' | 'restrict';
+    immutable?: boolean;
+}
+export interface LinkFieldInput extends FieldInputBase {
+    type: 'link';
+    to?: readonly string[];
+    external?: boolean;
+    withLabel?: boolean;
+    translatable?: boolean;
 }
-type BlockField<T> = Omit<T, 'private' | 'showIf' | 'tab'>;
-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'>;
+type BlockField<T> = Omit<T, 'private' | 'tab' | 'default' | 'unique' | 'immutable'>;
+export interface NestedBlocksFieldInput extends Omit<FieldInputBase, 'private' | 'tab'> {
+    type: 'blocks';
+    blocks: Record<string, BlockInput>;
+    min?: number;
+    max?: number;
+}
+export type BlockFieldInput = BlockField<TextFieldInput> | BlockField<RichtextFieldInput> | BlockField<NumberFieldInput> | BlockField<BooleanFieldInput> | BlockField<DateFieldInput> | BlockField<DateTimeFieldInput> | BlockField<EmailFieldInput> | BlockField<SelectFieldInput> | BlockField<JsonFieldInput> | BlockField<LinkFieldInput> | Omit<BlockField<MediaFieldInput>, 'mobile'> | NestedBlocksFieldInput;
 export interface BlockInput {
     label: string;
     component?: string;
     icon?: string;
     description?: string;
+    group?: string;
+    tags?: readonly string[];
     fields: Record<string, BlockFieldInput>;
+    layout?: CmsLayoutBlock[];
     validate?: CmsBlockValidate;
 }
 export interface BlocksFieldInput extends FieldInputBase {
@@ -347,7 +406,7 @@ export interface BlocksFieldInput extends FieldInputBase {
     min?: number;
     max?: number;
 }
-export type CmsFieldInput = TextFieldInput | RichtextFieldInput | NumberFieldInput | BooleanFieldInput | DateFieldInput | DateTimeFieldInput | EmailFieldInput | SlugFieldInput | SelectFieldInput | TagsFieldInput | JsonFieldInput | MediaFieldInput | RelationFieldInput | BlocksFieldInput;
+export type CmsFieldInput = TextFieldInput | RichtextFieldInput | NumberFieldInput | BooleanFieldInput | DateFieldInput | DateTimeFieldInput | EmailFieldInput | SlugFieldInput | SelectFieldInput | TagsFieldInput | JsonFieldInput | MediaFieldInput | RelationFieldInput | LinkFieldInput | BlocksFieldInput;
 interface CmsEntryInputBase {
     id: string;
     label: string;
@@ -391,6 +450,7 @@ export interface CmsContentInput {
     layout?: CmsLayoutBlock[];
     list?: CmsListInput;
     preview?: CmsPreviewOptions;
+    route?: string | Readonly<Record<string, string>>;
     validate?: CmsValidate;
     titleField?: never;
     drafts?: never;
@@ -399,5 +459,14 @@ export type CmsEntryInput = CmsCollectionInput | CmsSingleInput | CmsPageInput |
 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 './block-paths.js';
+export * from './conditions.js';
+export * from './content-routes.js';
+export * from './seo.js';
+export * from './redirects.js';
 export * from './layout.js';
+export * from './media-focal.js';
 export * from './users.js';
+export * from './preview-links.js';
+export * from './links.js';
+export type { CmsAccess, CmsRole, CmsRoleInput, CmsRoleOption, CmsRoles, CmsRolesInput, } from './roles.js';