@dbsp/core 1.11.1 → 3.0.0

package/dist/index.js

@@ -687,6 +687,13 @@ var SchemaValidationError = class extends Error {
   table;
   column;
 };
+function validateSchemaIndexOptions(tableName, idx) {
+  if (idx.nullsNotDistinct === true && idx.unique !== true) {
+    throw new SchemaValidationError(
+      `Index "${idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`}" on "${tableName}" cannot use nullsNotDistinct unless unique is true`
+    );
+  }
+}
 function schemaToModelIR(definition, constraints, extras, options) {
   if (typeof options?.defaultPkColumnName === "string" && options.defaultPkColumnName.trim().length === 0) {
     throw new SchemaValidationError(
@@ -1095,13 +1102,18 @@ function buildTableConstraints(tableName, constraints) {
   }
   if (tableConstraints.indexes) {
     for (const idx of tableConstraints.indexes) {
+      validateSchemaIndexOptions(tableName, idx);
       const indexIR = {
         name: idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`,
         columns: idx.columns,
         unique: idx.unique ?? false
       };
+      if (idx.nullsNotDistinct !== void 0) {
+        indexIR.nullsNotDistinct = idx.nullsNotDistinct;
+      }
       if (idx.method) indexIR.method = idx.method;
       if (idx.where) indexIR.where = idx.where;
+      if (idx.include !== void 0) indexIR.include = idx.include;
       if (idx.opclass) indexIR.opclass = idx.opclass;
       if (idx.with) indexIR.with = idx.with;
       extraIndexes.push(indexIR);
@@ -1489,12 +1501,6 @@ async function getSchemaFromDb(adapter, options) {
 }
 
 // src/conventions.ts
-var DEFAULT_CONVENTIONS = {
-  fkPattern: "{singular}Id",
-  pluralize: true,
-  timestamps: ["createdAt", "updatedAt"],
-  fkAutoIndex: true
-};
 var IRREGULAR_PLURALS = {
   people: "person",
   children: "child",
@@ -1553,257 +1559,6 @@ function capitalize(name) {
 function decapitalize(name) {
   return name.charAt(0).toLowerCase() + name.slice(1);
 }
-function getSelfRefInverseName(belongsToName) {
-  if (belongsToName === "parent") return "children";
-  return pluralize(belongsToName);
-}
-function detectForeignKeys(tableName, table, conventions, tableNames) {
-  const fks = [];
-  const pattern = conventions.fkPattern;
-  for (const [colName, colDef] of Object.entries(table)) {
-    if (colDef.references) {
-      const targetTable = colDef.references.table;
-      if (colDef.references.schema === void 0 && tableNames.has(targetTable)) {
-        const inferredName = colName.endsWith("Id") ? colName.slice(0, -2) : singularize(targetTable);
-        const isSelfRef = targetTable === tableName;
-        const detectedFK = {
-          column: colName,
-          targetTable,
-          inferredName,
-          explicit: true,
-          targetColumn: colDef.references.column ?? "id"
-        };
-        if (isSelfRef) {
-          detectedFK.parentRole = colDef.references.parentRole ?? inferredName;
-          detectedFK.childRole = colDef.references.childRole ?? getSelfRefInverseName(inferredName);
-        }
-        fks.push(detectedFK);
-      }
-      continue;
-    }
-    for (const candidateTable of tableNames) {
-      if (candidateTable === tableName) continue;
-      const singular = singularize(candidateTable);
-      const expectedColumn = pattern.replace("{singular}", singular);
-      if (colName === expectedColumn) {
-        fks.push({
-          column: colName,
-          targetTable: candidateTable,
-          inferredName: singular,
-          explicit: false,
-          targetColumn: "id"
-        });
-        break;
-      }
-    }
-    if (colName.endsWith("Id")) {
-      const prefix = colName.slice(0, -2);
-      const singular = singularize(tableName);
-      if (["parent", "manager", "supervisor", "owner", singular].includes(prefix)) {
-        if (!fks.some((fk) => fk.column === colName)) {
-          fks.push({
-            column: colName,
-            targetTable: tableName,
-            inferredName: prefix,
-            explicit: false,
-            targetColumn: "id",
-            // Auto-infer roles for convention-based self-ref FKs
-            parentRole: prefix,
-            childRole: getSelfRefInverseName(prefix)
-          });
-        }
-      }
-    }
-  }
-  return fks;
-}
-function isBusinessColumn(colName, colDef, timestamps) {
-  if (colDef.primaryKey) return false;
-  if (timestamps.includes(colName)) return false;
-  if (colDef.references) return false;
-  if (colName.endsWith("Id")) return false;
-  if (["id", "createdBy", "updatedBy", "deletedAt"].includes(colName))
-    return false;
-  return true;
-}
-function detectManyToMany(tables, conventions, tableNames) {
-  const results = [];
-  for (const [tableName, table] of Object.entries(tables)) {
-    const fks = detectForeignKeys(tableName, table, conventions, tableNames);
-    if (fks.length !== 2) continue;
-    const hasBusinessColumns = Object.entries(table).some(
-      ([colName, colDef]) => isBusinessColumn(colName, colDef, conventions.timestamps)
-    );
-    if (hasBusinessColumns) continue;
-    const fkA = fks[0];
-    const fkB = fks[1];
-    if (fkA && fkB) {
-      results.push({
-        junction: tableName,
-        tableA: fkA.targetTable,
-        tableB: fkB.targetTable,
-        fkA: fkA.column,
-        fkB: fkB.column
-      });
-    }
-  }
-  return results;
-}
-function inferRelationsFromSchema(tables, conventions, explicitRelations = {}) {
-  const result = { ...explicitRelations };
-  const tableNames = new Set(Object.keys(tables));
-  const manyToManys = detectManyToMany(tables, conventions, tableNames);
-  const junctionTables = new Set(manyToManys.map((m) => m.junction));
-  for (const m2m of manyToManys) {
-    const { junction, tableA, tableB, fkA, fkB } = m2m;
-    const relNameAtoB = conventions.pluralize ? pluralize(singularize(tableB)) : tableB;
-    const relNameBtoA = conventions.pluralize ? pluralize(singularize(tableA)) : tableA;
-    const keyAtoB = `${tableA}.${relNameAtoB}`;
-    const keyBtoA = `${tableB}.${relNameBtoA}`;
-    if (!(keyAtoB in result)) {
-      const rel = {
-        kind: "manyToMany",
-        target: tableB,
-        through: junction,
-        sourceFk: fkA,
-        targetFk: fkB
-      };
-      result[keyAtoB] = rel;
-    }
-    if (!(keyBtoA in result)) {
-      const rel = {
-        kind: "manyToMany",
-        target: tableA,
-        through: junction,
-        sourceFk: fkB,
-        targetFk: fkA
-      };
-      result[keyBtoA] = rel;
-    }
-  }
-  for (const [tableName, table] of Object.entries(tables)) {
-    if (junctionTables.has(tableName)) continue;
-    const fks = detectForeignKeys(tableName, table, conventions, tableNames);
-    for (const fk of fks) {
-      if (junctionTables.has(fk.targetTable)) continue;
-      const belongsToKey = `${tableName}.${fk.inferredName}`;
-      if (!(belongsToKey in result)) {
-        const rel = {
-          kind: "belongsTo",
-          target: fk.targetTable,
-          foreignKey: fk.column,
-          targetKey: fk.targetColumn
-        };
-        result[belongsToKey] = rel;
-      }
-      const isSelfRef = fk.targetTable === tableName;
-      const hasManyName = isSelfRef ? getSelfRefInverseName(fk.inferredName) : (() => {
-        const hasCustomAlias = fk.inferredName !== singularize(fk.targetTable);
-        if (hasCustomAlias) {
-          return conventions.pluralize ? pluralize(fk.inferredName) : fk.inferredName;
-        }
-        return conventions.pluralize ? pluralize(singularize(tableName)) : tableName;
-      })();
-      const hasManyKey = `${fk.targetTable}.${hasManyName}`;
-      if (!(hasManyKey in result)) {
-        const rel = {
-          kind: "hasMany",
-          target: tableName,
-          foreignKey: fk.column,
-          sourceKey: "id"
-        };
-        result[hasManyKey] = rel;
-      }
-    }
-  }
-  return result;
-}
-
-// src/schema-dsl.ts
-function defineSchema(tables, config) {
-  const relations = config?.relations ?? {};
-  const hints = config?.hints ?? {};
-  const conventions = config?.conventions ?? {};
-  const indexes = config?.indexes ?? {};
-  const defaultFilters = config?.defaultFilters ?? {};
-  const resolvedConventions = {
-    ...DEFAULT_CONVENTIONS,
-    ...conventions
-  };
-  const allRelations = inferRelationsFromSchema(
-    tables,
-    resolvedConventions,
-    relations
-  );
-  validateRelations(tables, relations);
-  validateHints(allRelations, hints);
-  validateDefaultFilters(tables, defaultFilters);
-  return {
-    tables,
-    relations: allRelations,
-    hints,
-    conventions: resolvedConventions,
-    indexes,
-    defaultFilters
-  };
-}
-function validateRelations(tables, relations) {
-  const tableNames = new Set(Object.keys(tables));
-  for (const [key, rel] of Object.entries(relations)) {
-    const sourceTable = key.split(".")[0] ?? key;
-    if (!tableNames.has(sourceTable)) {
-      throw new SchemaValidationError2(
-        `Relation '${key}' references non-existent source table '${sourceTable}'`
-      );
-    }
-    if (!tableNames.has(rel.target)) {
-      throw new SchemaValidationError2(
-        `Relation '${key}' references non-existent target table '${rel.target}'`
-      );
-    }
-    if (rel.kind === "manyToMany" && !tableNames.has(rel.through)) {
-      throw new SchemaValidationError2(
-        `Relation '${key}' references non-existent junction table '${rel.through}'`
-      );
-    }
-  }
-}
-function validateHints(relations, hints) {
-  for (const path of Object.keys(hints)) {
-    if (!(path in relations)) {
-      throw new SchemaValidationError2(
-        `Hint path '${path}' does not match any relation. Available: ${Object.keys(relations).join(", ")}`
-      );
-    }
-  }
-}
-function validateDefaultFilters(tables, defaultFilters) {
-  const tableNames = new Set(Object.keys(tables));
-  for (const tableName of Object.keys(defaultFilters)) {
-    if (!tableNames.has(tableName)) {
-      throw new SchemaValidationError2(
-        `Default filter for non-existent table '${tableName}'. Available: ${[...tableNames].join(", ")}`
-      );
-    }
-  }
-}
-var SchemaValidationError2 = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SchemaValidationError";
-  }
-};
-
-// src/schema-dsl-types.ts
-function isBelongsTo(rel) {
-  return rel.kind === "belongsTo";
-}
-function isHasMany(rel) {
-  return rel.kind === "hasMany";
-}
-function isManyToMany(rel) {
-  return rel.kind === "manyToMany";
-}
 
 // src/planner.ts
 import { resolveJsonAggOrderKey, toColumnList } from "@dbsp/types";
@@ -3191,13 +2946,13 @@ function supportsExecution(adapter) {
   return "execute" in adapter && "executeOne" in adapter && typeof adapter.execute === "function";
 }
 function supportsStreaming(adapter) {
-  return "stream" in adapter && typeof adapter.stream === "function";
+  return adapter.capabilities?.supportsStreaming === true && "stream" in adapter && typeof adapter.stream === "function";
 }
 function supportsIntrospection(adapter) {
   return "introspect" in adapter && typeof adapter.introspect === "function";
 }
 function supportsTransactions(adapter) {
-  return "transaction" in adapter && "withSchema" in adapter && typeof adapter.transaction === "function";
+  return adapter.capabilities?.supportsTransactions === true && "transaction" in adapter && "withSchema" in adapter && typeof adapter.transaction === "function";
 }
 function supportsRawSql(adapter) {
   return "executeRaw" in adapter && typeof adapter.executeRaw === "function";
@@ -6426,7 +6181,7 @@ function hydrateJsonAggIncludes(results, planReport) {
     if (typeof row !== "object" || row === null) {
       continue;
     }
-    const record2 = row;
+    const record = row;
     for (const [relationName, info] of relationInfo) {
       const candidates = [relationName];
       if (info.includeAlias && info.includeAlias !== relationName) {
@@ -6439,17 +6194,17 @@ function hydrateJsonAggIncludes(results, planReport) {
           /_([a-z])/g,
           (_, c) => c.toUpperCase()
         );
-        if (snakeJson in record2) {
+        if (snakeJson in record) {
           actualColumnName = snakeJson;
           break;
         }
-        if (camelJson in record2) {
+        if (camelJson in record) {
           actualColumnName = camelJson;
           break;
         }
       }
       if (actualColumnName) {
-        const jsonValue = record2[actualColumnName];
+        const jsonValue = record[actualColumnName];
         let parsed;
         if (typeof jsonValue === "string") {
           try {
@@ -6468,8 +6223,8 @@ function hydrateJsonAggIncludes(results, planReport) {
           parsed = parsed.length > 0 ? parsed[0] : null;
         }
         const outputKey = info.includeAlias ?? relationName;
-        record2[outputKey] = parsed;
-        delete record2[actualColumnName];
+        record[outputKey] = parsed;
+        delete record[actualColumnName];
       }
     }
   }
@@ -8398,12 +8153,12 @@ var ResultHydrator = class {
       if (typeof row !== "object" || row === null) {
         continue;
       }
-      const record2 = row;
+      const record = row;
       const valuesByPath = /* @__PURE__ */ new Map();
-      for (const key of Object.keys(record2)) {
+      for (const key of Object.keys(record)) {
         const info = findLongestJoinInfo(key, joinInfos);
         if (!info) continue;
-        const value = record2[key];
+        const value = record[key];
         let entry = valuesByPath.get(info.relationPath);
         if (!entry) {
           entry = { values: {}, allNull: true };
@@ -8415,13 +8170,13 @@ var ResultHydrator = class {
           value
         );
         if (value !== null && value !== void 0) entry.allNull = false;
-        delete record2[key];
+        delete record[key];
       }
       for (const info of infosByDepth) {
         const entry = valuesByPath.get(info.relationPath);
         if (!entry) continue;
         assignNestedValue(
-          record2,
+          record,
           info.segments,
           entry.allNull ? null : entry.values
         );
@@ -8651,10 +8406,10 @@ var ResultHydrator = class {
       return obj[columns[0]];
     }
     const values = columns.map((k) => obj[k]);
-    if (values.some((v2) => v2 === void 0 || v2 === null)) {
+    if (values.some((v) => v === void 0 || v === null)) {
       return void 0;
     }
-    const parts = values.map((v2) => String(v2));
+    const parts = values.map((v) => String(v));
     if (parts.some((p) => p.includes(COMPOSITE_KEY_SEP))) {
       return JSON.stringify(parts);
     }
@@ -8669,7 +8424,7 @@ var ResultHydrator = class {
       return obj[columns[0]];
     }
     const values = columns.map((k) => obj[k]);
-    return values.some((v2) => v2 === void 0 || v2 === null) ? void 0 : values;
+    return values.some((v) => v === void 0 || v === null) ? void 0 : values;
   }
 };
 
@@ -8763,6 +8518,13 @@ function buildSetOperationIntent(op2, all, left, right) {
 }
 
 // src/dx/stream-impl.ts
+function createUnsupportedStreamingError() {
+  return new ExecutionError({
+    operation: "stream()",
+    reason: "The adapter declares supportsStreaming: false for this ORM instance.",
+    fix: "Use an adapter configuration that supports streaming."
+  });
+}
 function stream(builder, options) {
   const adapter = builder.getConfiguredAdapter();
   const adapterOptions = options?.chunkSize !== void 0 ? { chunkSize: options.chunkSize } : void 0;
@@ -8782,6 +8544,9 @@ function stream(builder, options) {
       return this;
     },
     async next() {
+      if (!supportsStreaming(adapter)) {
+        throw createUnsupportedStreamingError();
+      }
       if (!hooksFired) {
         hooksFired = true;
         if (hookStore && hasHooks(hookStore)) {
@@ -10323,6 +10088,31 @@ function generateVacuumSQL(tableName, schemaName, options) {
   const mod = modifiers.length > 0 ? `(${modifiers.join(", ")}) ` : "";
   return `VACUUM ${mod}${buildQualifiedTable(tableName, schemaName)}`;
 }
+function createUnsupportedTransactionError() {
+  return new ExecutionError({
+    operation: "transaction()",
+    reason: "The adapter does not declare capabilities.supportsTransactions: true for this ORM instance.",
+    fix: "Use an adapter that implements transaction() and withSchema(), and declare adapter.capabilities.supportsTransactions: true."
+  });
+}
+function adapterTransactionState(adapter, operation, statement) {
+  const inTransaction = adapter.inTransaction;
+  if (typeof inTransaction !== "boolean") {
+    throw new InvalidOperationError(
+      operation,
+      `${statement} requires an adapter that exposes inTransaction: boolean; dbsp refuses to run it when transaction state is unknown.`
+    );
+  }
+  return inTransaction;
+}
+function assertOutsideTransaction(adapter, operation, statement) {
+  if (adapterTransactionState(adapter, operation, statement)) {
+    throw new InvalidOperationError(
+      operation,
+      `${statement} cannot run inside a transaction block`
+    );
+  }
+}
 function generateAlterColumnSQL(tableName, column, schemaName, options) {
   const tbl = buildQualifiedTable(tableName, schemaName);
   const col2 = quoteIdent(column);
@@ -10382,7 +10172,7 @@ function generateCreateIndexSQL(tableName, schemaName, opts) {
     parts.push("NULLS NOT DISTINCT");
   }
   if (opts.with && Object.keys(opts.with).length > 0) {
-    const withClauses = Object.entries(opts.with).map(([k, v2]) => `${k} = ${v2}`).join(", ");
+    const withClauses = Object.entries(opts.with).map(([k, v]) => `${k} = ${v}`).join(", ");
     parts.push(`WITH (${withClauses})`);
   }
   if (opts.where) parts.push(`WHERE ${opts.where}`);
@@ -10401,24 +10191,19 @@ function buildIndexAPI(tableName, schemaName, adapter, requireAdapter2) {
   return {
     async create(opts) {
       const a = requireAdapter2();
-      if (opts.concurrently && a.inTransaction) {
-        throw new InvalidOperationError(
-          "createIndex",
-          "CREATE INDEX CONCURRENTLY cannot run inside a transaction block"
-        );
+      if (opts.concurrently) {
+        assertOutsideTransaction(a, "createIndex", "CREATE INDEX CONCURRENTLY");
       }
       const sql2 = a.generateCreateIndex ? a.generateCreateIndex(tableName, opts, schemaName) : generateCreateIndexSQL(tableName, schemaName, opts);
       await a.executeDDL?.(sql2);
     },
     async drop(name, options) {
       const a = requireAdapter2();
-      if (options?.concurrently && a.inTransaction) {
-        throw new InvalidOperationError(
-          "dropIndex",
-          "DROP INDEX CONCURRENTLY cannot run inside a transaction block"
-        );
+      if (options?.concurrently) {
+        assertOutsideTransaction(a, "dropIndex", "DROP INDEX CONCURRENTLY");
       }
-      const sql2 = a.generateDropIndex ? a.generateDropIndex(name, options) : generateDropIndexSQL(name, schemaName, options);
+      const scopedOptions = schemaName ? { ...options, schema: options?.schema ?? schemaName } : options;
+      const sql2 = a.generateDropIndex ? a.generateDropIndex(name, scopedOptions) : generateDropIndexSQL(name, schemaName, options);
       await a.executeDDL?.(sql2);
     },
     async list(options) {
@@ -10471,12 +10256,7 @@ function buildTableDDL(tableName, schemaName, adapter) {
     },
     async vacuum(options) {
       const a = requireAdapter2();
-      if (a.inTransaction) {
-        throw new InvalidOperationError(
-          "vacuum",
-          "VACUUM cannot run inside a transaction block"
-        );
-      }
+      assertOutsideTransaction(a, "vacuum", "VACUUM");
       const sql2 = a.generateVacuum ? a.generateVacuum(tableName, schemaName, options) : generateVacuumSQL(tableName, schemaName, options);
       await a.executeDDL?.(sql2);
     },
@@ -10808,31 +10588,47 @@ function createOrmInstance(model, strictMode, relationHints, adapter, schemaName
     // =====================================================================
     // Transaction Methods (DX-025)
     // =====================================================================
-    async transaction(fn2) {
+    // NOT `async`, and that is load-bearing. An async method awaits whatever it
+    // returns and re-wraps it in a fresh Promise — which would mean the language
+    // itself attaches to the adapter's promise, and an adapter that needs to know
+    // whether the CALLER awaited a nested transaction would see every one of them
+    // as awaited, by core, before the caller ever touched it. So the adapter's
+    // promise is passed through untouched. The guards still reject rather than
+    // throwing synchronously, because that is what callers already rely on.
+    transaction(fn2) {
       if (!adapter) {
-        throw new Error(
-          "transaction() requires an adapter. Pass an adapter when creating the ORM."
+        return Promise.reject(
+          new Error(
+            "transaction() requires an adapter. Pass an adapter when creating the ORM."
+          )
         );
       }
-      return adapter.transaction(async (txAdapter) => {
-        const txOrm = createOrmInstance(
-          model,
-          strictMode,
-          relationHints,
-          txAdapter,
-          schemaName,
-          dialectCapabilities,
-          schemaDefinition,
-          globalPlanOptions,
-          defaultFilters,
-          hookStore,
-          onHookError,
-          true,
-          // inTransaction
-          tablesProxy
-        );
-        return fn2(txOrm);
-      });
+      if (!supportsTransactions(adapter)) {
+        return Promise.reject(createUnsupportedTransactionError());
+      }
+      try {
+        return adapter.transaction(async (txAdapter) => {
+          const txOrm = createOrmInstance(
+            model,
+            strictMode,
+            relationHints,
+            txAdapter,
+            schemaName,
+            dialectCapabilities,
+            schemaDefinition,
+            globalPlanOptions,
+            defaultFilters,
+            hookStore,
+            onHookError,
+            true,
+            // inTransaction
+            tablesProxy
+          );
+          return fn2(txOrm);
+        });
+      } catch (error) {
+        return Promise.reject(error);
+      }
     },
     // =====================================================================
     // Raw SQL Execution (DX-027)
@@ -10911,12 +10707,20 @@ function createOrmInstance(model, strictMode, relationHints, adapter, schemaName
             "executeDDL() requires an adapter that supports DDL execution."
           );
         }
+        if (options?.concurrently) {
+          assertOutsideTransaction(
+            adapter,
+            "dropIndex",
+            "DROP INDEX CONCURRENTLY"
+          );
+        }
         validateIdentifier(name, "index");
         const sc = options?.schema ?? schemaName;
         if (sc) {
           validateIdentifier(sc, "schema");
         }
-        const sql2 = adapter.generateDropIndex ? adapter.generateDropIndex(name, options) : (() => {
+        const scopedOptions = sc ? { ...options, schema: sc } : options;
+        const sql2 = adapter.generateDropIndex ? adapter.generateDropIndex(name, scopedOptions) : (() => {
           const parts = ["DROP INDEX"];
           if (options?.concurrently) parts.push("CONCURRENTLY");
           if (options?.ifExists) parts.push("IF EXISTS");
@@ -11056,729 +10860,6 @@ function rangeContainedBy(fieldOrColumn, valueOrRange, rangeType = "daterange")
   };
 }
 
-// src/dx/schema-bridge.ts
-import { buildRelationKeyFields, toColumnList as toColumnList3 } from "@dbsp/types";
-import * as v from "valibot";
-function normalizeReferenceSchema2(schemaName) {
-  if (schemaName == null) return void 0;
-  const t = schemaName.trim();
-  return t.length > 0 ? t : void 0;
-}
-function hasExternalSchema3(schemaName) {
-  return normalizeReferenceSchema2(schemaName) !== void 0;
-}
-function generatedTypeToColumnType(genType) {
-  switch (genType) {
-    case "string":
-    case "text":
-      return "string";
-    case "number":
-    case "decimal":
-      return "number";
-    case "integer":
-      return "integer";
-    case "bigint":
-      return "bigint";
-    case "boolean":
-      return "boolean";
-    case "date":
-      return "date";
-    case "timestamp":
-    case "datetime":
-      return "datetime";
-    case "json":
-      return "json";
-    case "jsonb":
-      return "jsonb";
-    case "time":
-      return "time";
-    case "uuid":
-      return "uuid";
-    case "daterange":
-      return "daterange";
-    case "tstzrange":
-      return "tstzrange";
-    case "int4range":
-      return "int4range";
-    case "tsrange":
-      return "tsrange";
-    case "int8range":
-      return "int8range";
-    case "numrange":
-      return "numrange";
-  }
-}
-function mapRelationType2(kind) {
-  switch (kind) {
-    case "belongsTo":
-      return "belongsTo";
-    case "hasMany":
-      return "hasMany";
-    case "manyToMany":
-      return "belongsToMany";
-  }
-}
-function sourceTableFromQualifiedName(qualifiedName) {
-  const dotIndex = qualifiedName.indexOf(".");
-  return dotIndex > 0 ? qualifiedName.slice(0, dotIndex) : qualifiedName;
-}
-function relationNameFromQualifiedName(qualifiedName) {
-  const dotIndex = qualifiedName.indexOf(".");
-  return dotIndex > 0 ? qualifiedName.slice(dotIndex + 1) : qualifiedName;
-}
-function columnListsEqual(left, right) {
-  const leftColumns = toColumnList3(left);
-  const rightColumns = toColumnList3(right);
-  return leftColumns.length === rightColumns.length && leftColumns.every((column, index) => column === rightColumns[index]);
-}
-function generatedReferencedColumns(key) {
-  const columns = toColumnList3(key);
-  return columns.length > 0 ? columns : ["id"];
-}
-function findRelationForeignKey(sourceTable, genRelation, tables) {
-  switch (genRelation.kind) {
-    case "belongsTo":
-      return tables.get(sourceTable)?.foreignKeys.find(
-        (fk) => !hasExternalSchema3(fk.references.schema) && fk.references.table === genRelation.target && columnListsEqual(fk.columns, genRelation.foreignKey)
-      );
-    case "hasMany":
-      return tables.get(genRelation.target)?.foreignKeys.find(
-        (fk) => !hasExternalSchema3(fk.references.schema) && fk.references.table === sourceTable && columnListsEqual(fk.columns, genRelation.foreignKey)
-      );
-    case "manyToMany":
-      return void 0;
-  }
-}
-function isGeneratedTableWithConfig(table) {
-  const columns = table.columns;
-  return typeof columns === "object" && columns !== null && typeof columns.type !== "string";
-}
-function buildTableIRFromDefinition(tableName, genTable, fkAutoIndex) {
-  const columns = [];
-  const foreignKeys = [];
-  const indexes = [];
-  const primaryKeys = [];
-  const tableColumns = isGeneratedTableWithConfig(genTable) ? genTable.columns : genTable;
-  const indexedColumns = /* @__PURE__ */ new Set();
-  for (const [colName, colDef] of Object.entries(tableColumns)) {
-    const col2 = {
-      name: colName,
-      type: generatedTypeToColumnType(colDef.type),
-      nullable: colDef.nullable ?? false,
-      default: colDef.default
-    };
-    if (colDef.unique !== void 0) {
-      col2.unique = colDef.unique;
-    }
-    if (colDef.autoIncrement !== void 0) {
-      col2.autoIncrement = colDef.autoIncrement;
-    }
-    columns.push(col2);
-    if (colDef.primaryKey) {
-      primaryKeys.push(colName);
-    }
-    if (colDef.references) {
-      const externalSchema = normalizeReferenceSchema2(colDef.references.schema);
-      const fk = {
-        columns: [colName],
-        references: {
-          table: colDef.references.table,
-          columns: [colDef.references.column ?? "id"],
-          ...externalSchema !== void 0 ? { schema: externalSchema } : {}
-        }
-      };
-      if (colDef.references.onDelete) {
-        fk.onDelete = colDef.references.onDelete;
-      }
-      foreignKeys.push(fk);
-    }
-    if (colDef.index) {
-      const indexName = typeof colDef.index === "string" ? colDef.index : `idx_${tableName}_${colName}`;
-      indexes.push({
-        name: indexName,
-        columns: [colName],
-        unique: false
-      });
-      indexedColumns.add(colName);
-    }
-    if (fkAutoIndex && colDef.references && !colDef.index) {
-      indexes.push({
-        name: `idx_${tableName}_${colName}`,
-        columns: [colName],
-        unique: false
-      });
-      indexedColumns.add(colName);
-    }
-  }
-  const pseudoColumns = [];
-  for (const fk of foreignKeys) {
-    const fkColumn = fk.columns[0];
-    const targetColumn = fk.references.columns[0];
-    if (fk.references.table === tableName && !hasExternalSchema3(fk.references.schema) && fkColumn !== void 0 && targetColumn !== void 0) {
-      const colDef = tableColumns[fkColumn];
-      const inferredName = fkColumn.endsWith("Id") ? fkColumn.slice(0, -2) : "parent";
-      const parentRole = colDef?.references?.parentRole ?? inferredName;
-      const childRole = colDef?.references?.childRole ?? (parentRole === "parent" ? "children" : `${parentRole}s`);
-      pseudoColumns.push(
-        createPseudoColumnMetadata(
-          tableName,
-          fkColumn,
-          targetColumn,
-          parentRole,
-          childRole
-        )
-      );
-    }
-  }
-  let primaryKey;
-  const configuredPrimaryKey = isGeneratedTableWithConfig(genTable) ? genTable.primaryKey : void 0;
-  if (configuredPrimaryKey !== void 0) {
-    primaryKey = configuredPrimaryKey;
-  } else if (primaryKeys.length > 0) {
-    primaryKey = primaryKeys.length === 1 ? primaryKeys[0] : primaryKeys;
-  } else {
-    const fkColumns = foreignKeys.flatMap((fk) => fk.columns);
-    if (fkColumns.length > 0) {
-      primaryKey = fkColumns.length === 1 ? fkColumns[0] : fkColumns;
-    } else {
-      const hasId = columns.some((c) => c.name === "id");
-      primaryKey = hasId ? "id" : void 0;
-    }
-  }
-  if (isGeneratedTableWithConfig(genTable)) {
-    for (const fk of genTable.foreignKeys ?? []) {
-      const externalSchema = normalizeReferenceSchema2(fk.references.schema);
-      const foreignKey = {
-        columns: [...fk.columns],
-        references: {
-          table: fk.references.table,
-          columns: [...fk.references.columns],
-          ...externalSchema !== void 0 ? { schema: externalSchema } : {}
-        }
-      };
-      if (fk.onDelete) foreignKey.onDelete = fk.onDelete;
-      if (fk.onUpdate) foreignKey.onUpdate = fk.onUpdate;
-      foreignKeys.push(foreignKey);
-    }
-    for (const index of genTable.indexes ?? []) {
-      indexes.push({
-        columns: [...index.columns],
-        unique: index.unique ?? false,
-        ...index.name !== void 0 && { name: index.name }
-      });
-    }
-  }
-  const frozenColumns = Object.freeze(columns);
-  return Object.freeze({
-    name: tableName,
-    columns: frozenColumns,
-    ...primaryKey !== void 0 ? { primaryKey } : {},
-    foreignKeys: Object.freeze(foreignKeys),
-    indexes: Object.freeze(indexes),
-    ...pseudoColumns.length > 0 && {
-      pseudoColumns: Object.freeze(pseudoColumns)
-    }
-  });
-}
-function buildRelationIR(qualifiedName, genRelation, hints, relationFk) {
-  const sourceTable = sourceTableFromQualifiedName(qualifiedName);
-  const relationName = relationNameFromQualifiedName(qualifiedName);
-  const hint = hints[qualifiedName];
-  const relCardinality = genRelation.kind === "hasMany" ? genRelation.cardinality : void 0;
-  const cardinality = hint?.cardinality === "one" ? "one" : relCardinality === "one" ? "one" : genRelation.kind === "belongsTo" ? "one" : "many";
-  const optionality = genRelation.kind === "belongsTo" ? "optional" : "optional";
-  let relationType = mapRelationType2(genRelation.kind);
-  if (genRelation.kind === "hasMany" && cardinality === "one") {
-    relationType = "hasOne";
-  }
-  const baseRelation = {
-    name: relationName,
-    source: sourceTable,
-    target: genRelation.target,
-    type: relationType,
-    cardinality,
-    optionality,
-    includeStrategy: genRelation.includeStrategy ?? "auto",
-    filterStrategy: hint?.defaultStrategy ?? "auto",
-    joinDefault: "auto"
-  };
-  switch (genRelation.kind) {
-    case "belongsTo":
-      return {
-        ...baseRelation,
-        ...buildRelationKeyFields(
-          relationFk ?? {
-            columns: genRelation.foreignKey,
-            references: {
-              table: genRelation.target,
-              columns: generatedReferencedColumns(genRelation.targetKey)
-            }
-          },
-          "belongsTo",
-          {
-            foreignKeyShape: genRelation.foreignKey,
-            ...genRelation.targetKey !== void 0 ? { referencedKeyShape: genRelation.targetKey } : {}
-          }
-        )
-      };
-    case "hasMany":
-      return {
-        ...baseRelation,
-        ...buildRelationKeyFields(
-          relationFk ?? {
-            columns: genRelation.foreignKey,
-            references: {
-              table: sourceTable,
-              columns: generatedReferencedColumns(genRelation.sourceKey)
-            }
-          },
-          "inverse",
-          {
-            foreignKeyShape: genRelation.foreignKey,
-            ...genRelation.sourceKey !== void 0 ? { referencedKeyShape: genRelation.sourceKey } : {}
-          }
-        )
-      };
-    case "manyToMany":
-      return {
-        ...baseRelation,
-        through: genRelation.through,
-        foreignKey: genRelation.sourceFk,
-        otherKey: genRelation.targetFk
-      };
-  }
-}
-function buildModelFromSchema(schema2) {
-  const tables = /* @__PURE__ */ new Map();
-  const relations = /* @__PURE__ */ new Map();
-  const fkAutoIndex = schema2.conventions.fkAutoIndex;
-  for (const [tableName, genTable] of Object.entries(schema2.tables)) {
-    tables.set(
-      tableName,
-      buildTableIRFromDefinition(tableName, genTable, fkAutoIndex)
-    );
-  }
-  for (const [qualifiedName, genRelation] of Object.entries(schema2.relations)) {
-    const sourceTable = sourceTableFromQualifiedName(qualifiedName);
-    relations.set(
-      qualifiedName,
-      buildRelationIR(
-        qualifiedName,
-        genRelation,
-        schema2.hints,
-        findRelationForeignKey(sourceTable, genRelation, tables)
-      )
-    );
-  }
-  return new ModelIRImpl(tables, relations);
-}
-function buildModelFromResolvedSchema(schema2) {
-  const generatedSchema = assertResolvedSchemaToGeneratedSchema(schema2);
-  return buildModelFromSchema(generatedSchema);
-}
-function isGeneratedSchema(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const obj = value;
-  return typeof obj.tables === "object" && obj.tables !== null && typeof obj.relations === "object" && obj.relations !== null && typeof obj.hints === "object" && obj.hints !== null && typeof obj.conventions === "object" && obj.conventions !== null;
-}
-var RESOLVED_SCHEMA_ONLY_TYPES = /* @__PURE__ */ new Set(["time", "jsonb"]);
-var GENERATED_SCHEMA_ONLY_TYPES = /* @__PURE__ */ new Set(["number", "datetime"]);
-function hasResolvedSchemaOnlyTypes(tables) {
-  for (const table of Object.values(tables)) {
-    for (const column of Object.values(table)) {
-      if (column?.type && RESOLVED_SCHEMA_ONLY_TYPES.has(column.type)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function hasGeneratedSchemaOnlyTypes(tables) {
-  for (const table of Object.values(tables)) {
-    for (const column of Object.values(table)) {
-      if (column?.type && GENERATED_SCHEMA_ONLY_TYPES.has(column.type)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function isResolvedSchema(value) {
-  if (!isGeneratedSchema(value)) {
-    return false;
-  }
-  if (hasResolvedSchemaOnlyTypes(
-    value.tables
-  )) {
-    return true;
-  }
-  if (hasGeneratedSchemaOnlyTypes(
-    value.tables
-  )) {
-    return false;
-  }
-  return false;
-}
-function normalizeSchema(input) {
-  if (!isGeneratedSchema(input)) {
-    throw new Error(
-      "Invalid schema: must have tables, relations, hints, and conventions properties"
-    );
-  }
-  if (isResolvedSchema(input)) {
-    const result = resolvedSchemaToGeneratedSchema(input);
-    if (!result.success) {
-      const messages = result.errors.map((e) => e.message).join(", ");
-      throw new Error(`Schema conversion failed: ${messages}`);
-    }
-    return result.schema;
-  }
-  return input;
-}
-var SchemaColumnTypeSchema = v.picklist([
-  "uuid",
-  "string",
-  "text",
-  "integer",
-  "bigint",
-  "decimal",
-  "boolean",
-  "timestamp",
-  "date",
-  "time",
-  "json",
-  "jsonb",
-  "daterange",
-  "tstzrange",
-  "int4range",
-  "tsrange",
-  "int8range",
-  "numrange"
-]);
-var PROTO_POLLUTION_KEYS = ["__proto__", "constructor", "prototype"];
-function safeRecord(valueSchema) {
-  return v.pipe(
-    v.unknown(),
-    v.check((input) => {
-      if (typeof input !== "object" || input === null) return true;
-      return !Object.keys(input).some(
-        (k) => PROTO_POLLUTION_KEYS.includes(k)
-      );
-    }, "Schema keys must not include prototype-pollution names (__proto__, constructor, prototype)"),
-    v.record(v.string(), valueSchema)
-  );
-}
-var OptionalReferenceSchemaNameSchema = v.optional(
-  v.pipe(
-    v.string(),
-    v.transform((schemaName) => normalizeReferenceSchema2(schemaName))
-  )
-);
-var ForeignKeyActionValues = [
-  "CASCADE",
-  "SET NULL",
-  "SET DEFAULT",
-  "RESTRICT",
-  "NO ACTION"
-];
-var ForeignKeyActionSchema = v.picklist(ForeignKeyActionValues);
-var ForeignKeyReferenceSchema = v.object({
-  schema: OptionalReferenceSchemaNameSchema,
-  table: v.string(),
-  column: v.optional(v.string()),
-  onDelete: v.optional(ForeignKeyActionSchema),
-  index: v.optional(v.boolean()),
-  parentRole: v.optional(v.string()),
-  childRole: v.optional(v.string())
-});
-var StringOrStringArraySchema = v.union([v.string(), v.array(v.string())]);
-var ColumnDefinitionSchema = v.object({
-  type: SchemaColumnTypeSchema,
-  primaryKey: v.optional(v.boolean()),
-  nullable: v.optional(v.boolean()),
-  unique: v.optional(v.boolean()),
-  autoIncrement: v.optional(v.boolean()),
-  default: v.optional(v.union([v.string(), v.number(), v.boolean()])),
-  references: v.optional(ForeignKeyReferenceSchema),
-  index: v.optional(v.union([v.boolean(), v.string()]))
-});
-var FlatTableDefinitionSchema = safeRecord(ColumnDefinitionSchema);
-var TableDefWithConfigSchema = v.object({
-  columns: FlatTableDefinitionSchema,
-  primaryKey: v.optional(StringOrStringArraySchema),
-  foreignKeys: v.optional(
-    v.array(
-      v.object({
-        columns: v.array(v.string()),
-        references: v.object({
-          schema: OptionalReferenceSchemaNameSchema,
-          table: v.string(),
-          columns: v.array(v.string())
-        }),
-        onDelete: v.optional(ForeignKeyActionSchema),
-        onUpdate: v.optional(ForeignKeyActionSchema)
-      })
-    )
-  ),
-  indexes: v.optional(
-    v.array(
-      v.object({
-        columns: v.array(v.string()),
-        unique: v.optional(v.boolean()),
-        name: v.optional(v.string())
-      })
-    )
-  )
-});
-var TableDefinitionSchema = v.union([
-  TableDefWithConfigSchema,
-  FlatTableDefinitionSchema
-]);
-var TablesDefinitionSchema = safeRecord(TableDefinitionSchema);
-var IncludeStrategySchema = v.optional(
-  v.picklist(["join", "subquery", "cte", "lateral", "json_agg", "auto"])
-);
-var BelongsToRelationSchema = v.object({
-  kind: v.literal("belongsTo"),
-  target: v.string(),
-  foreignKey: StringOrStringArraySchema,
-  targetKey: v.optional(StringOrStringArraySchema),
-  includeStrategy: IncludeStrategySchema
-});
-var HasManyRelationSchema = v.object({
-  kind: v.literal("hasMany"),
-  target: v.string(),
-  foreignKey: StringOrStringArraySchema,
-  sourceKey: v.optional(StringOrStringArraySchema),
-  includeStrategy: IncludeStrategySchema
-});
-var ManyToManyRelationSchema = v.object({
-  kind: v.literal("manyToMany"),
-  target: v.string(),
-  through: v.string(),
-  sourceFk: v.string(),
-  targetFk: v.string(),
-  includeStrategy: IncludeStrategySchema
-});
-var RelationDefinitionSchema = v.variant("kind", [
-  BelongsToRelationSchema,
-  HasManyRelationSchema,
-  ManyToManyRelationSchema
-]);
-var RelationsDefinitionSchema = safeRecord(RelationDefinitionSchema);
-var HintDefinitionSchema = v.object({
-  defaultStrategy: v.optional(v.picklist(["exists", "join"])),
-  cardinality: v.optional(v.picklist(["one", "many"]))
-});
-var HintsDefinitionSchema = safeRecord(HintDefinitionSchema);
-var ConventionsDefinitionSchema = v.object({
-  fkPattern: v.string(),
-  pluralize: v.boolean(),
-  timestamps: v.array(v.string()),
-  fkAutoIndex: v.boolean()
-});
-var IndexDefinitionSchema = v.object({
-  columns: v.array(v.string()),
-  unique: v.optional(v.boolean()),
-  name: v.optional(v.string())
-});
-var IndexesDefinitionSchema = safeRecord(v.array(IndexDefinitionSchema));
-var ResolvedSchemaValidation = v.object({
-  tables: TablesDefinitionSchema,
-  relations: RelationsDefinitionSchema,
-  hints: HintsDefinitionSchema,
-  conventions: ConventionsDefinitionSchema,
-  indexes: v.optional(IndexesDefinitionSchema)
-});
-function mapSchemaColumnType(schemaType) {
-  switch (schemaType) {
-    case "uuid":
-      return "uuid";
-    case "string":
-      return "string";
-    case "text":
-      return "text";
-    case "integer":
-      return "integer";
-    case "bigint":
-      return "bigint";
-    case "decimal":
-      return "decimal";
-    case "boolean":
-      return "boolean";
-    case "timestamp":
-      return "timestamp";
-    case "date":
-      return "date";
-    case "time":
-      return "time";
-    case "json":
-      return "json";
-    case "jsonb":
-      return "jsonb";
-    case "daterange":
-      return "daterange";
-    case "tstzrange":
-      return "tstzrange";
-    case "int4range":
-      return "int4range";
-    case "tsrange":
-      return "tsrange";
-    case "int8range":
-      return "int8range";
-    case "numrange":
-      return "numrange";
-  }
-}
-function convertColumn(col2) {
-  const result = {
-    type: mapSchemaColumnType(col2.type)
-  };
-  if (col2.primaryKey !== void 0) {
-    result.primaryKey = col2.primaryKey;
-  }
-  if (col2.nullable !== void 0) {
-    result.nullable = col2.nullable;
-  }
-  if (col2.unique !== void 0) {
-    result.unique = col2.unique;
-  }
-  if (col2.autoIncrement !== void 0) {
-    result.autoIncrement = col2.autoIncrement;
-  }
-  if (col2.default !== void 0) {
-    result.default = col2.default;
-  }
-  if (col2.references) {
-    const externalSchema = normalizeReferenceSchema2(col2.references.schema);
-    result.references = {
-      table: col2.references.table,
-      ...externalSchema !== void 0 ? { schema: externalSchema } : {},
-      ...col2.references.column !== void 0 ? { column: col2.references.column } : {},
-      ...col2.references.onDelete ? { onDelete: col2.references.onDelete } : {},
-      ...col2.references.index !== void 0 ? { index: col2.references.index } : {},
-      ...col2.references.parentRole ? { parentRole: col2.references.parentRole } : {},
-      ...col2.references.childRole ? { childRole: col2.references.childRole } : {}
-    };
-  }
-  return result;
-}
-function convertRelation(rel) {
-  switch (rel.kind) {
-    case "belongsTo": {
-      const result = {
-        kind: "belongsTo",
-        target: rel.target,
-        foreignKey: rel.foreignKey
-      };
-      if (rel.targetKey !== void 0) {
-        result.targetKey = rel.targetKey;
-      }
-      if (rel.includeStrategy !== void 0) {
-        result.includeStrategy = rel.includeStrategy;
-      }
-      return result;
-    }
-    case "hasMany": {
-      const result = {
-        kind: "hasMany",
-        target: rel.target,
-        foreignKey: rel.foreignKey
-      };
-      if (rel.sourceKey !== void 0) {
-        result.sourceKey = rel.sourceKey;
-      }
-      if (rel.includeStrategy !== void 0) {
-        result.includeStrategy = rel.includeStrategy;
-      }
-      return result;
-    }
-    case "manyToMany": {
-      const result = {
-        kind: "manyToMany",
-        target: rel.target,
-        through: rel.through,
-        sourceFk: rel.sourceFk,
-        targetFk: rel.targetFk
-      };
-      if (rel.includeStrategy !== void 0) {
-        result.includeStrategy = rel.includeStrategy;
-      }
-      return result;
-    }
-  }
-}
-function convertHint(hint) {
-  const result = {};
-  if (hint.defaultStrategy !== void 0) {
-    result.defaultStrategy = hint.defaultStrategy;
-  }
-  if (hint.cardinality !== void 0) {
-    result.cardinality = hint.cardinality;
-  }
-  return result;
-}
-function resolvedSchemaToGeneratedSchema(input) {
-  const parseResult = v.safeParse(ResolvedSchemaValidation, input);
-  if (!parseResult.success) {
-    return {
-      success: false,
-      errors: parseResult.issues
-    };
-  }
-  const validated = parseResult.output;
-  const tables = /* @__PURE__ */ Object.create(null);
-  for (const [tableName, tableDef] of Object.entries(validated.tables)) {
-    const convertedTable = /* @__PURE__ */ Object.create(null);
-    const tableObj = tableDef;
-    const isWithConfig = Array.isArray(tableObj.primaryKey);
-    const columns = isWithConfig ? tableObj.columns : tableObj;
-    for (const [colName, colDef] of Object.entries(columns)) {
-      convertedTable[colName] = convertColumn(
-        colDef
-      );
-    }
-    tables[tableName] = convertedTable;
-  }
-  const relations = /* @__PURE__ */ Object.create(null);
-  for (const [relName, relDef] of Object.entries(validated.relations)) {
-    relations[relName] = convertRelation(relDef);
-  }
-  const hints = /* @__PURE__ */ Object.create(null);
-  for (const [hintName, hintDef] of Object.entries(validated.hints)) {
-    hints[hintName] = convertHint(hintDef);
-  }
-  const conventions = {
-    fkPattern: validated.conventions.fkPattern,
-    pluralize: validated.conventions.pluralize,
-    timestamps: validated.conventions.timestamps,
-    fkAutoIndex: validated.conventions.fkAutoIndex
-  };
-  return {
-    success: true,
-    schema: {
-      tables,
-      relations,
-      hints,
-      conventions
-    }
-  };
-}
-function assertResolvedSchemaToGeneratedSchema(input) {
-  const result = resolvedSchemaToGeneratedSchema(input);
-  if (!result.success) {
-    const messages = result.errors.map((e) => {
-      const path = e.path?.map((p) => p.key).join(".") || "root";
-      return `[${path}] ${e.message} (expected: ${e.expected}, received: ${e.received})`;
-    }).join("\n");
-    throw new Error(`Schema validation failed:
-${messages}`);
-  }
-  return result.schema;
-}
-
 // src/dialects/index.ts
 var POSTGRESQL_CAPABILITIES = {
   name: "postgresql",
@@ -13159,7 +12240,6 @@ export {
   ColumnNotFoundError,
   CteBuilder,
   CteQueryBuilder,
-  DEFAULT_CONVENTIONS,
   DEFAULT_FEATURE_CHECKERS,
   DUCKDB_CAPABILITIES,
   DeleteBuilder,
@@ -13182,12 +12262,11 @@ export {
   RawCteQueryBuilder,
   RecursiveShapeMismatchError,
   RelationNotFoundError,
-  ResolvedSchemaValidation,
   ResultHydrator,
   SQLITE_CAPABILITIES,
   SQL_RAW_MARKER,
   SchemaValidationError as SchemaError,
-  SchemaValidationError2 as SchemaValidationError,
+  SchemaValidationError,
   SubqueryBuilder,
   SubqueryExpression,
   TABLE_META,
@@ -13226,7 +12305,6 @@ export {
   assertParamsLength,
   assertParamsType,
   assertParamsValue,
-  assertResolvedSchemaToGeneratedSchema,
   assertSQLColumn,
   assertSQLEquals,
   assertSQLJoin,
@@ -13234,8 +12312,6 @@ export {
   assertSuccess,
   assertTypeSupported,
   batchValues,
-  buildModelFromResolvedSchema,
-  buildModelFromSchema,
   capitalize,
   caseWhen,
   cast,
@@ -13257,11 +12333,8 @@ export {
   decapitalize,
   defaultLogger,
   defineModel,
-  defineSchema,
   denseRank,
   deriveRelationPathFromIntentPath,
-  detectForeignKeys,
-  detectManyToMany,
   distinct,
   emitWarning,
   eq,
@@ -13284,13 +12357,11 @@ export {
   inArray,
   inSubquery,
   inferForeignKey,
-  inferRelationsFromSchema,
   export_isAdjacencyTraversal as isAdjacencyTraversal,
   export_isAggregateWindowFunction as isAggregateWindowFunction,
   isAliasedColumn,
   isAllColumns,
   isBatchValuesRef,
-  isBelongsTo,
   isCardinalityShorthand,
   export_isCoalesceExpression as isCoalesceExpression,
   export_isColumnAliasExpression as isColumnAliasExpression,
@@ -13301,11 +12372,8 @@ export {
   isDistinctFrom,
   export_isEdgeTableTraversal as isEdgeTableTraversal,
   isExpressionSpec,
-  isGeneratedSchema,
-  isHasMany,
   export_isInsertIntent as isInsertIntent,
   isKnownDialect,
-  isManyToMany,
   export_isMutationIntent as isMutationIntent,
   isNotNull,
   isNull,
@@ -13320,7 +12388,6 @@ export {
   isRelationObjectDef,
   isRelationRef,
   isRelationTupleDef,
-  isResolvedSchema,
   export_isSelectAggregate as isSelectAggregate,
   export_isSelectAll as isSelectAll,
   export_isSelectFields as isSelectFields,
@@ -13360,7 +12427,6 @@ export {
   neq,
   none,
   normalizeSQL,
-  normalizeSchema,
   not,
   notExists,
   nqlRaw,
@@ -13393,7 +12459,6 @@ export {
   requiresDatabase,
   resetLogger,
   resolveQueryIndex,
-  resolvedSchemaToGeneratedSchema,
   rowNumber,
   runAssertions,
   schema,
@@ -13418,6 +12483,7 @@ export {
   validateAssertionBlocks,
   validateRecursiveInclude,
   validateRecursiveShape,
+  validateSchemaIndexOptions,
   validateTypeName,
   wAvg,
   wCount,