@prisma-next/sql-contract-ts 0.9.0 → 0.10.0

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@prisma-next/sql-contract-ts",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL-specific TypeScript contract authoring surface for Prisma Next",
   "dependencies": {
-    "@prisma-next/config": "0.9.0",
-    "@prisma-next/contract": "0.9.0",
-    "@prisma-next/contract-authoring": "0.9.0",
-    "@prisma-next/framework-components": "0.9.0",
-    "@prisma-next/sql-contract": "0.9.0",
-    "@prisma-next/utils": "0.9.0",
+    "@prisma-next/config": "0.10.0",
+    "@prisma-next/contract": "0.10.0",
+    "@prisma-next/contract-authoring": "0.10.0",
+    "@prisma-next/framework-components": "0.10.0",
+    "@prisma-next/sql-contract": "0.10.0",
+    "@prisma-next/utils": "0.10.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3",
     "ts-toolbelt": "^9.6.0"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.9.0",
-    "@prisma-next/tsconfig": "0.9.0",
+    "@prisma-next/test-utils": "0.10.0",
+    "@prisma-next/tsconfig": "0.10.0",
     "@types/pg": "8.20.0",
     "pg": "8.20.0",
-    "@prisma-next/tsdown": "0.9.0",
+    "@prisma-next/tsdown": "0.10.0",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.6"

package/src/build-contract.ts

@@ -17,7 +17,7 @@ import {
   type StorageHashBase,
 } from '@prisma-next/contract/types';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
-import { UNSPECIFIED_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import { type Namespace, UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import { validateIndexTypes } from '@prisma-next/sql-contract/index-type-validation';
 import {
   createIndexTypeRegistry,
@@ -28,10 +28,12 @@ import {
   applyFkDefaults,
   isPostgresEnumStorageEntry,
   type PostgresEnumStorageEntry,
+  type SqlNamespaceTablesInput,
   SqlStorage,
-  SqlUnspecifiedNamespace,
+  type SqlStorageInput,
   type StorageColumn,
-  type StorageTable,
+  StorageTable,
+  type StorageTableInput,
   type StorageTypeInstance,
   toStorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
@@ -209,6 +211,71 @@ function buildDomainField(
   };
 }
 
+function collectStorageNamespaceCoordinateIds(definition: ContractDefinition): Set<string> {
+  const ids = new Set<string>();
+  ids.add(UNBOUND_NAMESPACE_ID);
+  for (const id of definition.namespaces ?? []) {
+    if (id.length > 0) {
+      ids.add(id);
+    }
+  }
+  for (const model of definition.models) {
+    if (model.namespaceId !== undefined && model.namespaceId.length > 0) {
+      ids.add(model.namespaceId);
+    }
+  }
+  return ids;
+}
+
+const POSTGRES_ENUM_NAMESPACE_ID = 'public';
+
+function partitionStorageTypesForTarget(
+  targetId: string,
+  types: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+  namespaceTypes?: Readonly<Record<string, Readonly<Record<string, PostgresEnumStorageEntry>>>>,
+): {
+  readonly documentTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+  readonly namespaceEnumTypesById: Record<string, Record<string, PostgresEnumStorageEntry>>;
+} {
+  const documentTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {};
+  const namespaceEnumTypesById: Record<string, Record<string, PostgresEnumStorageEntry>> = {};
+  for (const [name, entry] of Object.entries(types)) {
+    if (isPostgresEnumStorageEntry(entry)) {
+      if (targetId !== 'postgres') {
+        throw new Error(
+          `buildSqlContractFromDefinition: postgres enum "${name}" is only valid when target is "postgres" (got "${targetId}").`,
+        );
+      }
+      let slot = namespaceEnumTypesById[POSTGRES_ENUM_NAMESPACE_ID];
+      if (slot === undefined) {
+        slot = {};
+        namespaceEnumTypesById[POSTGRES_ENUM_NAMESPACE_ID] = slot;
+      }
+      slot[name] = entry;
+      continue;
+    }
+    documentTypes[name] = entry;
+  }
+  if (namespaceTypes !== undefined) {
+    for (const [nsId, enumsInNs] of Object.entries(namespaceTypes)) {
+      for (const [name, entry] of Object.entries(enumsInNs)) {
+        if (targetId !== 'postgres') {
+          throw new Error(
+            `buildSqlContractFromDefinition: postgres enum "${name}" is only valid when target is "postgres" (got "${targetId}").`,
+          );
+        }
+        let slot = namespaceEnumTypesById[nsId];
+        if (slot === undefined) {
+          slot = {};
+          namespaceEnumTypesById[nsId] = slot;
+        }
+        slot[name] = entry;
+      }
+    }
+  }
+  return { documentTypes, namespaceEnumTypesById };
+}
+
 export function buildSqlContractFromDefinition(
   definition: ContractDefinition,
   codecLookup?: CodecLookup,
@@ -217,7 +284,8 @@ export function buildSqlContractFromDefinition(
   const targetFamily = 'sql';
   const modelsByName = new Map(definition.models.map((m) => [m.modelName, m]));
 
-  const storageTables: Record<string, StorageTable> = {};
+  const tablesByNamespace: Record<string, Record<string, StorageTable>> = {};
+  const tableNameToNamespaceId = new Map<string, string>();
   const executionDefaults: ExecutionMutationDefault[] = [];
   const models: Record<string, ContractModel> = {};
   const roots: Record<string, string> = {};
@@ -276,6 +344,11 @@ export function buildSqlContractFromDefinition(
       }
     }
 
+    const namespaceId =
+      semanticModel.namespaceId !== undefined && semanticModel.namespaceId.length > 0
+        ? semanticModel.namespaceId
+        : UNBOUND_NAMESPACE_ID;
+
     const foreignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
       const targetModel = assertKnownTargetModel(
         modelsByName,
@@ -289,9 +362,18 @@ export function buildSqlContractFromDefinition(
         fk.references.table,
         'Foreign key',
       );
+      const targetNamespaceId =
+        fk.references.namespaceId ??
+        (targetModel.namespaceId !== undefined && targetModel.namespaceId.length > 0
+          ? targetModel.namespaceId
+          : UNBOUND_NAMESPACE_ID);
       return {
-        columns: fk.columns,
-        references: { table: fk.references.table, columns: fk.references.columns },
+        source: { namespaceId, tableName, columns: fk.columns },
+        target: {
+          namespaceId: targetNamespaceId,
+          tableName: fk.references.table,
+          columns: fk.references.columns,
+        },
         ...applyFkDefaults(
           {
             ...ifDefined('constraint', fk.constraint),
@@ -305,7 +387,15 @@ export function buildSqlContractFromDefinition(
       };
     });
 
-    storageTables[tableName] = {
+    const existingNs = tableNameToNamespaceId.get(tableName);
+    if (existingNs !== undefined && existingNs !== namespaceId) {
+      throw new Error(
+        `buildSqlContractFromDefinition: table "${tableName}" is mapped in namespace "${namespaceId}" but already exists in namespace "${existingNs}".`,
+      );
+    }
+    tableNameToNamespaceId.set(tableName, namespaceId);
+
+    const tableInput: StorageTableInput = {
       columns,
       uniques: (semanticModel.uniques ?? []).map((u) => ({
         columns: u.columns,
@@ -328,6 +418,18 @@ export function buildSqlContractFromDefinition(
         : {}),
     };
 
+    let nsTables = tablesByNamespace[namespaceId];
+    if (nsTables === undefined) {
+      nsTables = {};
+      tablesByNamespace[namespaceId] = nsTables;
+    }
+    if (nsTables[tableName] !== undefined) {
+      throw new Error(
+        `buildSqlContractFromDefinition: duplicate table "${tableName}" in namespace "${namespaceId}".`,
+      );
+    }
+    nsTables[tableName] = new StorageTable(tableInput);
+
     // --- Build contract model ---
 
     const storageFields: Record<string, { readonly column: string }> = {};
@@ -414,15 +516,39 @@ export function buildSqlContractFromDefinition(
       ];
     }),
   );
+  const { documentTypes, namespaceEnumTypesById } = partitionStorageTypesForTarget(
+    target,
+    storageTypes,
+    definition.namespaceTypes,
+  );
+  const namespaceCoordinateIds = collectStorageNamespaceCoordinateIds(definition);
+  for (const id of Object.keys(namespaceEnumTypesById)) {
+    namespaceCoordinateIds.add(id);
+  }
+  const { createNamespace } = definition;
+  const namespaces: Record<string, SqlNamespaceTablesInput | Namespace> = Object.fromEntries(
+    [...namespaceCoordinateIds].sort().map((id) => {
+      const enumTypes = namespaceEnumTypesById[id];
+      const nsInput: SqlNamespaceTablesInput = {
+        id,
+        tables: tablesByNamespace[id] ?? {},
+        ...ifDefined('types', enumTypes),
+      };
+      return [id, createNamespace ? createNamespace(nsInput) : nsInput];
+    }),
+  );
   const storageWithoutHash = {
-    tables: storageTables,
-    types: storageTypes,
-    namespaces: { [UNSPECIFIED_NAMESPACE_ID]: SqlUnspecifiedNamespace.instance },
+    types: documentTypes,
+    namespaces,
   };
   const storageHash: StorageHashBase<string> = definition.storageHash
     ? coreHash(definition.storageHash)
-    : computeStorageHash({ target, targetFamily, storage: storageWithoutHash });
-  const storage = new SqlStorage({ ...storageWithoutHash, storageHash });
+    : computeStorageHash({
+        target,
+        targetFamily,
+        storage: storageWithoutHash as Record<string, unknown>,
+      });
+  const storage = new SqlStorage({ ...storageWithoutHash, storageHash } as SqlStorageInput); // Builder types are wider than SqlStorageInput until SqlStorage normalises document types.
 
   const executionSection =
     executionDefaults.length > 0

package/src/composed-authoring-helpers.ts

@@ -119,7 +119,7 @@ type PackAwareModel<IndexTypes extends IndexTypeMap> = {
     Relations extends Record<string, AnyRelationBuilder> = Record<never, never>,
   >(
     modelName: ModelName,
-    input: { readonly fields: Fields; readonly relations?: Relations },
+    input: { readonly fields: Fields; readonly relations?: Relations; readonly namespace?: string },
   ): ContractModelBuilder<ModelName, Fields, Relations, undefined, undefined, IndexTypes>;
   <
     Fields extends Record<string, ScalarFieldBuilder>,
@@ -127,6 +127,7 @@ type PackAwareModel<IndexTypes extends IndexTypeMap> = {
   >(input: {
     readonly fields: Fields;
     readonly relations?: Relations;
+    readonly namespace?: string;
   }): ContractModelBuilder<undefined, Fields, Relations, undefined, undefined, IndexTypes>;
 };
 

package/src/contract-builder.ts

@@ -5,8 +5,10 @@ import type {
   FamilyPackRef,
   TargetPackRef,
 } from '@prisma-next/framework-components/components';
+import type { Namespace } from '@prisma-next/framework-components/ir';
 import type {
   PostgresEnumStorageEntry,
+  SqlNamespaceTablesInput,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import { buildSqlContractFromDefinition } from './build-contract';
@@ -35,6 +37,7 @@ export { buildSqlContractFromDefinition } from './build-contract';
 type ModelLike = {
   readonly stageOne: {
     readonly modelName?: string;
+    readonly namespace?: string;
     readonly fields: Record<string, ScalarFieldBuilder>;
     readonly relations: Record<string, RelationBuilder<RelationState>>;
   };
@@ -54,6 +57,7 @@ type ContractDefinition<
   Naming extends ContractInput['naming'] | undefined,
   StorageHash extends string | undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined,
+  Namespaces extends readonly string[] | undefined = undefined,
 > = {
   readonly family: Family;
   readonly target: Target;
@@ -62,6 +66,8 @@ type ContractDefinition<
   readonly storageHash?: StorageHash;
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
   readonly capabilities?: Capabilities;
+  readonly namespaces?: Namespaces;
+  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
   readonly types?: Types;
   readonly models?: Models;
   readonly codecLookup?: CodecLookup;
@@ -75,6 +81,7 @@ type ContractScaffold<
   Naming extends ContractInput['naming'] | undefined,
   StorageHash extends string | undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined,
+  Namespaces extends readonly string[] | undefined = undefined,
 > = {
   readonly family: Family;
   readonly target: Target;
@@ -83,6 +90,8 @@ type ContractScaffold<
   readonly storageHash?: StorageHash;
   readonly foreignKeyDefaults?: ForeignKeyDefaults;
   readonly capabilities?: Capabilities;
+  readonly namespaces?: Namespaces;
+  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
   readonly codecLookup?: CodecLookup;
 };
 
@@ -114,6 +123,126 @@ function validateTargetPackRef(
   }
 }
 
+/**
+ * Per-target reserved namespace names enforced by `defineContract` for
+ * SQL family contracts. Two categories:
+ *
+ * 1. **IR sentinels** (`__unbound__`, `__unspecified__`) — reserved on
+ *    every SQL target. The double-underscore decoration marks them as
+ *    framework-reserved coordinates; user code must not declare them
+ *    explicitly.
+ * 2. **Target-specific PSL keywords** — Postgres reserves the bare
+ *    `unbound` identifier for the late-binding opt-in
+ *    (`namespace unbound { … }`) so the TS surface must reject it from
+ *    `defineContract({ namespaces })` lists. SQLite has no schema
+ *    concept and rejects every non-empty namespaces list outright;
+ *    callers should declare `namespaces: []` or omit the field.
+ */
+function validateNamespaceDeclarations(
+  target: TargetPackRef<'sql', string>,
+  namespaces: readonly string[] | undefined,
+): void {
+  if (!namespaces) {
+    return;
+  }
+
+  if (target.targetId === 'sqlite' && namespaces.length > 0) {
+    throw new Error(
+      `defineContract: SQLite contracts cannot declare namespaces (SQLite has no schema concept; emitted DDL is always unqualified). Received namespaces: [${namespaces
+        .map((name) => `"${name}"`)
+        .join(', ')}].`,
+    );
+  }
+
+  const seen = new Set<string>();
+  for (const namespace of namespaces) {
+    if (namespace.length === 0) {
+      throw new Error('defineContract: namespace names cannot be empty.');
+    }
+    if (namespace.trim().length === 0) {
+      throw new Error(`defineContract: namespace name "${namespace}" cannot be whitespace-only.`);
+    }
+    if (namespace === '__unbound__' || namespace === '__unspecified__') {
+      throw new Error(
+        `defineContract: namespace name "${namespace}" is a reserved IR sentinel and cannot appear in the declared namespaces list.`,
+      );
+    }
+    if (target.targetId === 'postgres' && namespace === 'unbound') {
+      throw new Error(
+        `defineContract: namespace name "unbound" is reserved by Postgres for the late-binding opt-in (use \`namespace unbound { … }\` in PSL instead of declaring it as a regular schema).`,
+      );
+    }
+    if (seen.has(namespace)) {
+      throw new Error(`defineContract: namespaces list contains duplicate entry "${namespace}".`);
+    }
+    seen.add(namespace);
+  }
+}
+
+/**
+ * Per-model `namespace` validation paired with
+ * {@link validateNamespaceDeclarations}. Mirrors the reserved-name
+ * rules so the per-model surface stays consistent with the contract-
+ * level surface:
+ *
+ * - `__unbound__` / `__unspecified__` — reserved IR sentinels on
+ *   every SQL target.
+ * - `unbound` on Postgres — reserved for the PSL
+ *   `namespace unbound { … }` opt-in.
+ *
+ * Additionally enforces that each per-model `namespace` either
+ * references an entry in the contract's declared `namespaces` list or
+ * names the Postgres late-binding keyword (`unbound`) — the latter is
+ * not a "declared namespace" but is a legal opt-in only via PSL today,
+ * so the TS surface also rejects it on the per-model side and points
+ * authors at the PSL `namespace unbound { … }` block.
+ *
+ * The SQLite per-model `namespace` field is rejected outright (SQLite
+ * has no schema concept).
+ */
+function validatePerModelNamespaces(
+  target: TargetPackRef<'sql', string>,
+  namespaces: readonly string[] | undefined,
+  models: Record<string, ModelLike>,
+): void {
+  const declaredNamespaces = new Set<string>(namespaces ?? []);
+
+  for (const [modelKey, modelBuilder] of Object.entries(models)) {
+    const perModelNamespace = modelBuilder.stageOne.namespace;
+    if (perModelNamespace === undefined) {
+      continue;
+    }
+
+    if (target.targetId === 'sqlite') {
+      throw new Error(
+        `defineContract: model "${modelKey}" sets \`namespace: "${perModelNamespace}"\` but the target is SQLite (SQLite has no schema concept; remove the per-model \`namespace\` field).`,
+      );
+    }
+
+    if (perModelNamespace === '__unbound__' || perModelNamespace === '__unspecified__') {
+      throw new Error(
+        `defineContract: model "${modelKey}" sets \`namespace: "${perModelNamespace}"\` but that name is a reserved IR sentinel and cannot appear in user code.`,
+      );
+    }
+
+    if (target.targetId === 'postgres' && perModelNamespace === 'unbound') {
+      throw new Error(
+        `defineContract: model "${modelKey}" sets \`namespace: "unbound"\` but that name is reserved by Postgres for the late-binding opt-in (use \`namespace unbound { … }\` in PSL instead — there is no equivalent surface in the TS builder today).`,
+      );
+    }
+
+    if (!declaredNamespaces.has(perModelNamespace)) {
+      const hint =
+        declaredNamespaces.size > 0
+          ? ` Declared namespaces: [${[...declaredNamespaces].map((name) => `"${name}"`).join(', ')}].`
+          : ' The contract does not declare any namespaces; add `namespaces: ["…"]` to `defineContract` first.';
+      throw new Error(
+        `defineContract: model "${modelKey}" references namespace "${perModelNamespace}" but that name does not appear in the contract's declared \`namespaces\` list.${hint}`,
+      );
+    }
+  }
+}
+
 function validateExtensionPackRefs(
   target: TargetPackRef<'sql', string>,
   extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>,
@@ -152,6 +281,12 @@ function buildContractFromDsl(
 ): ReturnType<typeof buildSqlContractFromDefinition> {
   validateTargetPackRef(definition.family, definition.target);
   validateExtensionPackRefs(definition.target, definition.extensionPacks);
+  validateNamespaceDeclarations(definition.target, definition.namespaces);
+  validatePerModelNamespaces(
+    definition.target,
+    definition.namespaces,
+    (definition.models ?? {}) as Record<string, ModelLike>,
+  );
 
   return buildSqlContractFromDefinition(
     buildContractDefinition(definition),
@@ -174,6 +309,7 @@ export function defineContract<
   const Naming extends ContractInput['naming'] | undefined = undefined,
   const StorageHash extends string | undefined = undefined,
   const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
+  const Namespaces extends readonly string[] | undefined = undefined,
 >(
   definition: ContractDefinition<
     Family,
@@ -184,7 +320,8 @@ export function defineContract<
     Capabilities,
     Naming,
     StorageHash,
-    ForeignKeyDefaults
+    ForeignKeyDefaults,
+    Namespaces
   >,
 ): SqlContractResult<
   ContractDefinition<
@@ -196,7 +333,8 @@ export function defineContract<
     Capabilities,
     Naming,
     StorageHash,
-    ForeignKeyDefaults
+    ForeignKeyDefaults,
+    Namespaces
   >
 >;
 export function defineContract<
@@ -214,6 +352,7 @@ export function defineContract<
   const Naming extends ContractInput['naming'] | undefined = undefined,
   const StorageHash extends string | undefined = undefined,
   const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
+  const Namespaces extends readonly string[] | undefined = undefined,
 >(
   definition: ContractScaffold<
     Family,
@@ -222,7 +361,8 @@ export function defineContract<
     Capabilities,
     Naming,
     StorageHash,
-    ForeignKeyDefaults
+    ForeignKeyDefaults,
+    Namespaces
   >,
   factory: ContractFactory<Family, Target, Types, Models, ExtensionPacks>,
 ): SqlContractResult<
@@ -235,7 +375,8 @@ export function defineContract<
     Capabilities,
     Naming,
     StorageHash,
-    ForeignKeyDefaults
+    ForeignKeyDefaults,
+    Namespaces
   >
 >;
 export function defineContract(

package/src/contract-definition.ts

@@ -2,9 +2,11 @@ import type { ColumnDefault, ExecutionMutationDefaultPhases } from '@prisma-next
 import type { ForeignKeyDefaultsState } from '@prisma-next/contract-authoring';
 import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
+import type { Namespace } from '@prisma-next/framework-components/ir';
 import type {
   PostgresEnumStorageEntry,
   ReferentialAction,
+  SqlNamespaceTablesInput,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 
@@ -43,6 +45,13 @@ export interface ForeignKeyNode {
     readonly model: string;
     readonly table: string;
     readonly columns: readonly string[];
+    /**
+     * Namespace coordinate of the referenced table. When omitted the
+     * assembler resolves the coordinate from the referenced model node's
+     * own `namespaceId`; the field exists so authoring paths that already
+     * know the target namespace can stamp it explicitly.
+     */
+    readonly namespaceId?: string;
   };
   readonly name?: string;
   readonly onDelete?: ReferentialAction;
@@ -87,6 +96,17 @@ export interface ValueObjectNode {
 export interface ModelNode {
   readonly modelName: string;
   readonly tableName: string;
+  /**
+   * Resolved namespace coordinate for this model — the key into the
+   * parent contract's `SqlStorage.namespaces` map. Omitting the field
+   * (or setting it to the framework's `UNBOUND_NAMESPACE_ID` sentinel)
+   * selects the late-bound slot, which renders as unqualified DDL.
+   *
+   * Populated by per-target PSL interpreters from the resolved
+   * `namespace { … }` AST bucket; the TS builder also sets it from the
+   * per-model `namespace` field once that authoring surface lands.
+   */
+  readonly namespaceId?: string;
   readonly fields: readonly (FieldNode | ValueObjectFieldNode)[];
   readonly id?: PrimaryKeyNode;
   readonly uniques?: readonly UniqueConstraintNode[];
@@ -102,6 +122,26 @@ export interface ContractDefinition {
   readonly storageHash?: string;
   readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
   readonly storageTypes?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+  /**
+   * Enum types declared inside a named `namespace { enum … }` block,
+   * keyed first by namespace id then by type name. These are routed to
+   * `storage.namespaces[nsId].types` rather than the implicit fallback
+   * namespace used for top-level `storageTypes` enums.
+   */
+  readonly namespaceTypes?: Readonly<
+    Record<string, Readonly<Record<string, PostgresEnumStorageEntry>>>
+  >;
+  /**
+   * Declared namespace coordinates for this contract — populates
+   * `SqlStorage.namespaces` together with `createNamespace`.
+   */
+  readonly namespaces?: readonly string[];
+  /**
+   * Target-supplied factory that materialises a `Namespace` concretion
+   * for a declared namespace coordinate. Mirrors
+   * `ContractInput.createNamespace`.
+   */
+  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
   readonly models: readonly ModelNode[];
   readonly valueObjects?: readonly ValueObjectNode[];
 }