@prisma-next/sql-contract 0.8.0 → 0.9.0-dev.1

package/src/factories.ts

@@ -1,42 +1,32 @@
 import type { ScalarFieldType } from '@prisma-next/contract/types';
-import type {
+import {
+  applyFkDefaults,
   ForeignKey,
-  ForeignKeyOptions,
-  ForeignKeyReferences,
+  type ForeignKeyOptions,
   Index,
   PrimaryKey,
-  SqlModelFieldStorage,
-  SqlModelStorage,
+  type SqlModelFieldStorage,
+  type SqlModelStorage,
   StorageColumn,
+  type StorageColumnInput,
   StorageTable,
   UniqueConstraint,
 } from './types';
-import { applyFkDefaults } from './types';
 
 export function col(nativeType: string, codecId: string, nullable = false): StorageColumn {
-  return {
-    nativeType,
-    codecId,
-    nullable,
-  };
+  return new StorageColumn({ nativeType, codecId, nullable });
 }
 
 export function pk(...columns: readonly string[]): PrimaryKey {
-  return {
-    columns,
-  };
+  return new PrimaryKey({ columns });
 }
 
 export function unique(...columns: readonly string[]): UniqueConstraint {
-  return {
-    columns,
-  };
+  return new UniqueConstraint({ columns });
 }
 
 export function index(...columns: readonly string[]): Index {
-  return {
-    columns,
-  };
+  return new Index({ columns });
 }
 
 export function fk(
@@ -45,23 +35,20 @@ export function fk(
   refColumns: readonly string[],
   opts?: ForeignKeyOptions & { constraint?: boolean; index?: boolean },
 ): ForeignKey {
-  const references: ForeignKeyReferences = {
-    table: refTable,
-    columns: refColumns,
-  };
-
-  return {
+  const defaults = applyFkDefaults({ constraint: opts?.constraint, index: opts?.index });
+  return new ForeignKey({
     columns,
-    references,
+    references: { table: refTable, columns: refColumns },
     ...(opts?.name !== undefined && { name: opts.name }),
     ...(opts?.onDelete !== undefined && { onDelete: opts.onDelete }),
     ...(opts?.onUpdate !== undefined && { onUpdate: opts.onUpdate }),
-    ...applyFkDefaults({ constraint: opts?.constraint, index: opts?.index }),
-  };
+    constraint: defaults.constraint,
+    index: defaults.index,
+  });
 }
 
 export function table(
-  columns: Record<string, StorageColumn>,
+  columns: Record<string, StorageColumn | StorageColumnInput>,
   opts?: {
     pk?: PrimaryKey;
     uniques?: readonly UniqueConstraint[];
@@ -69,13 +56,13 @@ export function table(
     fks?: readonly ForeignKey[];
   },
 ): StorageTable {
-  return {
+  return new StorageTable({
     columns,
     ...(opts?.pk !== undefined && { primaryKey: opts.pk }),
     uniques: opts?.uniques ?? [],
     indexes: opts?.indexes ?? [],
     foreignKeys: opts?.fks ?? [],
-  };
+  });
 }
 
 export function model(

package/src/index-type-validation.ts

@@ -1,5 +1,5 @@
+import { ContractValidationError } from '@prisma-next/contract/contract-validation-error';
 import type { Contract } from '@prisma-next/contract/types';
-import { ContractValidationError } from '@prisma-next/contract/validate-contract';
 import { type } from 'arktype';
 import type { IndexTypeRegistry } from './index-types';
 import type { SqlStorage } from './types';

package/src/index.ts

@@ -2,5 +2,4 @@ export * from './exports/factories';
 export * from './exports/index-type-validation';
 export * from './exports/index-types';
 export * from './exports/types';
-export * from './exports/validate';
 export * from './exports/validators';

package/src/ir/foreign-key-references.ts

@@ -0,0 +1,26 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlNode } from './sql-node';
+
+export interface ForeignKeyReferencesInput {
+  readonly table: string;
+  readonly columns: readonly string[];
+}
+
+/**
+ * SQL Contract IR node for the referenced side of a foreign key.
+ *
+ * The class is shaped around single-namespace references today; a
+ * future milestone introduces a cross-namespace coordinate on top of
+ * `(table, columns)` when namespace-keyed storage lands.
+ */
+export class ForeignKeyReferences extends SqlNode {
+  readonly table: string;
+  readonly columns: readonly string[];
+
+  constructor(input: ForeignKeyReferencesInput) {
+    super();
+    this.table = input.table;
+    this.columns = input.columns;
+    freezeNode(this);
+  }
+}

package/src/ir/foreign-key.ts

@@ -0,0 +1,50 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { ForeignKeyReferences, type ForeignKeyReferencesInput } from './foreign-key-references';
+import { SqlNode } from './sql-node';
+
+export type ReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
+
+export interface ForeignKeyInput {
+  readonly columns: readonly string[];
+  readonly references: ForeignKeyReferences | ForeignKeyReferencesInput;
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  /** Whether to emit FK constraint DDL (ALTER TABLE … ADD CONSTRAINT … FOREIGN KEY). */
+  readonly constraint: boolean;
+  /** Whether to emit a backing index for the FK columns. */
+  readonly index: boolean;
+}
+
+/**
+ * SQL Contract IR node for a table-level foreign-key declaration.
+ *
+ * The nested `references` field is normalised to a
+ * {@link ForeignKeyReferences} instance inside the constructor so
+ * downstream walks see a uniform AST regardless of whether the input
+ * was a JSON literal or an already-constructed class instance.
+ */
+export class ForeignKey extends SqlNode {
+  readonly columns: readonly string[];
+  readonly references: ForeignKeyReferences;
+  readonly constraint: boolean;
+  readonly index: boolean;
+  declare readonly name?: string;
+  declare readonly onDelete?: ReferentialAction;
+  declare readonly onUpdate?: ReferentialAction;
+
+  constructor(input: ForeignKeyInput) {
+    super();
+    this.columns = input.columns;
+    this.references =
+      input.references instanceof ForeignKeyReferences
+        ? input.references
+        : new ForeignKeyReferences(input.references);
+    this.constraint = input.constraint;
+    this.index = input.index;
+    if (input.name !== undefined) this.name = input.name;
+    if (input.onDelete !== undefined) this.onDelete = input.onDelete;
+    if (input.onUpdate !== undefined) this.onUpdate = input.onUpdate;
+    freezeNode(this);
+  }
+}

package/src/ir/postgres-enum-storage-entry.ts

@@ -0,0 +1,55 @@
+import type { StorageType } from '@prisma-next/framework-components/ir';
+
+/**
+ * Discriminator literal for the Postgres-enum variant on the polymorphic
+ * `SqlStorage.types` slot.
+ *
+ * Enums are a target-level concept: Postgres ships native
+ * `CREATE TYPE … AS ENUM` while other SQL targets approximate enums via
+ * constraints. The literal lives at the SQL family layer because every
+ * SQL-family consumer (verifier, planner, lowering, …) needs to
+ * discriminate enum-typed slot entries from codec-typed ones. The
+ * concrete IR class (`PostgresEnumType`) lives in the target-postgres
+ * package and implements this structural contract; cross-domain
+ * layering rules forbid the SQL family from importing the concrete
+ * target class directly, so the discriminator and structural interface
+ * carry the dispatch.
+ */
+export const POSTGRES_ENUM_KIND = 'postgres-enum' as const;
+
+/**
+ * Structural contract every Postgres-enum slot entry honours — both
+ * the live `PostgresEnumType` IR-class instance and the raw JSON
+ * envelope shape that survives `JSON.stringify` round-trips. SQL
+ * family-layer dispatch narrows polymorphic `StorageType` slot
+ * entries to this shape via `isPostgresEnumStorageEntry`.
+ *
+ * The `codecBinding` field is accessor-shaped (live class instance) on
+ * the IR class and undefined on the raw JSON envelope; consumers that
+ * need it must guard for its presence (the JSON path synthesises an
+ * equivalent shape from `codecId` + `values`).
+ */
+export interface PostgresEnumStorageEntry extends StorageType {
+  readonly kind: typeof POSTGRES_ENUM_KIND;
+  readonly name: string;
+  readonly nativeType: string;
+  readonly values: readonly string[];
+  /**
+   * Enumerable own property on the persisted JSON envelope; the live
+   * IR-class instance carries it too. Family-shared dispatch sites
+   * read `codecId` directly rather than going through the IR-class
+   * `codecBinding` accessor (which lives on the prototype and isn't
+   * present on raw JSON envelopes).
+   */
+  readonly codecId: string;
+}
+
+/**
+ * Narrow a polymorphic `StorageType` entry to the Postgres-enum shape
+ * via its enumerable `kind` discriminator. Type guard returns true for
+ * both live `PostgresEnumType` instances and raw JSON envelopes.
+ */
+export function isPostgresEnumStorageEntry(value: unknown): value is PostgresEnumStorageEntry {
+  if (typeof value !== 'object' || value === null) return false;
+  return (value as { kind?: unknown }).kind === POSTGRES_ENUM_KIND;
+}

package/src/ir/primary-key.ts

@@ -0,0 +1,22 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlNode } from './sql-node';
+
+export interface PrimaryKeyInput {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+
+/**
+ * SQL Contract IR node for a table's primary-key constraint.
+ */
+export class PrimaryKey extends SqlNode {
+  readonly columns: readonly string[];
+  declare readonly name?: string;
+
+  constructor(input: PrimaryKeyInput) {
+    super();
+    this.columns = input.columns;
+    if (input.name !== undefined) this.name = input.name;
+    freezeNode(this);
+  }
+}

package/src/ir/sql-index.ts

@@ -0,0 +1,33 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlNode } from './sql-node';
+
+export interface IndexInput {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+}
+
+/**
+ * SQL Contract IR node for a table-level secondary index.
+ *
+ * Note that this class shadows the global TypeScript `Index` lib type
+ * at the family-shared name; consumer files that need both should
+ * alias one (e.g.
+ * `import { Index as SqlIndexNode } from '@prisma-next/sql-contract/types'`).
+ */
+export class Index extends SqlNode {
+  readonly columns: readonly string[];
+  declare readonly name?: string;
+  declare readonly type?: string;
+  declare readonly options?: Record<string, unknown>;
+
+  constructor(input: IndexInput) {
+    super();
+    this.columns = input.columns;
+    if (input.name !== undefined) this.name = input.name;
+    if (input.type !== undefined) this.type = input.type;
+    if (input.options !== undefined) this.options = input.options;
+    freezeNode(this);
+  }
+}

package/src/ir/sql-node.ts

@@ -0,0 +1,52 @@
+import { IRNodeBase } from '@prisma-next/framework-components/ir';
+
+/**
+ * SQL family IR node base. Carries the family-level `kind` discriminator
+ * `'sql'` and inherits the framework's `freezeNode` affordance.
+ *
+ * Single family-level discriminator (not per-leaf) reflects the fact that
+ * SQL IR has no polymorphic dispatch today — verifiers and serializers
+ * walk by structural position (`storage.tables[name].columns[name]`),
+ * not by inspecting `kind`. The abstract bar for per-leaf discriminators
+ * isn't earned until a future polymorphic consumer arrives.
+ *
+ * `kind` is installed as a non-enumerable own property on every instance,
+ * which keeps three things clean simultaneously:
+ *
+ * - `JSON.stringify(node)` produces the canonical pre-lift JSON envelope
+ *   shape (no `kind` field), so emitted contract.json files and the
+ *   `validateSqlContractFully` arktype schemas stay unchanged.
+ * - Test assertions that use `toEqual({...})` against the pre-lift flat
+ *   shape continue to pass — only enumerable own properties are
+ *   compared.
+ * - Direct access (`node.kind`) and runtime narrowing
+ *   (`if (node.kind === 'sql')`) still work, so future polymorphic
+ *   dispatch can begin reading `kind` without a runtime change.
+ *
+ * Future per-leaf overrides land cleanly: a class that gains a
+ * polymorphic-dispatch consumer (e.g. an enum type instance walked
+ * alongside other types) overrides `kind` with its narrower literal
+ * at that leaf level. Per-leaf overrides will use enumerable kind
+ * (matching the Mongo per-class-discriminator precedent) because they
+ * encode dispatch-relevant information that callers need to see in
+ * JSON envelopes; the family-level `'sql'` is uniform across all SQL
+ * IR and carries no dispatch-relevant information.
+ */
+export abstract class SqlNode extends IRNodeBase {
+  readonly kind?: string;
+
+  constructor() {
+    super();
+    Object.defineProperty(this, 'kind', {
+      value: 'sql',
+      writable: false,
+      enumerable: false,
+      // configurable so per-leaf subclasses (e.g. PostgresEnumType in
+      // target-postgres) can override `kind` with their narrower
+      // enumerable literal via a class-field initializer. SqlNode
+      // itself never needs to mutate the property again, so
+      // configurability has no surface impact at this layer.
+      configurable: true,
+    });
+  }
+}

package/src/ir/sql-storage.ts

@@ -0,0 +1,154 @@
+import type { StorageHashBase } from '@prisma-next/contract/types';
+import {
+  freezeNode,
+  type Namespace,
+  type Storage,
+  UNSPECIFIED_NAMESPACE_ID,
+} from '@prisma-next/framework-components/ir';
+import {
+  isPostgresEnumStorageEntry,
+  type PostgresEnumStorageEntry,
+} from './postgres-enum-storage-entry';
+import { SqlNode } from './sql-node';
+import { SqlUnspecifiedNamespace } from './sql-unspecified-namespace';
+import { StorageTable, type StorageTableInput } from './storage-table';
+import {
+  isStorageTypeInstance,
+  type StorageTypeInstance,
+  type StorageTypeInstanceInput,
+} from './storage-type-instance';
+
+/**
+ * Polymorphic value type for `SqlStorage.types` entries (Decision 18,
+ * Option B). The slot's framework alphabet is `StorageType` — codec
+ * triples (`StorageTypeInstance` with `kind: 'codec-instance'`) and
+ * target-specific IR class instances structurally satisfying
+ * `PostgresEnumStorageEntry` (with `kind: 'postgres-enum'`) are the
+ * two variants the SQL family ships today. The construction side also
+ * accepts {@link StorageTypeInstanceInput} so callers can pass raw
+ * codec triples; the constructor stamps the discriminator.
+ */
+export type SqlStorageTypeEntry =
+  | StorageTypeInstance
+  | PostgresEnumStorageEntry
+  | StorageTypeInstanceInput;
+
+const DEFAULT_NAMESPACES: Readonly<Record<string, Namespace>> = Object.freeze({
+  [UNSPECIFIED_NAMESPACE_ID]: SqlUnspecifiedNamespace.instance,
+});
+
+export interface SqlStorageInput<THash extends string = string> {
+  readonly storageHash: StorageHashBase<THash>;
+  readonly tables: Record<string, StorageTable | StorageTableInput>;
+  readonly types?: Record<string, SqlStorageTypeEntry>;
+  readonly namespaces?: Readonly<Record<string, Namespace>>;
+}
+
+/**
+ * SQL Contract IR root node for the `storage` field.
+ *
+ * Single concrete family-shared class — both Postgres and SQLite
+ * consume this same class today. Per-target storage subclasses are
+ * introduced when each target's namespace shape earns its
+ * target-specific concretion (target-specific derived fields,
+ * target-specific storage extensions).
+ *
+ * Honours the framework `Storage` interface: every SQL IR carries a
+ * `namespaces` map keyed by namespace id. The default singleton
+ * (`{ [UNSPECIFIED_NAMESPACE_ID]: SqlUnspecifiedNamespace.instance }`)
+ * binds every contract authored before per-target namespace concretions
+ * land; per-target namespace classes (`PostgresSchema.unspecified`,
+ * `SqliteUnspecifiedDatabase.instance`) earn their slots when each
+ * target's namespace shape lands.
+ *
+ * The constructor normalises nested IR-class fields (`tables`, optional
+ * `types`) into class instances so downstream walks see a uniform AST.
+ * `types` is polymorphic per Decision 18 Option B: codec-triple inputs
+ * are stamped with `kind: 'codec-instance'`; class-instance kinds
+ * (e.g. Postgres-enum entries satisfying `PostgresEnumStorageEntry`)
+ * pass through; hydration of raw JSON class-instance entries (carrying
+ * their narrower `kind` literal) is the per-target serializer's
+ * responsibility (so the family base does not import target-specific
+ * subclasses).
+ */
+export class SqlStorage<THash extends string = string> extends SqlNode implements Storage {
+  readonly storageHash: StorageHashBase<THash>;
+  readonly tables: Readonly<Record<string, StorageTable>>;
+  readonly namespaces: Readonly<Record<string, Namespace>>;
+  // SQL-family slot view: the two structural variants the family ships
+  // today (codec triples + Postgres-enum structural entries). Each
+  // variant extends the framework `StorageType` alphabet; the SQL
+  // narrowing keeps cross-domain layering clean — SQL-family consumers
+  // dispatch via `isStorageTypeInstance` / `isPostgresEnumStorageEntry`
+  // type guards rather than importing the target's concrete IR class
+  // (cross-domain rule: SQL may not import `target-*`).
+  declare readonly types?: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;
+
+  constructor(input: SqlStorageInput<THash>) {
+    super();
+    this.storageHash = input.storageHash;
+    this.tables = Object.freeze(
+      Object.fromEntries(
+        Object.entries(input.tables).map(([name, t]) => [
+          name,
+          t instanceof StorageTable ? t : new StorageTable(t),
+        ]),
+      ),
+    );
+    this.namespaces = input.namespaces ?? DEFAULT_NAMESPACES;
+    if (input.types !== undefined) {
+      this.types = Object.freeze(
+        Object.fromEntries(
+          Object.entries(input.types).map(([name, ti]) => [name, normaliseTypeEntry(name, ti)]),
+        ),
+      );
+    }
+    freezeNode(this);
+  }
+}
+
+/**
+ * Strict polymorphic-slot dispatch for `SqlStorage.types` entries
+ * (TML-2536). Every entry must carry a recognised `kind` discriminator
+ * — either `'codec-instance'` (codec triple, family-shared) or
+ * `'postgres-enum'` (target-specific IR class). Untagged or
+ * unrecognised inputs throw a diagnostic naming the entry and its
+ * `kind`, so format drift surfaces loudly at the deserializer
+ * boundary instead of slipping past the seam and corrupting
+ * downstream IR walks.
+ *
+ * Codec-triple authors that have an untagged shape on hand can call
+ * `toStorageTypeInstance(...)` (which stamps the `'codec-instance'`
+ * discriminator) before constructing `SqlStorage`. On-disk reads
+ * cross `familyInstance.deserializeContract` first; the structural
+ * arktype schema rejects untagged entries earlier, so this throw
+ * only fires for in-memory authoring bugs.
+ */
+function normaliseTypeEntry(
+  name: string,
+  entry: SqlStorageTypeEntry,
+): StorageTypeInstance | PostgresEnumStorageEntry {
+  if (isPostgresEnumStorageEntry(entry)) {
+    // Live class instances pass through unchanged; raw JSON envelopes
+    // (e.g. `kind: 'postgres-enum'` without the class identity) are
+    // rejected so the target serializer's hydration path is the only
+    // way IR class instances enter the slot.
+    if (entry instanceof SqlNode) {
+      return entry;
+    }
+    throw new Error(
+      `Encountered raw postgres-enum JSON in storage.types[${JSON.stringify(name)}] without serializer hydration; use a target ContractSerializer that registers the matching entity-type factory.`,
+    );
+  }
+  if (isStorageTypeInstance(entry)) {
+    return entry;
+  }
+  const rawKind = (entry as { kind?: unknown }).kind;
+  const kindDescription =
+    rawKind === undefined
+      ? 'missing `kind` discriminator'
+      : `unrecognised \`kind\` discriminator ${JSON.stringify(rawKind)}`;
+  throw new Error(
+    `storage.types[${JSON.stringify(name)}] has ${kindDescription}; expected ${JSON.stringify('codec-instance')} or ${JSON.stringify('postgres-enum')}. Untagged codec triples should be wrapped with toStorageTypeInstance(...) before construction.`,
+  );
+}

package/src/ir/sql-unspecified-namespace.ts

@@ -0,0 +1,51 @@
+import {
+  freezeNode,
+  NamespaceBase,
+  UNSPECIFIED_NAMESPACE_ID,
+} from '@prisma-next/framework-components/ir';
+
+/**
+ * Family-layer placeholder for the SQL unspecified-namespace singleton.
+ *
+ * SQL contracts honour the framework `Storage.namespaces` invariant from
+ * the moment they appear in the IR. Today `SqlStorage` is family-shared
+ * (Postgres + SQLite consume the same class); a per-target namespace
+ * concretion (`PostgresSchema.unspecified`, `SqliteUnspecifiedDatabase.instance`)
+ * earns its existence when each target's namespace shape lands. Until
+ * then the family ships a single placeholder singleton so the JSON
+ * envelope and runtime walk are honest at every layer.
+ *
+ * The `kind` discriminator is installed as a non-enumerable own property
+ * so the JSON envelope reads `{ "id": "__unspecified__" }` — symmetric
+ * with the family-level non-enumerable `kind` on `SqlNode` and bounded
+ * to the minimum data the framework `Namespace` interface promises.
+ *
+ * **Freeze-trap warning.** The leaf constructor calls
+ * `freezeNode(this)` after installing `kind`. The leaf-class shape
+ * works today only because `NamespaceBase` does NOT freeze in its
+ * constructor — the `Object.defineProperty(this, 'kind', …)` call after
+ * `super()` succeeds because the instance is still mutable at that
+ * point. Subclasses that add instance fields will still hit the freeze
+ * trap once leaf-class `freezeNode(this)` runs; and if a future
+ * framework change lifts the freeze to `NamespaceBase`, even the
+ * `defineProperty` here would silently fail. To add subclass instance
+ * fields safely, lift `freezeNode` to a leaf-class `seal()` hook each
+ * leaf calls explicitly at the end of its own constructor.
+ */
+export class SqlUnspecifiedNamespace extends NamespaceBase {
+  static readonly instance: SqlUnspecifiedNamespace = new SqlUnspecifiedNamespace();
+
+  readonly id = UNSPECIFIED_NAMESPACE_ID;
+  declare readonly kind?: string;
+
+  private constructor() {
+    super();
+    Object.defineProperty(this, 'kind', {
+      value: 'sql-namespace',
+      writable: false,
+      enumerable: false,
+      configurable: true,
+    });
+    freezeNode(this);
+  }
+}

package/src/ir/storage-column.ts

@@ -0,0 +1,55 @@
+import type { ColumnDefault } from '@prisma-next/contract/types';
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlNode } from './sql-node';
+
+/**
+ * Hydration / construction input shape for {@link StorageColumn}. Mirrors
+ * the on-disk storage JSON envelope exactly so the family-base
+ * serializer's hydration walker can hand an arktype-validated literal
+ * straight to `new`.
+ *
+ * `typeParams` and `typeRef` remain mutually exclusive (one or the
+ * other, not both); the constructor preserves whichever caller-side
+ * choice the input encodes.
+ */
+export interface StorageColumnInput {
+  readonly nativeType: string;
+  readonly codecId: string;
+  readonly nullable: boolean;
+  readonly typeParams?: Record<string, unknown>;
+  readonly typeRef?: string;
+  readonly default?: ColumnDefault;
+}
+
+/**
+ * SQL Contract IR node for a single column entry in `StorageTable.columns`.
+ *
+ * Single concrete family-shared class — every SQL target reads the
+ * same column shape today, so there is no per-target subclass. The
+ * class type accepts any caller that constructs via
+ * `new StorageColumn(input)`; literal construction sites must pass
+ * through the constructor or the family-base hydration walker.
+ *
+ * The column's `name` is not on the class — columns are keyed by name
+ * in the parent `StorageTable.columns: Record<string, StorageColumn>`
+ * map, so a `name` field would be redundant with the key.
+ */
+export class StorageColumn extends SqlNode {
+  readonly nativeType: string;
+  readonly codecId: string;
+  readonly nullable: boolean;
+  declare readonly typeParams?: Record<string, unknown>;
+  declare readonly typeRef?: string;
+  declare readonly default?: ColumnDefault;
+
+  constructor(input: StorageColumnInput) {
+    super();
+    this.nativeType = input.nativeType;
+    this.codecId = input.codecId;
+    this.nullable = input.nullable;
+    if (input.typeParams !== undefined) this.typeParams = input.typeParams;
+    if (input.typeRef !== undefined) this.typeRef = input.typeRef;
+    if (input.default !== undefined) this.default = input.default;
+    freezeNode(this);
+  }
+}