@shapio/schema 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,1082 @@
+import { a as isEmptyRichText, i as RichTextResult, n as RichTextNode, o as richTextMediaIds, r as RichTextProblem, s as validateRichText, t as RichTextDocument } from "./validate-Oyo0GJ9j.js";
+import { Static, TSchema, Type } from "typebox";
+//#region src/ids.d.ts
+/**
+ * Stable IDs for models, components and fields: random UUIDs (v4).
+ *
+ * Why UUID rather than ULID: PostgreSQL stores and indexes `uuid` natively (16 bytes) for the system
+ * tables that key on model IDs; `crypto.randomUUID()` exists in Node and every browser, so the admin can
+ * create field IDs client-side with no dependency; and nothing in Shapio needs IDs to sort by creation time
+ * (revisions carry their own version numbers and timestamps). IDs are compared case-insensitively nowhere:
+ * they are always lower-case as generated.
+ */
+export declare const STABLE_ID_PATTERN: RegExp;
+export declare const isStableId: (value: unknown) => value is string;
+export declare const createStableId: () => string;
+//#endregion
+//#region src/types/dataTypes.d.ts
+/** Every stored data type. A field's data type is separate from the editor that renders it (brief §2.5). */
+export declare const DATA_TYPES: readonly ["string", "text", "richtext", "number", "integer", "decimal", "biginteger", "boolean", "date", "datetime", "time", "enum", "json", "slug", "email", "url", "uid", "media", "relation", "component", "dynamiczone"];
+export type DataType = (typeof DATA_TYPES)[number];
+export declare const isDataType: (value: unknown) => value is DataType;
+/**
+ * Scalar types stored as one JSON value per field (string, number or boolean). Only these can be unique,
+ * filterable or sortable: their index expression is a single cast of `data ->> fieldId` (ADR 0001).
+ */
+export declare const SCALAR_DATA_TYPES: ReadonlySet<DataType>;
+/** Types that may carry `unique: true` (boolean and long text make no sense as unique keys). */
+export declare const UNIQUE_CAPABLE_DATA_TYPES: ReadonlySet<DataType>;
+/** Types whose values point at other definitions; the reference checks look at these. */
+export declare const REFERENCE_DATA_TYPES: ReadonlySet<DataType>;
+/**
+ * How a value is physically represented in the content JSON. Changing a field's type within a storage
+ * family never needs a data conversion, only a validity check; across families it is a conversion.
+ */
+export type StorageFamily = 'jsonString' | 'jsonNumber' | 'numericString' | 'boolean' | 'json' | 'richtext' | 'media' | 'relation' | 'component' | 'dynamiczone';
+export declare const STORAGE_FAMILY: Readonly<Record<DataType, StorageFamily>>;
+//#endregion
+//#region src/types/json.d.ts
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+export type JsonObject = {
+  [key: string]: JsonValue;
+};
+//#endregion
+//#region src/types/settings.d.ts
+export declare const MEDIA_KINDS: readonly ["image", "video", "audio", "document", "other"];
+export declare const RELATION_CARDINALITIES: readonly ["one", "many"];
+export declare const EnumValueSchema: Type.TObject<{
+  value: Type.TString;
+  label: Type.TString;
+}>;
+export declare const SETTINGS_SCHEMAS: {
+  string: Type.TObject<{
+    pattern: Type.TOptional<Type.TString>;
+    minLength: Type.TOptional<Type.TInteger>;
+    maxLength: Type.TOptional<Type.TInteger>;
+  }>;
+  text: Type.TObject<{
+    minLength: Type.TOptional<Type.TInteger>;
+    maxLength: Type.TOptional<Type.TInteger>;
+  }>;
+  richtext: Type.TObject<{
+    formatVersion: Type.TOptional<Type.TInteger>;
+    maxLength: Type.TOptional<Type.TInteger>;
+  }>;
+  number: Type.TObject<{
+    min: Type.TOptional<Type.TNumber>;
+    max: Type.TOptional<Type.TNumber>;
+  }>;
+  integer: Type.TObject<{
+    min: Type.TOptional<Type.TInteger>;
+    max: Type.TOptional<Type.TInteger>;
+  }>;
+  decimal: Type.TObject<{
+    precision: Type.TOptional<Type.TInteger>;
+    scale: Type.TOptional<Type.TInteger>;
+    min: Type.TOptional<Type.TString>;
+    max: Type.TOptional<Type.TString>;
+  }>;
+  biginteger: Type.TObject<{
+    min: Type.TOptional<Type.TString>;
+    max: Type.TOptional<Type.TString>;
+  }>;
+  boolean: Type.TObject<{}>;
+  date: Type.TObject<{
+    min: Type.TOptional<Type.TString>;
+    max: Type.TOptional<Type.TString>;
+  }>;
+  datetime: Type.TObject<{
+    min: Type.TOptional<Type.TString>;
+    max: Type.TOptional<Type.TString>;
+  }>;
+  time: Type.TObject<{
+    min: Type.TOptional<Type.TString>;
+    max: Type.TOptional<Type.TString>;
+  }>;
+  enum: Type.TObject<{
+    values: Type.TArray<Type.TObject<{
+      value: Type.TString;
+      label: Type.TString;
+    }>>;
+    multiple: Type.TOptional<Type.TBoolean>;
+  }>;
+  json: Type.TObject<{}>;
+  slug: Type.TObject<{
+    sourceFieldId: Type.TOptional<Type.TString>;
+    minLength: Type.TOptional<Type.TInteger>;
+    maxLength: Type.TOptional<Type.TInteger>;
+  }>;
+  email: Type.TObject<{}>;
+  url: Type.TObject<{
+    protocols: Type.TOptional<Type.TArray<Type.TEnum<["http", "https", "mailto", "tel"]>>>;
+  }>;
+  uid: Type.TObject<{
+    minLength: Type.TOptional<Type.TInteger>;
+    maxLength: Type.TOptional<Type.TInteger>;
+  }>;
+  media: Type.TObject<{
+    min: Type.TOptional<Type.TInteger>;
+    max: Type.TOptional<Type.TInteger>;
+    multiple: Type.TOptional<Type.TBoolean>;
+    allowedKinds: Type.TOptional<Type.TArray<Type.TEnum<["image", "video", "audio", "document", "other"]>>>;
+  }>;
+  relation: Type.TObject<{
+    min: Type.TOptional<Type.TInteger>;
+    max: Type.TOptional<Type.TInteger>;
+    target: Type.TString;
+    cardinality: Type.TEnum<["one", "many"]>;
+  }>;
+  component: Type.TObject<{
+    min: Type.TOptional<Type.TInteger>;
+    max: Type.TOptional<Type.TInteger>;
+    component: Type.TString;
+    repeatable: Type.TOptional<Type.TBoolean>;
+  }>;
+  dynamiczone: Type.TObject<{
+    min: Type.TOptional<Type.TInteger>;
+    max: Type.TOptional<Type.TInteger>;
+    components: Type.TArray<Type.TString>;
+  }>;
+};
+type SettingsSchemas = typeof SETTINGS_SCHEMAS;
+/** Settings as authored (defaults may be missing). */
+export type DataTypeSettingsInput = { [T in DataType]: Static<SettingsSchemas[T]>; };
+/** Settings after normalization: the defaulted keys are always present. */
+export type DataTypeSettings = Omit<DataTypeSettingsInput, 'richtext' | 'enum' | 'media' | 'component'> & {
+  richtext: DataTypeSettingsInput['richtext'] & {
+    formatVersion: number;
+  };
+  enum: DataTypeSettingsInput['enum'] & {
+    multiple: boolean;
+  };
+  media: DataTypeSettingsInput['media'] & {
+    multiple: boolean;
+  };
+  component: DataTypeSettingsInput['component'] & {
+    repeatable: boolean;
+  };
+};
+//#endregion
+//#region src/types/definitions.d.ts
+export declare const MODEL_KINDS: readonly ["collection", "singleton"];
+export type ModelKind = (typeof MODEL_KINDS)[number];
+export declare const DEFINITION_KINDS: readonly ["collection", "singleton", "component"];
+export type DefinitionKind = (typeof DEFINITION_KINDS)[number];
+export declare const SORT_DIRECTIONS: readonly ["asc", "desc"];
+export type SortDirection = (typeof SORT_DIRECTIONS)[number];
+export declare const MAX_FIELDS_PER_DEFINITION = 500;
+export declare const MAX_LABEL_LENGTH = 200;
+export declare const MAX_DESCRIPTION_LENGTH = 2000;
+export declare const EditorChoiceInputSchema: Type.TObject<{
+  id: Type.TString;
+  options: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+}>;
+export declare const FieldInputSchema: Type.TObject<{
+  id: Type.TOptional<Type.TString>;
+  apiKey: Type.TString;
+  label: Type.TString;
+  /** Help text shown under the control. */
+  description: Type.TOptional<Type.TString>;
+  type: Type.TEnum<["string", "text", "richtext", "number", "integer", "decimal", "biginteger", "boolean", "date", "datetime", "time", "enum", "json", "slug", "email", "url", "uid", "media", "relation", "component", "dynamiczone"]>;
+  required: Type.TOptional<Type.TBoolean>;
+  /** Per-locale value. Ignored (must be false) when the model is not localized. */
+  localized: Type.TOptional<Type.TBoolean>;
+  /** Readable by delivery principals wherever the model is readable (ADR 0005). Default true. */
+  public: Type.TOptional<Type.TBoolean>;
+  unique: Type.TOptional<Type.TBoolean>;
+  filterable: Type.TOptional<Type.TBoolean>;
+  sortable: Type.TOptional<Type.TBoolean>;
+  /** Hidden from editors and the API; stored values are preserved until an explicit cleanup. */
+  deprecated: Type.TOptional<Type.TBoolean>;
+  /** Used for new entries and to backfill existing ones when the field becomes required. */
+  defaultValue: Type.TOptional<Type.TUnknown>;
+  /** Type-specific settings, validated against SETTINGS_SCHEMAS[type]. */
+  settings: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+  editor: Type.TOptional<Type.TObject<{
+    id: Type.TString;
+    options: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+  }>>;
+}>;
+export declare const ModelDisplayInputSchema: Type.TObject<{
+  /** Field whose value labels an entry in lists, pickers and relation summaries. */
+  titleFieldId: Type.TOptional<Type.TString>;
+  /** Columns of the content list, in order. */
+  listFieldIds: Type.TOptional<Type.TArray<Type.TString>>;
+  defaultSort: Type.TOptional<Type.TObject<{
+    fieldId: Type.TString;
+    direction: Type.TEnum<["asc", "desc"]>;
+  }>>;
+  /** Editor layout: named sections of the entry form. */
+  groups: Type.TOptional<Type.TArray<Type.TObject<{
+    id: Type.TString;
+    label: Type.TString;
+    fieldIds: Type.TArray<Type.TString>;
+  }>>>;
+  /** Fields rendered as blocks in the entry document's canvas, in order. Default: see `effectiveLayout`. */
+  canvasFieldIds: Type.TOptional<Type.TArray<Type.TString>>;
+  /** A single image `media` field shown as the cover above the title. Default: see `effectiveLayout`. */
+  coverFieldId: Type.TOptional<Type.TString>;
+  /** Properties shown as chips in the document's strip. Default: the first non-empty ones. */
+  stripFieldIds: Type.TOptional<Type.TArray<Type.TString>>;
+}>;
+export declare const ComponentDisplayInputSchema: Type.TObject<{
+  titleFieldId: Type.TOptional<Type.TString>;
+  groups: Type.TOptional<Type.TArray<Type.TObject<{
+    id: Type.TString;
+    label: Type.TString;
+    fieldIds: Type.TArray<Type.TString>;
+  }>>>;
+}>;
+export declare const ModelDefinitionInputSchema: Type.TObject<{
+  kind: Type.TEnum<["collection", "singleton"]>;
+  /**
+   * Collections only: names the list route and query (`/api/content/articles`, `articles(…)`). Optional
+   * here so files written before plural API IDs still parse; normalizing fills it on a collection.
+   */
+  pluralApiKey: Type.TOptional<Type.TString>;
+  localized: Type.TOptional<Type.TBoolean>;
+  /** Entries have separate draft and published states. Default true. */
+  draftAndPublish: Type.TOptional<Type.TBoolean>;
+  display: Type.TOptional<Type.TObject<{
+    /** Field whose value labels an entry in lists, pickers and relation summaries. */
+    titleFieldId: Type.TOptional<Type.TString>;
+    /** Columns of the content list, in order. */
+    listFieldIds: Type.TOptional<Type.TArray<Type.TString>>;
+    defaultSort: Type.TOptional<Type.TObject<{
+      fieldId: Type.TString;
+      direction: Type.TEnum<["asc", "desc"]>;
+    }>>;
+    /** Editor layout: named sections of the entry form. */
+    groups: Type.TOptional<Type.TArray<Type.TObject<{
+      id: Type.TString;
+      label: Type.TString;
+      fieldIds: Type.TArray<Type.TString>;
+    }>>>;
+    /** Fields rendered as blocks in the entry document's canvas, in order. Default: see `effectiveLayout`. */
+    canvasFieldIds: Type.TOptional<Type.TArray<Type.TString>>;
+    /** A single image `media` field shown as the cover above the title. Default: see `effectiveLayout`. */
+    coverFieldId: Type.TOptional<Type.TString>;
+    /** Properties shown as chips in the document's strip. Default: the first non-empty ones. */
+    stripFieldIds: Type.TOptional<Type.TArray<Type.TString>>;
+  }>>;
+  id: Type.TOptional<Type.TString>;
+  apiKey: Type.TString;
+  label: Type.TString;
+  description: Type.TOptional<Type.TString>;
+  fields: Type.TArray<Type.TObject<{
+    id: Type.TOptional<Type.TString>;
+    apiKey: Type.TString;
+    label: Type.TString;
+    /** Help text shown under the control. */
+    description: Type.TOptional<Type.TString>;
+    type: Type.TEnum<["string", "text", "richtext", "number", "integer", "decimal", "biginteger", "boolean", "date", "datetime", "time", "enum", "json", "slug", "email", "url", "uid", "media", "relation", "component", "dynamiczone"]>;
+    required: Type.TOptional<Type.TBoolean>;
+    /** Per-locale value. Ignored (must be false) when the model is not localized. */
+    localized: Type.TOptional<Type.TBoolean>;
+    /** Readable by delivery principals wherever the model is readable (ADR 0005). Default true. */
+    public: Type.TOptional<Type.TBoolean>;
+    unique: Type.TOptional<Type.TBoolean>;
+    filterable: Type.TOptional<Type.TBoolean>;
+    sortable: Type.TOptional<Type.TBoolean>;
+    /** Hidden from editors and the API; stored values are preserved until an explicit cleanup. */
+    deprecated: Type.TOptional<Type.TBoolean>;
+    /** Used for new entries and to backfill existing ones when the field becomes required. */
+    defaultValue: Type.TOptional<Type.TUnknown>;
+    /** Type-specific settings, validated against SETTINGS_SCHEMAS[type]. */
+    settings: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    editor: Type.TOptional<Type.TObject<{
+      id: Type.TString;
+      options: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    }>>;
+  }>>;
+}>;
+export declare const ComponentDefinitionInputSchema: Type.TObject<{
+  kind: Type.TLiteral<"component">;
+  category: Type.TOptional<Type.TString>;
+  icon: Type.TOptional<Type.TString>;
+  display: Type.TOptional<Type.TObject<{
+    titleFieldId: Type.TOptional<Type.TString>;
+    groups: Type.TOptional<Type.TArray<Type.TObject<{
+      id: Type.TString;
+      label: Type.TString;
+      fieldIds: Type.TArray<Type.TString>;
+    }>>>;
+  }>>;
+  id: Type.TOptional<Type.TString>;
+  apiKey: Type.TString;
+  label: Type.TString;
+  description: Type.TOptional<Type.TString>;
+  fields: Type.TArray<Type.TObject<{
+    id: Type.TOptional<Type.TString>;
+    apiKey: Type.TString;
+    label: Type.TString;
+    /** Help text shown under the control. */
+    description: Type.TOptional<Type.TString>;
+    type: Type.TEnum<["string", "text", "richtext", "number", "integer", "decimal", "biginteger", "boolean", "date", "datetime", "time", "enum", "json", "slug", "email", "url", "uid", "media", "relation", "component", "dynamiczone"]>;
+    required: Type.TOptional<Type.TBoolean>;
+    /** Per-locale value. Ignored (must be false) when the model is not localized. */
+    localized: Type.TOptional<Type.TBoolean>;
+    /** Readable by delivery principals wherever the model is readable (ADR 0005). Default true. */
+    public: Type.TOptional<Type.TBoolean>;
+    unique: Type.TOptional<Type.TBoolean>;
+    filterable: Type.TOptional<Type.TBoolean>;
+    sortable: Type.TOptional<Type.TBoolean>;
+    /** Hidden from editors and the API; stored values are preserved until an explicit cleanup. */
+    deprecated: Type.TOptional<Type.TBoolean>;
+    /** Used for new entries and to backfill existing ones when the field becomes required. */
+    defaultValue: Type.TOptional<Type.TUnknown>;
+    /** Type-specific settings, validated against SETTINGS_SCHEMAS[type]. */
+    settings: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    editor: Type.TOptional<Type.TObject<{
+      id: Type.TString;
+      options: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    }>>;
+  }>>;
+}>;
+export declare const DefinitionInputSchema: Type.TUnion<[Type.TObject<{
+  kind: Type.TEnum<["collection", "singleton"]>;
+  /**
+   * Collections only: names the list route and query (`/api/content/articles`, `articles(…)`). Optional
+   * here so files written before plural API IDs still parse; normalizing fills it on a collection.
+   */
+  pluralApiKey: Type.TOptional<Type.TString>;
+  localized: Type.TOptional<Type.TBoolean>;
+  /** Entries have separate draft and published states. Default true. */
+  draftAndPublish: Type.TOptional<Type.TBoolean>;
+  display: Type.TOptional<Type.TObject<{
+    /** Field whose value labels an entry in lists, pickers and relation summaries. */
+    titleFieldId: Type.TOptional<Type.TString>;
+    /** Columns of the content list, in order. */
+    listFieldIds: Type.TOptional<Type.TArray<Type.TString>>;
+    defaultSort: Type.TOptional<Type.TObject<{
+      fieldId: Type.TString;
+      direction: Type.TEnum<["asc", "desc"]>;
+    }>>;
+    /** Editor layout: named sections of the entry form. */
+    groups: Type.TOptional<Type.TArray<Type.TObject<{
+      id: Type.TString;
+      label: Type.TString;
+      fieldIds: Type.TArray<Type.TString>;
+    }>>>;
+    /** Fields rendered as blocks in the entry document's canvas, in order. Default: see `effectiveLayout`. */
+    canvasFieldIds: Type.TOptional<Type.TArray<Type.TString>>;
+    /** A single image `media` field shown as the cover above the title. Default: see `effectiveLayout`. */
+    coverFieldId: Type.TOptional<Type.TString>;
+    /** Properties shown as chips in the document's strip. Default: the first non-empty ones. */
+    stripFieldIds: Type.TOptional<Type.TArray<Type.TString>>;
+  }>>;
+  id: Type.TOptional<Type.TString>;
+  apiKey: Type.TString;
+  label: Type.TString;
+  description: Type.TOptional<Type.TString>;
+  fields: Type.TArray<Type.TObject<{
+    id: Type.TOptional<Type.TString>;
+    apiKey: Type.TString;
+    label: Type.TString;
+    /** Help text shown under the control. */
+    description: Type.TOptional<Type.TString>;
+    type: Type.TEnum<["string", "text", "richtext", "number", "integer", "decimal", "biginteger", "boolean", "date", "datetime", "time", "enum", "json", "slug", "email", "url", "uid", "media", "relation", "component", "dynamiczone"]>;
+    required: Type.TOptional<Type.TBoolean>;
+    /** Per-locale value. Ignored (must be false) when the model is not localized. */
+    localized: Type.TOptional<Type.TBoolean>;
+    /** Readable by delivery principals wherever the model is readable (ADR 0005). Default true. */
+    public: Type.TOptional<Type.TBoolean>;
+    unique: Type.TOptional<Type.TBoolean>;
+    filterable: Type.TOptional<Type.TBoolean>;
+    sortable: Type.TOptional<Type.TBoolean>;
+    /** Hidden from editors and the API; stored values are preserved until an explicit cleanup. */
+    deprecated: Type.TOptional<Type.TBoolean>;
+    /** Used for new entries and to backfill existing ones when the field becomes required. */
+    defaultValue: Type.TOptional<Type.TUnknown>;
+    /** Type-specific settings, validated against SETTINGS_SCHEMAS[type]. */
+    settings: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    editor: Type.TOptional<Type.TObject<{
+      id: Type.TString;
+      options: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    }>>;
+  }>>;
+}>, Type.TObject<{
+  kind: Type.TLiteral<"component">;
+  category: Type.TOptional<Type.TString>;
+  icon: Type.TOptional<Type.TString>;
+  display: Type.TOptional<Type.TObject<{
+    titleFieldId: Type.TOptional<Type.TString>;
+    groups: Type.TOptional<Type.TArray<Type.TObject<{
+      id: Type.TString;
+      label: Type.TString;
+      fieldIds: Type.TArray<Type.TString>;
+    }>>>;
+  }>>;
+  id: Type.TOptional<Type.TString>;
+  apiKey: Type.TString;
+  label: Type.TString;
+  description: Type.TOptional<Type.TString>;
+  fields: Type.TArray<Type.TObject<{
+    id: Type.TOptional<Type.TString>;
+    apiKey: Type.TString;
+    label: Type.TString;
+    /** Help text shown under the control. */
+    description: Type.TOptional<Type.TString>;
+    type: Type.TEnum<["string", "text", "richtext", "number", "integer", "decimal", "biginteger", "boolean", "date", "datetime", "time", "enum", "json", "slug", "email", "url", "uid", "media", "relation", "component", "dynamiczone"]>;
+    required: Type.TOptional<Type.TBoolean>;
+    /** Per-locale value. Ignored (must be false) when the model is not localized. */
+    localized: Type.TOptional<Type.TBoolean>;
+    /** Readable by delivery principals wherever the model is readable (ADR 0005). Default true. */
+    public: Type.TOptional<Type.TBoolean>;
+    unique: Type.TOptional<Type.TBoolean>;
+    filterable: Type.TOptional<Type.TBoolean>;
+    sortable: Type.TOptional<Type.TBoolean>;
+    /** Hidden from editors and the API; stored values are preserved until an explicit cleanup. */
+    deprecated: Type.TOptional<Type.TBoolean>;
+    /** Used for new entries and to backfill existing ones when the field becomes required. */
+    defaultValue: Type.TOptional<Type.TUnknown>;
+    /** Type-specific settings, validated against SETTINGS_SCHEMAS[type]. */
+    settings: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    editor: Type.TOptional<Type.TObject<{
+      id: Type.TString;
+      options: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    }>>;
+  }>>;
+}>]>;
+export type FieldInput = Static<typeof FieldInputSchema>;
+export type ModelDefinitionInput = Static<typeof ModelDefinitionInputSchema>;
+export type ComponentDefinitionInput = Static<typeof ComponentDefinitionInputSchema>;
+export type DefinitionInput = ModelDefinitionInput | ComponentDefinitionInput;
+export type EditorChoice = {
+  id: string;
+  options: Record<string, JsonValue>;
+};
+type FieldBase = {
+  id: string;
+  apiKey: string;
+  label: string;
+  description?: string;
+  required: boolean;
+  localized: boolean;
+  public: boolean;
+  unique: boolean;
+  filterable: boolean;
+  sortable: boolean;
+  deprecated: boolean;
+  defaultValue?: JsonValue;
+  editor: EditorChoice;
+};
+/** A normalized field. Narrow on `type` to get typed `settings`. */
+export type FieldDefinition<T extends DataType = DataType> = { [K in T]: FieldBase & {
+  type: K;
+  settings: DataTypeSettings[K];
+}; }[T];
+export type FieldGroup = {
+  id: string;
+  label: string;
+  fieldIds: string[];
+};
+export type ModelDisplay = {
+  titleFieldId?: string;
+  listFieldIds?: string[];
+  defaultSort?: {
+    fieldId: string;
+    direction: SortDirection;
+  };
+  groups?: FieldGroup[];
+  canvasFieldIds?: string[];
+  coverFieldId?: string;
+  stripFieldIds?: string[];
+};
+export type ComponentDisplay = {
+  titleFieldId?: string;
+  groups?: FieldGroup[];
+};
+export type ModelDefinition = {
+  id: string;
+  kind: ModelKind;
+  apiKey: string;
+  /**
+   * Present on collections (filled by normalizing), absent on singletons. Read it through `routeKeyOf`,
+   * which also covers a stored definition that predates plural API IDs.
+   */
+  pluralApiKey?: string;
+  label: string;
+  description?: string;
+  localized: boolean;
+  draftAndPublish: boolean;
+  fields: FieldDefinition[];
+  display: ModelDisplay;
+};
+export type ComponentDefinition = {
+  id: string;
+  kind: 'component';
+  apiKey: string;
+  label: string;
+  description?: string;
+  category?: string;
+  icon?: string;
+  fields: FieldDefinition[];
+  display: ComponentDisplay;
+};
+/** Either kind. Most schema machinery (diff, file format, registry) works on both. */
+export type SchemaDefinition = ModelDefinition | ComponentDefinition;
+export declare const isComponentDefinition: (definition: SchemaDefinition) => definition is ComponentDefinition;
+export declare const isModelDefinition: (definition: SchemaDefinition) => definition is ModelDefinition;
+//#endregion
+//#region src/types/locales.d.ts
+/** BCP 47 subset: language (2–3 letters) plus optional subtags, e.g. `en`, `fr-CA`, `zh-Hant-TW`. */
+export declare const LOCALE_CODE_PATTERN: RegExp;
+export declare const MAX_FALLBACK_CHAIN = 10;
+export declare const LocaleInputSchema: Type.TObject<{
+  code: Type.TString;
+  label: Type.TString;
+  /** Locales tried in order when content is missing in this one; the default locale is always last. */
+  fallbacks: Type.TOptional<Type.TArray<Type.TString>>;
+}>;
+export type LocaleInput = Static<typeof LocaleInputSchema>;
+export type LocaleDefinition = {
+  code: string;
+  label: string;
+  isDefault: boolean;
+  fallbacks: string[];
+};
+//#endregion
+//#region src/types/valueFormats.d.ts
+/**
+ * Canonical text formats for values stored as JSON strings (ADR 0001: dates and times are canonical UTC
+ * ISO-8601 text so they index and sort as text; decimal and biginteger are strings so no precision is lost).
+ * The content validator (package E) and the settings validators here share these patterns.
+ */
+export declare const DATE_PATTERN: RegExp;
+export declare const DATETIME_PATTERN: RegExp;
+export declare const TIME_PATTERN: RegExp;
+export declare const DECIMAL_PATTERN: RegExp;
+export declare const BIGINTEGER_PATTERN: RegExp;
+/** Lower-case words joined by single hyphens, e.g. `summer-sale-2026`. */
+export declare const SLUG_PATTERN: RegExp;
+/** URL-safe identifier characters for `uid` fields. */
+export declare const UID_PATTERN: RegExp;
+/** The rich-text document envelope version this release reads and writes (ADR 0003). */
+export declare const RICHTEXT_FORMAT = "shapio-richtext";
+export declare const RICHTEXT_FORMAT_VERSION = 1;
+//#endregion
+//#region src/editors/catalogue.d.ts
+/**
+ * Built-in editors (ADR 0009): which data types each can edit and the schema of its options. The server
+ * validates every field's editor choice against this catalogue, so selecting and configuring an editor is
+ * runtime metadata. Custom editors (loaded at runtime from the project) use namespaced IDs containing a dot,
+ * e.g. `acme.colorWheel`; their options are free-form JSON here because their schema lives in the project.
+ */
+export type EditorCatalogueEntry = {
+  id: string;
+  dataTypes: readonly DataType[];
+  optionsSchema: TSchema;
+  /** Extra compatibility rule beyond the data type (e.g. radio buttons only for single-value enums). */
+  supports?: (field: FieldDefinition) => boolean;
+};
+export declare const EDITOR_CATALOGUE: ReadonlyMap<string, EditorCatalogueEntry>;
+/** The editor a field gets when its definition names none. */
+export declare const DEFAULT_EDITORS: Readonly<Record<DataType, string>>;
+/** `vendor.name` (letters, digits, `_`, `-`), e.g. `acme.colorWheel`. Built-in IDs never contain a dot. */
+export declare const CUSTOM_EDITOR_ID_PATTERN: RegExp;
+export declare const isCustomEditorId: (id: string) => boolean;
+/** Built-in editors that can edit this field (for the admin's editor picker). */
+export declare const listCompatibleEditors: (field: FieldDefinition) => EditorCatalogueEntry[];
+//#endregion
+//#region src/display/layout.d.ts
+/**
+ * Data types that can be blocks in the entry document's canvas. Components must also be repeatable and
+ * media must hold several files (`isCanvasEligible`); a single component or file is a property.
+ */
+export declare const CANVAS_ELIGIBLE: ReadonlySet<DataType>;
+/** Title types that the document edits inline as its H1; any other title type stays a property. */
+export declare const INLINE_TITLE_TYPES: ReadonlySet<DataType>;
+/** How many properties the strip shows when `display.stripFieldIds` is not set. */
+export declare const STRIP_DEFAULT_COUNT = 5;
+export declare const isCanvasEligible: (field: FieldDefinition) => boolean;
+/** A single `media` field that may hold an image. */
+export declare const isCoverEligible: (field: FieldDefinition) => boolean;
+/** Properties under one of the model's `display.groups` (`label` undefined for ungrouped fields). */
+export type PropertyGroup = {
+  id: string;
+  label: string | undefined;
+  fields: FieldDefinition[];
+};
+export type DocumentLayout = {
+  /** The field that labels the entry (`effectiveTitleField`), if any. */
+  title: FieldDefinition | undefined;
+  /** The title is edited inline as the H1 (string/text); otherwise it is shown read-only and is a property. */
+  titleInline: boolean;
+  cover: FieldDefinition | undefined;
+  /** Canvas blocks, in order. */
+  canvas: FieldDefinition[];
+  /** Every other live field, ordered by `display.groups`, then field order. */
+  properties: FieldDefinition[];
+  /** `properties` split by group, for the settings drawer and the property grid. */
+  propertyGroups: PropertyGroup[];
+  /**
+   * The strip's configured properties, or null when it is not configured: then it shows the first
+   * STRIP_DEFAULT_COUNT non-empty properties (`stripFieldsOf`), which depends on the entry's values.
+   */
+  strip: FieldDefinition[] | null;
+};
+/**
+ * The entry document's layout: title, cover, canvas blocks and properties. Configured `display` ids win
+ * when they point at live, eligible fields; anything else falls back to the defaults (canvas: every
+ * eligible field in field order; cover: the first single image field). Deprecated and ineligible ids are
+ * skipped, so a stale definition never breaks the editor. Pure: no values, no I/O.
+ */
+export declare const effectiveLayout: (model: ModelDefinition) => DocumentLayout;
+/** The strip's properties: the configured ones, or the first `limit` that `hasValue` says are non-empty. */
+export declare const stripFieldsOf: (layout: DocumentLayout, hasValue: (field: FieldDefinition) => boolean, limit?: number) => FieldDefinition[];
+//#endregion
+//#region src/display/titleField.d.ts
+/** Field types that may label entries: the only types `display.titleFieldId` accepts, and the fallback's. */
+export declare const TITLE_FIELD_TYPES: ReadonlySet<string>;
+/**
+ * Field types the list API's `q` search runs on, checked on top of the title field: an enum title is not
+ * searchable. `url` is listed for search only; it is never a title.
+ */
+export declare const TEXT_TITLE_FIELD_TYPES: ReadonlySet<string>;
+/**
+ * The field that labels a definition's entries in lists, pickers, relation summaries and search: the
+ * configured `display.titleFieldId` when it points at a live (non-deprecated) field, otherwise the first
+ * live field of a title type (TITLE_FIELD_TYPES) in field order, otherwise undefined. `titleFieldId` is
+ * optional, so a model built without one still gets a readable title.
+ */
+export declare const effectiveTitleField: (definition: SchemaDefinition) => FieldDefinition | undefined;
+//#endregion
+//#region src/naming/plural.d.ts
+/** Appended when English has no distinct plural (`news` → `newsItems`, `series` → `seriesItems`). */
+export declare const PLURAL_FALLBACK_SUFFIX = "Items";
+/**
+ * Suggests the plural API ID of a collection from its singular one (`article` → `articles`,
+ * `category` → `categories`). Only a suggestion for the admin and the value filled into definitions that
+ * predate plural API IDs: the plural is stored on the definition and nothing pluralises at request time.
+ * Deterministic for a given `pluralize` version, which is pinned exactly for that reason.
+ */
+export declare const suggestPlural: (apiKey: string) => string;
+//#endregion
+//#region src/normalize.d.ts
+/** Input whose IDs have been assigned (see `assignIds`). */
+type WithIds<T extends {
+  id?: string;
+}> = T & {
+  id: string;
+};
+export type FieldInputWithId = WithIds<FieldInput>;
+export type DefinitionInputWithIds = (WithIds<ModelDefinitionInput> & {
+  fields: FieldInputWithId[];
+}) | (WithIds<ComponentDefinitionInput> & {
+  fields: FieldInputWithId[];
+});
+/**
+ * Applies defaults so that two definitions meaning the same thing are byte-identical once serialized
+ * canonically: a hand-written file that omits `public` hashes the same as one that says `public: true`.
+ * Empty optional strings and arrays are dropped. A collection without a plural API ID gets the suggested
+ * one (`suggestPlural`), so files and definitions from before plural API IDs keep working.
+ */
+export declare const normalizeDefinition: (input: DefinitionInputWithIds) => SchemaDefinition;
+/** Normalizes a definition that is already normalized-shaped (e.g. read back from the database). */
+export declare const renormalizeDefinition: (definition: SchemaDefinition) => SchemaDefinition;
+//#endregion
+//#region src/validators/issues.d.ts
+/**
+ * A problem found in a definition. `path` is a JSON pointer into the definition (`/fields/2/apiKey`), so
+ * the admin can put the message next to the control and the CLI can point at the file location.
+ */
+export type ValidationIssue = {
+  path: string;
+  code: IssueCode;
+  message: string;
+  /** Set by cross-definition checks so a multi-definition apply can say which file is wrong. */
+  definitionId?: string;
+};
+export type IssueCode = 'INVALID_STRUCTURE' | 'INVALID_ID' | 'DUPLICATE_ID' | 'API_KEY_INVALID' | 'API_KEY_TOO_LONG' | 'API_KEY_RESERVED_PREFIX' | 'API_KEY_RESERVED' | 'API_KEY_COLLISION' | 'PLURAL_API_KEY_SAME_AS_SINGULAR' | 'GENERATED_NAME_COLLISION' | 'INVALID_SETTINGS' | 'INVALID_RANGE' | 'INVALID_PATTERN' | 'DUPLICATE_ENUM_VALUE' | 'INVALID_ENUM_VALUE' | 'UNSUPPORTED_FLAG' | 'INVALID_DEFAULT_VALUE' | 'UNKNOWN_EDITOR' | 'INCOMPATIBLE_EDITOR' | 'INVALID_EDITOR_OPTIONS' | 'UNKNOWN_FIELD_REFERENCE' | 'INVALID_FIELD_REFERENCE' | 'DUPLICATE_GROUP' | 'UNKNOWN_REFERENCE' | 'INVALID_REFERENCE_TARGET' | 'COMPONENT_CYCLE' | 'COMPONENT_TOO_DEEP' | 'REFERENCED_DEFINITION';
+export declare class SchemaValidationError extends Error {
+  readonly issues: readonly ValidationIssue[];
+  constructor(issues: readonly ValidationIssue[]);
+}
+export declare const issue: (path: string, code: IssueCode, message: string) => ValidationIssue;
+//#endregion
+//#region src/validators/apiKey.d.ts
+/**
+ * API keys (models, components, fields) must be valid GraphQL names from day one (CONTRIBUTING.md rule 4),
+ * so GraphQL can expose them without renames.
+ */
+export declare const API_KEY_PATTERN: RegExp;
+export declare const MAX_API_KEY_LENGTH = 64;
+export declare const isApiKeySyntaxValid: (key: string) => boolean;
+/**
+ * Syntax checks shared by every kind of API key (`noun` names it in messages, e.g. "plural API ID").
+ * Returns the first problem, or null.
+ */
+export declare const checkApiKeySyntax: (key: string, noun?: string) => {
+  code: IssueCode;
+  message: string;
+} | null;
+/** Case-folded form used for every collision check: `Title` and `title` collide. */
+export declare const foldApiKey: (key: string) => string;
+//#endregion
+//#region src/validators/defaultValue.d.ts
+/**
+ * Checks that a field's `defaultValue` has the right JSON shape for its type. Full content rules
+ * (lengths, ranges) are applied by the content validator when the default is used.
+ * Returns a message, or null when the default is acceptable.
+ */
+export declare const checkDefaultValue: (field: FieldDefinition) => string | null;
+//#endregion
+//#region src/validators/definition.d.ts
+/** All problems with one definition, in document order. Empty means valid on its own. */
+export declare const validateDefinition: (definition: SchemaDefinition) => ValidationIssue[];
+//#endregion
+//#region src/validators/naming.d.ts
+/**
+ * The names GraphQL (package J) and other generated contracts derive from API keys. Defined here, with the
+ * validator, so a name that would collide in GraphQL is rejected when the model is saved, never later.
+ * Package J must generate exactly these names.
+ */
+export declare const toTypeName: (apiKey: string) => string;
+/** Suffixes of the types generated for each model (`Page`, `PageFilter`, `PageInput`...). */
+export declare const MODEL_TYPE_SUFFIXES: readonly ["", "Filter", "Input", "Connection", "Edge", "Localizations", "Sort"];
+export declare const COMPONENT_TYPE_SUFFIXES: readonly ["", "Input"];
+export declare const MUTATION_PREFIXES: readonly ["create", "update", "delete", "publish", "unpublish"];
+/**
+ * The key a model is addressed by in the delivery API (`/api/content/:routeKey`, preview routes): the
+ * plural API ID of a collection, the API ID of a singleton. A collection stored before plural API IDs
+ * existed gets the same derived value normalizing would fill, so this never returns undefined.
+ */
+export declare const routeKeyOf: (definition: ModelDefinition) => string;
+/** GraphQL list query of a collection (`articles(…)`): its plural API ID. */
+export declare const collectionQueryName: (definition: ModelDefinition) => string;
+/**
+ * A stored definition with the plural API ID a collection gets when it predates them (the value
+ * normalizing fills), and whether anything was filled. Callers that hash definitions re-hash when `filled`.
+ */
+export declare const withDerivedPlural: <T extends SchemaDefinition>(definition: T) => {
+  definition: T;
+  filled: boolean;
+};
+/**
+ * GraphQL built-ins and the fixed types Shapio's schema always defines. Compared case-folded, so a model
+ * called `string` (type `String`) or `pageInfo` is rejected.
+ */
+export declare const RESERVED_TYPE_NAMES: readonly string[];
+/**
+ * Model and component API keys the admin uses as static URL segments (`/content/new`,
+ * `/develop/components`), so a type with one of these keys could not be opened. Compared case-folded.
+ */
+export declare const RESERVED_DEFINITION_API_KEYS: readonly string[];
+/**
+ * Field API keys that collide with the system fields every entry exposes in REST and GraphQL.
+ * Compared case-folded.
+ */
+export declare const RESERVED_FIELD_API_KEYS: readonly string[];
+/**
+ * Root query fields every GraphQL schema has, whatever models exist. Compared case-folded. The first is the
+ * schema version field (schemaBuilder.ts reads it by position).
+ */
+export declare const RESERVED_QUERY_NAMES: readonly string[];
+export type NameNamespace = 'type' | 'query' | 'mutation';
+export type GeneratedName = {
+  namespace: NameNamespace;
+  name: string;
+  /** Which definition (and field, for per-field types) produced the name, for error messages. */
+  definitionId: string;
+  fieldId?: string;
+  /** The definition property the name comes from, when not `apiKey` (for the issue path). */
+  property?: 'pluralApiKey';
+};
+/** Every name a definition contributes to the GraphQL schema. */
+export declare const generatedNames: (definition: SchemaDefinition) => GeneratedName[];
+//#endregion
+//#region src/validators/parse.d.ts
+export type ParseDefinitionResult = {
+  ok: true;
+  definition: SchemaDefinition;
+} | {
+  ok: false;
+  issues: ValidationIssue[];
+};
+export type ParseDefinitionOptions = {
+  /**
+   * The current definition, if this is an edit. Fields sent without an `id` are matched to the current
+   * field with the same API key (case-insensitive) and keep its ID; unmatched fields get a new ID.
+   */
+  previous?: SchemaDefinition;
+  createId?: () => string;
+};
+/** Fills in missing definition and field IDs (see ParseDefinitionOptions.previous). */
+export declare const assignIds: (input: DefinitionInput, { previous, createId }?: ParseDefinitionOptions) => DefinitionInputWithIds;
+/**
+ * The single entry point from untrusted input (request bodies, schema files) to a normalized definition:
+ * structure, settings per data type, ID assignment, defaults, then the per-definition semantic checks.
+ * Cross-definition rules (references, cycles, GraphQL name collisions) are `validateSchema`'s job.
+ */
+export declare const parseDefinition: (raw: unknown, options?: ParseDefinitionOptions) => ParseDefinitionResult;
+//#endregion
+//#region src/validators/schema.d.ts
+/** Deepest allowed nesting of components (a component inside a component inside ... ) below an entry. */
+export declare const MAX_COMPONENT_DEPTH = 5;
+/** Component IDs a definition embeds directly (component and dynamic-zone fields). */
+export declare const embeddedComponentIds: (definition: SchemaDefinition) => string[];
+/**
+ * Cross-definition checks over a whole schema (every active definition with the proposed change applied):
+ * unique IDs and API keys, GraphQL name collisions, relation and component targets, component cycles and
+ * nesting depth. Each definition must already pass `validateDefinition`.
+ */
+export declare const validateSchema: (definitions: readonly SchemaDefinition[]) => ValidationIssue[];
+/** Definitions that reference `id` (relations, components, dynamic zones). Used to block deletions. */
+export declare const findReferencingDefinitions: (definitions: readonly SchemaDefinition[], id: string) => SchemaDefinition[];
+/**
+ * Models that embed a component directly or through other components, i.e. whose entries change shape
+ * when the component does (brief §5: "editing a shared component must account for all dependent models").
+ */
+export declare const findDependentModels: (definitions: readonly SchemaDefinition[], componentId: string) => SchemaDefinition[];
+//#endregion
+//#region src/diff/types.d.ts
+export declare const CHANGE_KINDS: readonly ["definition.added", "definition.removed", "definition.apiKey", "definition.pluralApiKey", "definition.metadata", "model.kind", "model.localized", "model.draftAndPublish", "field.added", "field.removed", "field.order", "field.apiKey", "field.metadata", "field.editor", "field.type", "field.required", "field.localized", "field.public", "field.deprecated", "field.unique", "field.filterable", "field.sortable", "field.settings"];
+export type ChangeKind = (typeof CHANGE_KINDS)[number];
+/**
+ * One difference between two versions of a definition. `property` names the changed property for
+ * `*.metadata` (`label`, `description`, ...) and `field.settings` (the settings key); `from`/`to` hold the
+ * old and new values (absent when the side does not exist).
+ */
+export type SchemaChange = {
+  kind: ChangeKind;
+  definitionId: string;
+  fieldId?: string;
+  property?: string;
+  from?: JsonValue;
+  to?: JsonValue;
+};
+//#endregion
+//#region src/diff/diffDefinitions.d.ts
+/**
+ * Every difference between two versions of a definition, matched by stable IDs (so a renamed field is a
+ * rename, not a removal plus an addition). Pass `null` for a side that does not exist. The order is
+ * deterministic: definition-level changes, then fields in the new order, then removed fields.
+ */
+export declare const diffDefinitions: (before: SchemaDefinition | null, after: SchemaDefinition | null) => SchemaChange[];
+//#endregion
+//#region src/diff/classify.d.ts
+/**
+ * Change classification (brief §5, ADR 0002). Each change gets a category, whether it needs prerequisite
+ * work before the new revision can be activated, and flags for breaking API contracts and destroying data.
+ *
+ * | Brief §5 row                         | category                         | activation                    |
+ * | ------------------------------------ | -------------------------------- | ----------------------------- |
+ * | Label, help text, editor layout      | metadata                         | immediate                     |
+ * | Compatible editor swap               | editorSwap                       | immediate                     |
+ * | Optional field or new model          | additive                         | immediate (live)              |
+ * | Required field                       | requiredField                    | validateRequired / backfill   |
+ * | Type or rich-text format conversion  | conversion                       | convert (+ validate)          |
+ * | API key rename                       | contract (breaking)              | immediate, needs ack          |
+ * | Field removal                        | removal (breaking, data kept)    | immediate, needs ack          |
+ * | Unique/index constraint              | constraint / index               | checkUnique / buildIndex      |
+ * | (plus) type change of a unique field | as its type change               | + checkUnique                 |
+ * | (plus) tightened validation rules    | validation                       | validateValues                |
+ * | (plus) localized true→false          | conversion (destructive)         | convert                       |
+ */
+export type ChangeCategory = 'metadata' | 'editorSwap' | 'additive' | 'requiredField' | 'validation' | 'conversion' | 'contract' | 'removal' | 'constraint' | 'index';
+/** Work that must succeed before activation. Content-touching kinds run through the content ports. */
+export type PrerequisiteKind = 'validateRequired' | 'backfill' | 'validateValues' | 'checkUnique' | 'buildIndex' | 'convert';
+/** Work done after activation, once nothing reads the old structure. */
+export type CleanupKind = 'dropIndex' | 'releaseUnique';
+export type ClassifiedChange = SchemaChange & {
+  category: ChangeCategory;
+  /** Changes the public API contract (REST/GraphQL shape or visibility); needs explicit acknowledgement. */
+  breaking: boolean;
+  /** Loses stored information that a schema rollback cannot restore. */
+  destructive: boolean;
+  /** False for conversions Shapio cannot perform; the planner refuses them. */
+  supported: boolean;
+  prerequisites: PrerequisiteKind[];
+  cleanup: CleanupKind[];
+};
+export type ClassifyContext = {
+  before: SchemaDefinition | null;
+  after: SchemaDefinition | null;
+};
+/** Classifies one change in the context of the definitions it was diffed from. */
+export declare const classifyChange: (change: SchemaChange, context: ClassifyContext) => ClassifiedChange;
+export declare const classifyChanges: (changes: readonly SchemaChange[], context: ClassifyContext) => ClassifiedChange[];
+export type ChangeSummary = {
+  breaking: boolean;
+  destructive: boolean;
+  supported: boolean;
+  prerequisites: PrerequisiteKind[];
+  cleanup: CleanupKind[];
+  /** True when nothing but metadata/editor changes are involved. */
+  metadataOnly: boolean;
+};
+export declare const summarizeChanges: (changes: readonly ClassifiedChange[]) => ChangeSummary;
+/** Locale configuration changes (ADR 0002/0004). Locales are global, so they are planned on their own. */
+export type LocaleChangeKind = 'locale.added' | 'locale.removed' | 'locale.defaultChanged' | 'locale.metadata';
+export type ClassifiedLocaleChange = {
+  kind: LocaleChangeKind;
+  code: string;
+  category: ChangeCategory;
+  breaking: boolean;
+  destructive: boolean;
+};
+/**
+ * - added: live (entries gain the locale as editors fill it in);
+ * - removed: destroys that locale's content (purged by a follow-up job), so it needs explicit consent;
+ * - default changed: delivery falls back to a different locale, a contract change for API consumers;
+ * - label or fallback chain: metadata.
+ */
+export declare const classifyLocaleChange: (kind: LocaleChangeKind, code: string) => ClassifiedLocaleChange;
+//#endregion
+//#region src/fileFormat/canonical.d.ts
+export declare const canonicalJson: (value: unknown) => string;
+/**
+ * The bytes Shapio hashes and writes for a definition. The definition must be normalized
+ * (`normalizeDefinition`), so defaults are explicit and the same meaning has one spelling.
+ */
+export declare const serializeDefinition: (definition: SchemaDefinition) => string;
+//#endregion
+//#region src/fileFormat/hash.d.ts
+/** `sha256:<hex>` of a UTF-8 string, via Web Crypto (Node and browsers alike). */
+export declare const sha256: (text: string) => Promise<string>;
+/** Hash of a normalized definition's canonical serialization; recorded per model in the lock file. */
+export declare const hashDefinition: (definition: SchemaDefinition) => Promise<string>;
+//#endregion
+//#region src/fileFormat/lockFile.d.ts
+/** Where `shapio schema pull` keeps its record of what it pulled, relative to the project root. */
+export declare const LOCK_FILE_PATH = ".shapio/schema-lock.json";
+export declare const LOCK_FILE_FORMAT_VERSION = 1;
+export declare const LockEntrySchema: Type.TObject<{
+  kind: Type.TEnum<["collection", "singleton", "component"]>;
+  apiKey: Type.TString;
+  /** The definition's per-model version on the instance when it was pulled. */
+  version: Type.TInteger;
+  /** `hashDefinition` of the pulled definition; a local file with another hash has been edited. */
+  hash: Type.TString;
+}>;
+export declare const LockFileSchema: Type.TObject<{
+  formatVersion: Type.TLiteral<1>;
+  /** The instance's global schema version at pull time (informational; the guard is per model). */
+  schemaVersion: Type.TInteger;
+  /** Keyed by definition ID. */
+  definitions: Type.TRecord<"^.*$", Type.TObject<{
+    kind: Type.TEnum<["collection", "singleton", "component"]>;
+    apiKey: Type.TString;
+    /** The definition's per-model version on the instance when it was pulled. */
+    version: Type.TInteger;
+    /** `hashDefinition` of the pulled definition; a local file with another hash has been edited. */
+    hash: Type.TString;
+  }>>;
+}>;
+export type LockEntry = Static<typeof LockEntrySchema>;
+export type LockFile = Static<typeof LockFileSchema>;
+export declare class LockFileError extends Error {
+  constructor(message: string);
+}
+export declare const parseLockFile: (text: string) => LockFile;
+export declare const serializeLockFile: (lock: LockFile) => string;
+//#endregion
+//#region src/sync/threeWay.d.ts
+/**
+ * Per-definition three-way decision for `shapio schema apply` (ADR 0002). The base is what the lock file
+ * recorded at pull time; local is the file in the repository; remote is the target instance now.
+ *
+ * - unchanged locally → skip, even if the target changed it since (no silent revert of production edits);
+ * - changed locally and unchanged on the target → apply, guarded by the target's current version;
+ * - changed on both → refuse and show the diff, like a rejected non-fast-forward push.
+ *
+ * Deletions need `prune`. Identical content on both sides is never a conflict.
+ */
+export type SyncSide = {
+  version: number;
+  hash: string;
+};
+export type SyncLocal = {
+  definition: SchemaDefinition;
+  hash: string;
+};
+export type SyncRemote = SyncSide & {
+  definition: SchemaDefinition;
+};
+export type SyncInput = {
+  local?: SyncLocal;
+  base?: SyncSide;
+  remote?: SyncRemote;
+  prune: boolean;
+};
+export type SyncSkipReason = 'unchangedLocally' | 'alreadyApplied' | 'remoteOnly' | 'deletedLocallyWithoutPrune' | 'alreadyDeleted';
+export type SyncConflictReason = 'changedOnBoth' | 'deletedOnTarget' | 'existsOnTarget' | 'changedOnTargetBeforeDelete';
+export type SyncDecision = {
+  action: 'skip';
+  reason: SyncSkipReason;
+} | {
+  action: 'create';
+} | {
+  action: 'update';
+  expectedVersion: number;
+} | {
+  action: 'delete';
+  expectedVersion: number;
+} | {
+  action: 'conflict';
+  reason: SyncConflictReason;
+};
+export declare const decideSync: ({ local, base, remote, prune }: SyncInput) => SyncDecision;
+//#endregion
+//#region src/richtext/spec.d.ts
+/**
+ * The rich-text document schema (ADR 0003, build plan §3.9): the baseline Tiptap/ProseMirror node and mark
+ * set, as data. The server validates stored documents against it and renders HTML from it; the admin's
+ * Tiptap editor (package F) must produce exactly these nodes, marks and attributes. Anything else is
+ * rejected, never stripped silently.
+ *
+ * Why a hand-written structural check instead of `@tiptap/core` headless: the baseline is small and fixed,
+ * the check needs no DOM shim, no extra runtime dependency on the server and no schema instantiation per
+ * request, and it reports precise paths. Package F keeps the editor in step with this module (it is the
+ * contract), and the shared JSON fixtures in this module's tests are what both sides agree on.
+ */
+export type AttrRule = {
+  /** Returns true when the value is acceptable. `null` is checked like any other value. */
+  check: (value: unknown) => boolean;
+  /** Used when the attribute is absent. */
+  default: unknown;
+};
+export type NodeRule = {
+  /** `block` nodes sit in block containers; `inline` nodes in textblocks. */
+  group: 'block' | 'inline' | 'listItem' | 'tableRow' | 'tableCell' | 'doc';
+  /** Allowed child groups or node types, and the minimum number of children. */
+  content?: {
+    allow: readonly string[];
+    min: number;
+  };
+  attrs?: Readonly<Record<string, AttrRule>>;
+  /** Inline children may carry marks (text nodes in a textblock); false for code blocks. */
+  marks?: boolean;
+};
+/** `href` values a link may carry: web, mail and phone links, and same-document/relative paths. */
+export declare const SAFE_LINK_PATTERN: RegExp;
+export declare const NODE_RULES: Readonly<Record<string, NodeRule>>;
+export type MarkRule = {
+  attrs?: Readonly<Record<string, AttrRule>>;
+};
+export declare const MARK_RULES: Readonly<Record<string, MarkRule>>;
+/** Nesting deeper than this is rejected (keeps validation and rendering bounded). */
+export declare const MAX_RICHTEXT_DEPTH = 40;
+//#endregion
+//#region src/richtext/render.d.ts
+/**
+ * HTML rendering of stored rich text for delivery (ADR 0003). Rendered from JSON only, never from stored
+ * HTML: every tag comes from this allow-list and every text and attribute value is escaped, so the output
+ * is safe whatever the document held. Deterministic, so a site built at a pinned snapshot gets the same HTML.
+ */
+/** Resolves an image's media ID to a deliverable URL; undefined when the asset is missing or not visible. */
+export type MediaUrlResolver = (mediaId: string) => string | undefined;
+export declare const escapeHtml: (value: string) => string;
+/** Renders a validated document to sanitized HTML. */
+export declare const renderRichTextHtml: (document: RichTextDocument, resolveMedia?: MediaUrlResolver) => string;
+/** The document's text, blocks separated by blank lines (rich text → plain text conversions, search). */
+export declare const richTextToPlainText: (document: RichTextDocument) => string;
+/** Plain text → a document of paragraphs (blank lines split paragraphs; single newlines are hard breaks). */
+export declare const plainTextToRichText: (text: string) => RichTextDocument;
+//#endregion
+export { RichTextDocument, RichTextNode, RichTextProblem, RichTextResult, isEmptyRichText, richTextMediaIds, validateRichText };
+//# sourceMappingURL=index.d.ts.map