@murumets-ee/entity 0.1.3 → 0.1.5

package/dist/index.d.mts

@@ -0,0 +1,903 @@
+import * as _$drizzle_orm0 from "drizzle-orm";
+import { SQL } from "drizzle-orm";
+import * as _$drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
+import { PgTableWithColumns } from "drizzle-orm/pg-core";
+import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+
+//#region src/admin-config.d.ts
+/**
+ * Optional admin UI configuration for entities.
+ * Controls how entities appear in the admin sidebar, list pages, and forms.
+ */
+interface EntityAdminConfig {
+  /** Sidebar section: 'content' | 'structure' | custom string. Default: 'content' */
+  group?: string;
+  /** Plural display name for sidebar + list pages. Default: title-cased pluralized entity name */
+  label?: string;
+  /** Singular label for "New X" button. Default: title-cased entity name */
+  labelSingular?: string;
+  /** Lucide icon name as string, e.g. 'file-text' */
+  icon?: string;
+  /** Description shown on list page */
+  description?: string;
+  /** Form layout. Default: 'single' */
+  layout?: 'single' | 'two-column';
+  /** Fields to hide in the form */
+  hiddenFields?: string[];
+  /** Columns to hide in the list */
+  hiddenColumns?: string[];
+  /** Per-field label/description/placeholder overrides */
+  fieldOverrides?: Record<string, {
+    label?: string;
+    description?: string;
+    placeholder?: string;
+  }>;
+  /** Default list sort field. Default: 'createdAt' */
+  defaultSort?: string;
+  /** Default list sort direction. Default: 'desc' */
+  defaultSortDirection?: 'asc' | 'desc';
+  /** List page size. Default: 20 */
+  pageSize?: number;
+  /** For block editor: fields to show in Puck root config */
+  rootFields?: string[];
+  /** Suppress "New" button in the list page */
+  disableCreate?: boolean;
+  /** Order within sidebar group. Default: 0 */
+  sortOrder?: number;
+}
+//#endregion
+//#region src/fields/base.d.ts
+/**
+ * Field type definitions
+ * These define the structure and configuration for all field types
+ */
+interface BaseFieldConfig {
+  required?: boolean;
+  default?: unknown;
+  translatable?: boolean;
+  indexed?: boolean;
+  unique?: boolean;
+  access?: {
+    view?: string;
+    edit?: string;
+  };
+}
+interface IdField extends BaseFieldConfig {
+  type: 'id';
+}
+interface TextField extends BaseFieldConfig {
+  type: 'text';
+  maxLength?: number;
+  minLength?: number;
+  pattern?: RegExp;
+}
+interface NumberField extends BaseFieldConfig {
+  type: 'number';
+  min?: number;
+  max?: number;
+  integer?: boolean;
+}
+interface BooleanField extends BaseFieldConfig {
+  type: 'boolean';
+}
+interface DateField extends BaseFieldConfig {
+  type: 'date';
+  minDate?: Date;
+  maxDate?: Date;
+}
+interface SelectField extends BaseFieldConfig {
+  type: 'select';
+  options: readonly string[];
+}
+interface ReferenceField extends BaseFieldConfig {
+  type: 'reference';
+  entity: string;
+  cardinality: 'one' | 'many';
+  onDelete?: 'cascade' | 'set-null' | 'restrict';
+}
+interface MediaField extends BaseFieldConfig {
+  type: 'media';
+  accept?: string[];
+  maxSize?: number;
+}
+interface RichTextField extends BaseFieldConfig {
+  type: 'richtext';
+  blocks?: string[];
+}
+interface SlugField extends BaseFieldConfig {
+  type: 'slug';
+  from: string;
+  unique?: boolean;
+}
+/**
+ * Minimal block definition reference — used by BlocksField to type-check allowed blocks.
+ * The full BlockDefinition (with label, etc.) lives in @murumets-ee/content.
+ */
+interface BlockDefinitionRef {
+  slug: string;
+  fields: Record<string, FieldConfig>;
+}
+/**
+ * Blocks field — ordered array of typed content blocks.
+ * Each block instance stores its data in {entity}_layout table.
+ *
+ * @property blocks - Allowed block definitions
+ * @property min/max - Block count constraints
+ * @property localized - true = per-locale layouts, false = shared layout with translated content (default)
+ */
+interface JsonField extends BaseFieldConfig {
+  type: 'json';
+}
+interface BlocksField extends BaseFieldConfig {
+  type: 'blocks';
+  blocks: readonly BlockDefinitionRef[];
+  min?: number;
+  max?: number;
+  localized?: boolean;
+}
+type FieldConfig = IdField | TextField | NumberField | BooleanField | DateField | SelectField | ReferenceField | MediaField | RichTextField | SlugField | JsonField | BlocksField;
+//#endregion
+//#region src/types/infer.d.ts
+/**
+ * Maps a single FieldConfig to its TypeScript output type.
+ * Each branch is a shallow comparison — no recursion.
+ */
+type FieldToTS<F extends FieldConfig> = F extends IdField ? string : F extends TextField ? string : F extends NumberField ? number : F extends BooleanField ? boolean : F extends DateField ? Date | string : F extends SelectField ? F['options'][number] : F extends ReferenceField ? F['cardinality'] extends 'many' ? string[] : string : F extends MediaField ? string : F extends RichTextField ? Record<string, unknown>[] : F extends SlugField ? string : F extends JsonField ? Record<string, unknown> : F extends BlocksField ? Array<{
+  _block: string;
+  _id: string;
+  [key: string]: unknown;
+}> : never;
+/**
+ * Extract keys of fields where `required` is literally `true`.
+ * Fields without `required` or with `required?: false` are optional.
+ */
+type RequiredFieldKeys<Fields extends Record<string, FieldConfig>> = { [K in keyof Fields]: Fields[K]['required'] extends true ? K : never }[keyof Fields];
+type OptionalFieldKeys<Fields extends Record<string, FieldConfig>> = { [K in keyof Fields]: Fields[K]['required'] extends true ? never : K }[keyof Fields];
+/**
+ * Maps a full field record to its TypeScript output type.
+ * Required fields are non-nullable; optional fields are `T | null | undefined`.
+ *
+ * The `id` field is always `string` and always present.
+ * The `id` key from Fields is excluded to avoid duplication since
+ * we hardcode `{ id: string }` at the front.
+ */
+type InferEntityDTO<Fields extends Record<string, FieldConfig>> = {
+  id: string;
+} & { [K in Exclude<RequiredFieldKeys<Fields>, 'id'>]: FieldToTS<Fields[K]> } & { [K in OptionalFieldKeys<Fields>]?: FieldToTS<Fields[K]> | null };
+/** Fields that are auto-generated and should not appear in create input. */
+type AutoGeneratedFields = 'id' | 'createdAt' | 'updatedAt' | 'createdBy' | 'updatedBy' | '_version';
+/**
+ * The input type for creating an entity.
+ * - Omits auto-generated fields (id, timestamps, version)
+ * - Required fields stay required; optional fields stay optional
+ */
+type InferCreateInput<Fields extends Record<string, FieldConfig>> = Omit<{ [K in Exclude<RequiredFieldKeys<Fields>, 'id'>]: FieldToTS<Fields[K]> } & { [K in OptionalFieldKeys<Fields>]?: FieldToTS<Fields[K]> | null }, AutoGeneratedFields>;
+/** Fields that cannot be changed after creation. */
+type ImmutableFields = 'id' | 'createdAt' | 'createdBy';
+type InferUpdateInput<Fields extends Record<string, FieldConfig>> = Partial<Omit<InferEntityDTO<Fields>, ImmutableFields>>;
+/**
+ * Behavior field types use `type` (not `interface`) because interfaces
+ * lack implicit index signatures needed for Record<string, FieldConfig>.
+ *
+ * Types are simplified to match what the field builders actually return,
+ * with only the specificity that FieldToTS needs (e.g., options tuple
+ * for SelectField, cardinality for ReferenceField).
+ */
+/** Fields added by publishable() */
+type PublishableFields = {
+  status: SelectField & {
+    options: readonly ['draft', 'published'];
+  };
+  publishedAt: DateField;
+};
+/** Fields added by auditable() */
+type AuditableFields = {
+  createdBy: TextField;
+  updatedBy: TextField;
+  createdAt: DateField;
+  updatedAt: DateField;
+};
+/** Fields added by sluggable() */
+type SluggableFields = {
+  slug: SlugField;
+};
+/** Fields added by revisionable() */
+type RevisionableFields = {
+  _version: NumberField;
+};
+/** Fields added by hierarchical() */
+type HierarchicalFields = {
+  parentId: ReferenceField & {
+    cardinality: 'one';
+  };
+  path: TextField;
+  depth: NumberField;
+};
+/**
+ * Extract the DTO type from an Entity.
+ *
+ * Usage:
+ *   const Article = defineEntity({ ... })
+ *   type ArticleDTO = InferEntity<typeof Article>
+ */
+type InferEntity<E> = E extends {
+  allFields: infer F extends Record<string, FieldConfig>;
+} ? InferEntityDTO<F> : never;
+//#endregion
+//#region src/behaviors/types.d.ts
+interface Behavior<F extends Record<string, FieldConfig> = Record<string, FieldConfig>> {
+  name: string;
+  fields?: F;
+  hooks?: {
+    beforeCreate?: (data: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    afterCreate?: (entity: Record<string, unknown>) => Promise<void>;
+    beforeUpdate?: (id: string, data: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    afterUpdate?: (entity: Record<string, unknown>) => Promise<void>;
+    beforeDelete?: (id: string) => Promise<void>;
+    afterDelete?: (id: string) => Promise<void>;
+  };
+}
+type BehaviorFactory = (...args: unknown[]) => Behavior;
+//#endregion
+//#region src/behaviors/auditable.d.ts
+declare function auditable(): Behavior<AuditableFields>;
+//#endregion
+//#region src/behaviors/hierarchical.d.ts
+interface HierarchicalOptions {
+  /**
+   * What happens when deleting a node that has children.
+   * - 'restrict': Prevent deletion (default)
+   * - 'cascade': Delete all descendants
+   * - 'reparent': Move children to the deleted node's parent
+   */
+  onDelete?: 'restrict' | 'cascade' | 'reparent';
+}
+declare function hierarchical(_options?: HierarchicalOptions): Behavior<HierarchicalFields>;
+//#endregion
+//#region src/behaviors/publishable.d.ts
+declare function publishable(): Behavior<PublishableFields>;
+//#endregion
+//#region src/behaviors/revisionable.d.ts
+declare function revisionable(): Behavior<RevisionableFields>;
+//#endregion
+//#region src/behaviors/sluggable.d.ts
+interface SluggableOptions {
+  /** Make the slug translatable — each locale gets its own slug. Default: false */
+  translatable?: boolean;
+}
+/**
+ * Convert text to URL-safe slug
+ */
+declare function slugify(text: string): string;
+declare function sluggable(sourceField: string, options?: SluggableOptions): Behavior<SluggableFields>;
+//#endregion
+//#region src/fields/builders.d.ts
+declare const field: {
+  /**
+   * ID field (auto-added to every entity)
+   */
+  id: <const C extends Partial<IdField> = {}>(config?: C) => IdField & C;
+  /**
+   * Text field
+   */
+  text: <const C extends Partial<TextField> = {}>(config?: C) => TextField & C;
+  /**
+   * Number field
+   */
+  number: <const C extends Partial<NumberField> = {}>(config?: C) => NumberField & C;
+  /**
+   * Boolean field
+   */
+  boolean: <const C extends Partial<BooleanField> = {}>(config?: C) => BooleanField & C;
+  /**
+   * Date field
+   */
+  date: <const C extends Partial<DateField> = {}>(config?: C) => DateField & C;
+  /**
+   * Select field (enum)
+   * Preserves literal option types for type inference.
+   * e.g. field.select({ options: ['news', 'tutorial'] }) infers 'news' | 'tutorial'
+   */
+  select: <const O extends readonly string[], const C extends Omit<Partial<SelectField>, "options"> = {}>(config: {
+    options: O;
+  } & C) => SelectField & {
+    options: O;
+  } & C;
+  /**
+   * Reference field (foreign key to another entity)
+   * Preserves literal cardinality to distinguish string vs string[] in inferred types.
+   */
+  reference: <C extends "one" | "many" = "one", const R extends Partial<Omit<ReferenceField, "entity" | "cardinality">> = {}>(config: {
+    entity: string;
+    cardinality?: C;
+  } & R) => ReferenceField & {
+    cardinality: C;
+  } & R;
+  /**
+   * Media field (file upload)
+   */
+  media: <const C extends Partial<MediaField> = {}>(config?: C) => MediaField & C;
+  /**
+   * Rich text field (WYSIWYG editor)
+   */
+  richtext: <const C extends Partial<RichTextField> = {}>(config?: C) => RichTextField & C;
+  /**
+   * Slug field (URL-safe string, auto-generated from source field)
+   */
+  slug: <const C extends Partial<SlugField> = {}>(config: Pick<SlugField, "from"> & C) => SlugField & C;
+  /**
+   * JSON field (arbitrary JSON data, stored as JSONB)
+   */
+  json: <const C extends Partial<JsonField> = {}>(config?: C) => JsonField & C;
+  /**
+   * Blocks field — ordered array of typed content blocks
+   * Preserves literal block tuple type for discriminated union inference.
+   */
+  blocks: <const B extends readonly BlockDefinitionRef[]>(config: {
+    blocks: B;
+    min?: number;
+    max?: number;
+    localized?: boolean;
+  }) => BlocksField & {
+    blocks: B;
+  };
+};
+//#endregion
+//#region src/behaviors/timestamped.d.ts
+type TimestampedFields = {
+  createdAt: ReturnType<typeof field.date>;
+  updatedAt: ReturnType<typeof field.date>;
+};
+declare function timestamped(): Behavior<TimestampedFields>;
+//#endregion
+//#region src/behaviors/index.d.ts
+/**
+ * Behavior namespace for fluent API
+ */
+declare const behavior: {
+  publishable: typeof publishable;
+  auditable: typeof auditable;
+  sluggable: typeof sluggable;
+  revisionable: typeof revisionable;
+  hierarchical: typeof hierarchical;
+  timestamped: typeof timestamped;
+};
+//#endregion
+//#region src/count-cache.d.ts
+/**
+ * In-memory TTL cache for COUNT(*) query results.
+ *
+ * Reduces database load on paginated list pages where the total count
+ * is recalculated on every pagination/sort/search interaction. The cache
+ * is per-process (not shared across workers) with a short TTL (default 5s)
+ * so counts are at most a few seconds stale.
+ *
+ * Cache keys include the entity name + serialized WHERE clause, so filtered
+ * and unfiltered counts are cached independently.
+ */
+/**
+ * Interface for count cache implementations.
+ * Used in client configs to avoid TypeScript private-field structural incompatibility
+ * across separate .d.ts files.
+ */
+interface CountCacheLike {
+  get(key: string): number | undefined;
+  set(key: string, count: number): void;
+  invalidate(prefix: string): void;
+}
+declare class CountCache implements CountCacheLike {
+  private cache;
+  private ttlMs;
+  constructor(ttlMs?: number);
+  /**
+   * Get a cached count. Returns undefined on miss or expired entry.
+   */
+  get(key: string): number | undefined;
+  /**
+   * Cache a count result with the configured TTL.
+   */
+  set(key: string, count: number): void;
+  /**
+   * Invalidate all cache entries whose key starts with the given prefix.
+   * Typically called with the entity name after mutations (create/update/delete).
+   */
+  invalidate(prefix: string): void;
+  /**
+   * Remove all expired entries. Useful for periodic cleanup in long-running processes.
+   */
+  prune(): void;
+  /**
+   * Clear the entire cache.
+   */
+  clear(): void;
+  /**
+   * Number of entries currently in the cache (including expired ones not yet pruned).
+   */
+  get size(): number;
+}
+//#endregion
+//#region src/count-estimate.d.ts
+/**
+ * Estimate the total row count for a table using Postgres statistics.
+ *
+ * Returns the approximate row count from `pg_class.reltuples`, which is
+ * updated by VACUUM/ANALYZE. Returns 0 if the table is not found or
+ * statistics are not yet available (e.g., freshly created table).
+ *
+ * @param db - Drizzle Postgres database instance
+ * @param tableName - The Postgres table name (without schema prefix)
+ * @returns Estimated row count (non-negative integer)
+ */
+declare function estimateRowCount(db: PostgresJsDatabase, tableName: string): Promise<number>;
+//#endregion
+//#region src/cursor.d.ts
+/** Cursor input for keyset pagination. */
+interface CursorInput {
+  /** Sort field name (e.g. 'createdAt'). Must be a real column on the entity. */
+  field: string;
+  /** Last seen value of the sort field. */
+  value: string | number;
+  /** Sort direction — must match the ORDER BY direction. */
+  direction: 'asc' | 'desc';
+  /** Tie-breaker: last seen entity ID. Required for non-unique sort fields. */
+  id?: string;
+}
+/** Decoded cursor (internal, after validation). */
+interface DecodedCursor {
+  field: string;
+  value: string | number;
+  direction: 'asc' | 'desc';
+  id?: string;
+}
+/**
+ * Encode a cursor for API transport (base64url).
+ * Built from the last item in a result set.
+ */
+declare function encodeCursor(item: Record<string, unknown>, sortField: string, direction: 'asc' | 'desc'): string;
+/**
+ * Decode and validate a cursor string from query params.
+ * Returns null if the cursor is malformed, tampered, or invalid.
+ *
+ * Security: the `field` value is NOT validated here — the caller must
+ * whitelist it against the entity's actual columns.
+ */
+declare function decodeCursor(encoded: string): DecodedCursor | null;
+/**
+ * Build the keyset WHERE condition from a decoded cursor.
+ *
+ * For DESC: `WHERE (field < value) OR (field = value AND id < cursorId)`
+ * For ASC:  `WHERE (field > value) OR (field = value AND id > cursorId)`
+ *
+ * The caller must verify that `cursor.field` exists on the table before calling.
+ *
+ * @param table - Drizzle table with columns
+ * @param cursor - Decoded and validated cursor
+ * @returns SQL condition, or null if the field doesn't exist on the table
+ */
+declare function buildCursorCondition(table: PgTableWithColumns<any>, cursor: DecodedCursor): SQL | null;
+//#endregion
+//#region src/define-entity.d.ts
+/**
+ * Entity definition input (without behaviors — behaviors are typed separately
+ * on the `defineEntity` function to enable tuple inference).
+ *
+ * @typeParam F - The literal field map. Inferred automatically from the call site.
+ */
+interface EntityDefinition<F extends Record<string, FieldConfig> = Record<string, FieldConfig>> {
+  name: string;
+  kind?: 'collection' | 'singleton';
+  fields: F;
+  scope?: 'global' | 'team' | 'user';
+  access?: {
+    view?: string;
+    create?: string;
+    update?: string;
+    delete?: string;
+  };
+  /** Admin UI configuration — controls sidebar, list, and form display */
+  admin?: EntityAdminConfig;
+}
+/**
+ * Full input for defineEntity (fields + behaviors + other config).
+ * Behaviors are typed as a tuple `B` for type extraction.
+ */
+type EntityInput<F extends Record<string, FieldConfig> = Record<string, FieldConfig>, B extends Behavior[] = Behavior[]> = EntityDefinition<F> & {
+  behaviors?: B;
+};
+/**
+ * A fully resolved entity with merged behavior fields.
+ * @typeParam AllFields - The complete field map (id + behaviors + user fields).
+ */
+interface Entity<AllFields extends Record<string, FieldConfig> = Record<string, FieldConfig>> {
+  name: string;
+  kind?: 'collection' | 'singleton';
+  fields: Record<string, FieldConfig>;
+  behaviors?: Behavior[];
+  scope?: 'global' | 'team' | 'user';
+  access?: {
+    view?: string;
+    create?: string;
+    update?: string;
+    delete?: string;
+  };
+  /** Admin UI configuration — controls sidebar, list, and form display */
+  admin?: EntityAdminConfig;
+  allFields: AllFields;
+  hooks: Behavior['hooks'];
+}
+/**
+ * Extract and intersect behavior field types from a behaviors tuple.
+ * Walks the tuple recursively (depth bounded by number of behaviors, max ~5).
+ */
+type ExtractBehaviorFields<B extends Behavior[]> = B extends [Behavior<infer F1>, ...infer Rest extends Behavior[]] ? F1 & ExtractBehaviorFields<Rest> : {};
+/**
+ * Define an entity with full type inference.
+ *
+ * @example
+ * const Article = defineEntity({
+ *   name: 'article',
+ *   fields: {
+ *     title: field.text({ required: true }),
+ *     featured: field.boolean(),
+ *   },
+ *   behaviors: [publishable(), auditable()],
+ * })
+ *
+ * type ArticleDTO = InferEntity<typeof Article>
+ * // { id: string; title: string; featured?: boolean | null; status?: ...; createdAt?: ...; }
+ */
+declare function defineEntity<F extends Record<string, FieldConfig>, const B extends Behavior[] = []>(definition: EntityDefinition<F> & {
+  behaviors?: B;
+}): Entity<{
+  id: IdField;
+} & ExtractBehaviorFields<B> & F>;
+//#endregion
+//#region src/refs/find-usages.d.ts
+interface EntityUsage {
+  sourceEntity: string;
+  sourceId: string;
+  sourceField: string;
+}
+//#endregion
+//#region src/refs/errors.d.ts
+declare class ReferencedEntityError extends Error {
+  readonly entityName: string;
+  readonly entityId: string;
+  readonly usages: EntityUsage[];
+  constructor(entityName: string, entityId: string, usages: EntityUsage[]);
+}
+//#endregion
+//#region src/schema-generator.d.ts
+/**
+ * Generate a runtime Drizzle schema from an entity definition.
+ * Every field becomes its own column — no JSONB.
+ */
+declare function generateSchema(entity: Entity): _$drizzle_orm_pg_core0.PgTableWithColumns<{
+  name: string;
+  schema: undefined;
+  columns: {
+    [x: string]: _$drizzle_orm_pg_core0.PgColumn<{
+      name: string;
+      tableName: string;
+      dataType: _$drizzle_orm0.ColumnDataType;
+      columnType: string;
+      data: unknown;
+      driverParam: unknown;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: string[] | undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: "pg";
+}>;
+/**
+ * Generate TypeScript code string for an entity schema.
+ * Every field becomes its own column — no JSONB.
+ */
+declare function generateSchemaCode(entity: Entity): string;
+/**
+ * Generate runtime translation table schema.
+ * Each translatable field gets its own nullable column.
+ */
+declare function generateTranslationSchema(entity: Entity): _$drizzle_orm_pg_core0.PgTableWithColumns<{
+  name: string;
+  schema: undefined;
+  columns: {
+    [x: string]: _$drizzle_orm_pg_core0.PgColumn<{
+      name: string;
+      tableName: string;
+      dataType: _$drizzle_orm0.ColumnDataType;
+      columnType: string;
+      data: unknown;
+      driverParam: unknown;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: string[] | undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: "pg";
+}> | null;
+/**
+ * Generate TypeScript code string for a translation table.
+ * Each translatable field gets its own nullable column.
+ */
+declare function generateTranslationSchemaCode(entity: Entity): string | null;
+/**
+ * Check if an entity has any blocks fields
+ */
+declare function hasBlocksFields(entity: Entity): boolean;
+/**
+ * Generate layout table schema for entities with blocks fields.
+ * Stores block instances in a separate table with ordering.
+ *
+ * When blocks field has localized: false (default), locale is NULL (shared layout).
+ * When blocks field has localized: true, locale is set per-locale.
+ */
+declare function generateLayoutSchema(entity: Entity): _$drizzle_orm_pg_core0.PgTableWithColumns<{
+  name: string;
+  schema: undefined;
+  columns: {
+    id: _$drizzle_orm_pg_core0.PgColumn<{
+      name: "id";
+      tableName: string;
+      dataType: "string";
+      columnType: "PgUUID";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    entityId: _$drizzle_orm_pg_core0.PgColumn<{
+      name: "entity_id";
+      tableName: string;
+      dataType: "string";
+      columnType: "PgUUID";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    fieldName: _$drizzle_orm_pg_core0.PgColumn<{
+      name: "field_name";
+      tableName: string;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 100;
+    }>;
+    blockType: _$drizzle_orm_pg_core0.PgColumn<{
+      name: "block_type";
+      tableName: string;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 100;
+    }>;
+    sortOrder: _$drizzle_orm_pg_core0.PgColumn<{
+      name: "sort_order";
+      tableName: string;
+      dataType: "number";
+      columnType: "PgInteger";
+      data: number;
+      driverParam: string | number;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    data: _$drizzle_orm_pg_core0.PgColumn<{
+      name: "data";
+      tableName: string;
+      dataType: "json";
+      columnType: "PgJsonb";
+      data: unknown;
+      driverParam: unknown;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    locale: _$drizzle_orm_pg_core0.PgColumn<{
+      name: "locale";
+      tableName: string;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 10;
+    }>;
+  };
+  dialect: "pg";
+}> | null;
+/**
+ * Check if an entity has the versionable behavior
+ */
+declare function isVersionable(entity: Entity): boolean;
+/**
+ * Check if an entity needs a per-locale publish status table.
+ * Requires both publishable() behavior AND at least one translatable field.
+ */
+declare function needsLocaleStatus(entity: Entity): boolean;
+/**
+ * Generate TypeScript code string for a per-locale publish status table.
+ */
+declare function generateLocaleStatusCode(entity: Entity): string;
+/**
+ * Check if an entity is publishable (has publishable() behavior).
+ */
+declare function isPublishable(entity: Entity): boolean;
+/**
+ * Generate TypeScript code string for a drafts overlay table.
+ */
+declare function generateDraftsCode(entity: Entity): string;
+/**
+ * Generate TypeScript code string for the shared content locks table.
+ */
+declare function generateContentLocksCode(): string;
+/**
+ * Check if an entity has blocks fields with translatable block content (non-localized mode).
+ */
+declare function hasTranslatableBlocks(entity: Entity): boolean;
+/**
+ * Generate TypeScript code string for a layout table (blocks storage).
+ */
+declare function generateLayoutCode(entity: Entity): string;
+/**
+ * Generate TypeScript code string for a layout translation table.
+ */
+declare function generateLayoutTranslationCode(entity: Entity): string;
+/**
+ * Generate TypeScript code string for a versions table.
+ */
+declare function generateVersionsCode(entity: Entity): string;
+/**
+ * Generate layout translation table for non-localized blocks with translatable fields.
+ */
+declare function generateLayoutTranslationSchema(entity: Entity): _$drizzle_orm_pg_core0.PgTableWithColumns<{
+  name: string;
+  schema: undefined;
+  columns: {
+    id: _$drizzle_orm_pg_core0.PgColumn<{
+      name: "id";
+      tableName: string;
+      dataType: "string";
+      columnType: "PgUUID";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    layoutId: _$drizzle_orm_pg_core0.PgColumn<{
+      name: "layout_id";
+      tableName: string;
+      dataType: "string";
+      columnType: "PgUUID";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    locale: _$drizzle_orm_pg_core0.PgColumn<{
+      name: "locale";
+      tableName: string;
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 10;
+    }>;
+    fields: _$drizzle_orm_pg_core0.PgColumn<{
+      name: "fields";
+      tableName: string;
+      dataType: "json";
+      columnType: "PgJsonb";
+      data: unknown;
+      driverParam: unknown;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: "pg";
+}> | null;
+//#endregion
+export { type AuditableFields, type Behavior, type BehaviorFactory, type BlockDefinitionRef, type BlocksField, type BooleanField, CountCache, type CountCacheLike, type CursorInput, type DateField, type Entity, type EntityAdminConfig, type EntityDefinition, type EntityInput, type EntityUsage, type FieldConfig, type FieldToTS, type HierarchicalFields, type IdField, type InferCreateInput, type InferEntity, type InferEntityDTO, type InferUpdateInput, type JsonField, type MediaField, type NumberField, type PublishableFields, type ReferenceField, ReferencedEntityError, type RevisionableFields, type RichTextField, type SelectField, type SlugField, type SluggableFields, type SluggableOptions, type TextField, auditable, behavior, buildCursorCondition, decodeCursor, defineEntity, encodeCursor, estimateRowCount, field, generateContentLocksCode, generateDraftsCode, generateLayoutCode, generateLayoutSchema, generateLayoutTranslationCode, generateLayoutTranslationSchema, generateLocaleStatusCode, generateSchema, generateSchemaCode, generateTranslationSchema, generateTranslationSchemaCode, generateVersionsCode, hasBlocksFields, hasTranslatableBlocks, hierarchical, isPublishable, isVersionable, needsLocaleStatus, publishable, revisionable, sluggable, slugify, timestamped };
+//# sourceMappingURL=index.d.mts.map