@dbsp/core 1.10.1 → 2.0.0

package/dist/index.d.ts

@@ -1,8 +1,7 @@
 import * as _dbsp_types from '@dbsp/types';
 import { PseudoColumnMetadata, RecursiveMetadata, RelationIR, RelationKind, AdapterCapabilities, Adapter, BaseAdapter, DDLGeneratingAdapter, ExecutingAdapter, IntrospectingAdapter, RawSqlAdapter, StreamingAdapter, TransactionalAdapter, ColumnType, WhereIntent, OnDeleteAction, ModelIR, DbCasing, QueryIntent, PlanOptions, PlanReport, RecursiveIntent, RecursivePlanOptions, RecursivePlanReport, TableIR, EnumIR, SequenceIR, AmbiguityCheckResult, DialectCapabilities, DDLFeature, DDLFeatureVersionRange, SelectIntent, IncludeIntent, AggregateIntent, OrderByIntent, SortDirection, InsertIntent, InsertFromIntent, UpdateIntent, BatchUpdateIntent, DeleteIntent, UpsertIntent, UpsertFromIntent, Dump, SetOperationIntent, LockStrength, LockWaitPolicy, DumpMeta, JoinIntent, UnnestCteIntent, CteQueryIntent, CompileOptions, CompiledQuery, MutationIntent as MutationIntent$1, DumpSequenceStep, UpsertConflictTarget, UpsertConflictAction, RawCteIntent, TruncateOptions, VacuumOptions, AlterColumnOptions, CreateIndexOptions, DropIndexOptions, IndexInfo, ExpressionIntent, ComparisonOperator, WhereSubqueryIntent, SubqueryRefIntent, WhereAndIntent, WhereAnyIntent, WhereComparisonIntent, WhereRelationFilterIntent, RecursiveExistsOptions, WhereExistsIntent, WhereInIntent, WhereNullIntent, WhereLikeIntent, WhereNotIntent, WhereNotExistsIntent, WhereOrIntent, WhereRawExistsIntent, WhereRawNotExistsIntent, WhereExpressionIntent, AggOrderByArg, RelationType as RelationType$1, Cardinality, FeatureWarning, UnsupportedFeatureBehavior, FeatureBehaviorConfig, RangeValue, WhereRangeIntent, SubqueryIncludeInfo } from '@dbsp/types';
-export { Adapter, AdapterCapabilities, AdapterLogger, AdapterStreamOptions, AdjacencyTraversal, AggregateExpressionIntent, AggregateFunction, AggregateIntent, AggregateWindowFunction, AliasIncludedColumnsMode, AlterColumnOptions, AmbiguityCheckResult, ArrayOperator, BaseAdapter, CTEDefinition, Cardinality, CaseExpressionIntent, CoalesceExpressionIntent, ColumnAliasIntent, ColumnExpressionIntent, ColumnIR, ColumnType, CommonColumnType, ComparisonExpressionIntent, ComparisonOperator, CompileOnlyAdapter, CompileOptions, CompileResultWithIncludes, CompiledQuery, CompilingAdapter, CreateIndexOptions, CustomTraversal, DDLGeneratingAdapter, DbCasing, DecisionType, DeleteIntent, DialectCapabilities, DialectName, DropIndexOptions, DuckDBColumnType, Dump, DumpMeta, EdgeTableTraversal, EmitJoinClause, ExecutingAdapter, ExpressionIntent, FilterStrategy, ForeignKeyIR, IncludeIntent, IncludeStrategy, IndexColumnDef, IndexIR, IndexInfo, IndexMethod, InsertFromIntent, InsertIntent, IntrospectingAdapter, IsTypeSupported, JoinDefault, JoinIntent, LiteralExpressionIntent, LogicalOperator, MSSQLColumnType, ModelIR, MutationIntent, MySQLColumnType, NullOperator, NullsPosition, OffsetWindowFunction, OnDeleteAction, Optionality, OrderByIntent, PartitionIR, PlanDecision, PlanOptions, PlanReport, PlanWarning, PlanWarningCode, PostgresColumnType, PostgresOnlyColumnType, PseudoColumnExpressionIntent, PseudoColumnMetadata, PseudoColumnTraversal, QueryIntent, RangeOperator, RangeValue, RankingWindowFunction, RawExpressionIntent, RawSqlAdapter, RecursiveAdvancedOptions, RecursiveDedupe, RecursiveDirection, RecursiveEmitOptions, RecursiveExistsOptions, RecursiveIntent, RecursiveMetadata, RecursiveNodeIdExpr, RecursivePlanOptions, RecursivePlanReport, RecursiveTrackOptions, RecursiveTraversal, RelationColumnIntent, RelationIR, RelationKind, RelationOperator, RelationType, ResolvedIncludeStrategy, SQLiteColumnType, ScalarSubqueryIntent, SelectAggregateIntent, SelectAllIntent, SelectFieldsIntent, SelectIntent, SelectWithExpressionsIntent, SortDirection, StreamingAdapter, StringOperator, SubqueryIncludeInfo, SubqueryRefIntent, SupportedColumnTypes, TableIR, TransactionalAdapter, TruncateOptions, UpdateIntent, UpsertConflictAction, UpsertConflictTarget, UpsertFromIntent, UpsertIntent, VacuumOptions, WhereAndIntent, WhereAnyIntent, WhereComparisonIntent, WhereExistsIntent, WhereInIntent, WhereIntent, WhereLikeIntent, WhereNotExistsIntent, WhereNotIntent, WhereNullIntent, WhereOrIntent, WhereRangeIntent, WhereRelationFilterIntent, WhereSubqueryIntent, WindowFunction, WindowIntent, WindowOrderBy, getNodeIdAlias, isAdjacencyTraversal, isAggregateWindowFunction, isCoalesceExpression, isColumnAliasExpression, isCustomTraversal, isDeleteIntent, isEdgeTableTraversal, isInsertIntent, isMutationIntent, isRankingWindowFunction, isRawExpression, isRecursiveIntent, isRelationColumnExpression, isSelectAggregate, isSelectAll, isSelectFields, isSelectWithExpressions, isSubqueryRef, isUpdateIntent, isUpsertIntent, isWhereAnd, isWhereAny, isWhereComparison, isWhereExists, isWhereIn, isWhereLike, isWhereLogical, isWhereNot, isWhereNotExists, isWhereNull, isWhereOr, isWhereRange, isWhereRelationBased, isWhereRelationFilter, isWhereSubquery, isWindowIntent } from '@dbsp/types';
+export { Adapter, AdapterCapabilities, AdapterLogger, AdapterStreamOptions, AdjacencyTraversal, AggregateExpressionIntent, AggregateFunction, AggregateIntent, AggregateWindowFunction, AliasIncludedColumnsMode, AlterColumnOptions, AmbiguityCheckResult, ArrayOperator, BaseAdapter, CTEDefinition, Cardinality, CaseExpressionIntent, CoalesceExpressionIntent, ColumnAliasIntent, ColumnExpressionIntent, ColumnIR, ColumnType, CommonColumnType, ComparisonExpressionIntent, ComparisonOperator, CompileOnlyAdapter, CompileOptions, CompileResultWithIncludes, CompiledQuery, CompilingAdapter, CreateIndexOptions, CustomTraversal, DDLGeneratingAdapter, DbCasing, DecisionType, DeleteIntent, DialectCapabilities, DialectName, DropIndexOptions, DuckDBColumnType, Dump, DumpMeta, EdgeTableTraversal, EmitJoinClause, ExecutingAdapter, ExpressionIntent, FilterStrategy, ForeignKeyIR, IncludeIntent, IncludeStrategy, IndexColumnDef, IndexIR, IndexInfo, IndexMethod, InsertFromIntent, InsertIntent, IntrospectingAdapter, IsTypeSupported, JoinDefault, JoinIntent, LiteralExpressionIntent, LogicalOperator, MSSQLColumnType, ModelIR, MutationIntent, MySQLColumnType, NullOperator, NullsPosition, OffsetWindowFunction, OnDeleteAction, Optionality, OrderByIntent, PartitionIR, PlanDecision, PlanOptions, PlanReport, PlanWarning, PlanWarningCode, PostgresColumnType, PostgresOnlyColumnType, PseudoColumnExpressionIntent, PseudoColumnMetadata, PseudoColumnTraversal, QueryIntent, RangeOperator, RangeValue, RankingWindowFunction, RawExpressionIntent, RawSqlAdapter, RecursiveAdvancedOptions, RecursiveDedupe, RecursiveDirection, RecursiveEmitOptions, RecursiveExistsOptions, RecursiveIntent, RecursiveMetadata, RecursiveNodeIdExpr, RecursivePlanOptions, RecursivePlanReport, RecursiveTrackOptions, RecursiveTraversal, RelationColumnIntent, RelationIR, RelationKind, RelationOperator, RelationType, ResolvedIncludeStrategy, SQLiteColumnType, SelectAggregateIntent, SelectAllIntent, SelectFieldsIntent, SelectIntent, SelectWithExpressionsIntent, SortDirection, StreamingAdapter, StringOperator, SubqueryIncludeInfo, SubqueryRefIntent, SupportedColumnTypes, TableIR, TransactionalAdapter, TruncateOptions, UpdateIntent, UpsertConflictAction, UpsertConflictTarget, UpsertFromIntent, UpsertIntent, VacuumOptions, WhereAndIntent, WhereAnyIntent, WhereComparisonIntent, WhereExistsIntent, WhereInIntent, WhereIntent, WhereLikeIntent, WhereNotExistsIntent, WhereNotIntent, WhereNullIntent, WhereOrIntent, WhereRangeIntent, WhereRelationFilterIntent, WhereSubqueryIntent, WindowFunction, WindowIntent, WindowOrderBy, getNodeIdAlias, isAdjacencyTraversal, isAggregateWindowFunction, isCoalesceExpression, isColumnAliasExpression, isCustomTraversal, isDeleteIntent, isEdgeTableTraversal, isInsertIntent, isMutationIntent, isRankingWindowFunction, isRawExpression, isRecursiveIntent, isRelationColumnExpression, isSelectAggregate, isSelectAll, isSelectFields, isSelectWithExpressions, isSubqueryRef, isUpdateIntent, isUpsertIntent, isWhereAnd, isWhereAny, isWhereComparison, isWhereExists, isWhereIn, isWhereLike, isWhereLogical, isWhereNot, isWhereNotExists, isWhereNull, isWhereOr, isWhereRange, isWhereRelationBased, isWhereRelationFilter, isWhereSubquery, isWindowIntent } from '@dbsp/types';
 import { NqlCompilerOptions } from '@dbsp/nql';
-import * as v from 'valibot';
 
 /**
  * @module model-ir
@@ -560,12 +559,12 @@ declare function isAliasedColumn(value: unknown): value is AliasedColumn<string,
  * Supported column types in schema definitions.
  * Matches SchemaColumnType from schema.ts.
  */
-type SchemaColumnType$2 = 'string' | 'text' | 'uuid' | 'number' | 'integer' | 'decimal' | 'bigint' | 'boolean' | 'date' | 'time' | 'datetime' | 'timestamp' | 'json' | 'jsonb' | 'daterange' | 'tsrange' | 'tstzrange' | 'int4range' | 'int8range' | 'numrange';
+type SchemaColumnType$1 = 'string' | 'text' | 'uuid' | 'number' | 'integer' | 'decimal' | 'bigint' | 'boolean' | 'date' | 'time' | 'datetime' | 'timestamp' | 'json' | 'jsonb' | 'daterange' | 'tsrange' | 'tstzrange' | 'int4range' | 'int8range' | 'numrange';
 /**
  * Column definition - short form or long form.
  */
-type ColumnDef$1 = SchemaColumnType$2 | {
-    type: SchemaColumnType$2;
+type ColumnDef$1 = SchemaColumnType$1 | {
+    type: SchemaColumnType$1;
     nullable?: boolean;
     unique?: boolean;
     primaryKey?: boolean;
@@ -609,8 +608,8 @@ type IsRef<T> = T extends {
 /**
  * Extract the column type from a ColumnDef.
  */
-type ExtractColumnType$1<C> = C extends SchemaColumnType$2 ? C : C extends {
-    type: infer T extends SchemaColumnType$2;
+type ExtractColumnType$1<C> = C extends SchemaColumnType$1 ? C : C extends {
+    type: infer T extends SchemaColumnType$1;
 } ? T : never;
 /**
  * Check if a column is nullable.
@@ -621,7 +620,7 @@ type IsNullable$1<C> = C extends {
 /**
  * Map schema column types to TypeScript types.
  */
-type MapColumnTypeToTS<T extends SchemaColumnType$2> = T extends 'string' | 'text' | 'uuid' ? string : T extends 'number' | 'integer' | 'decimal' ? number : T extends 'bigint' ? bigint : T extends 'boolean' ? boolean : T extends 'date' | 'time' | 'datetime' | 'timestamp' ? Date : T extends 'json' | 'jsonb' ? unknown : T extends 'daterange' | 'tsrange' | 'tstzrange' | 'int4range' | 'int8range' | 'numrange' ? unknown : unknown;
+type MapColumnTypeToTS<T extends SchemaColumnType$1> = T extends 'string' | 'text' | 'uuid' ? string : T extends 'number' | 'integer' | 'decimal' ? number : T extends 'bigint' ? bigint : T extends 'boolean' ? boolean : T extends 'date' | 'time' | 'datetime' | 'timestamp' ? Date : T extends 'json' | 'jsonb' ? unknown : T extends 'daterange' | 'tsrange' | 'tstzrange' | 'int4range' | 'int8range' | 'numrange' ? unknown : unknown;
 /**
  * Infer the TypeScript type for a column definition.
  */
@@ -659,13 +658,13 @@ type GetRefTarget<TRef> = TRef extends {
 /**
  * Infer the row type for a table (used for relation target types).
  */
-type InferRowType$1<TTable extends TableDef$1> = {
+type InferRowType<TTable extends TableDef$1> = {
     [K in keyof ExtractColumns<TTable> as K extends string ? K : never]: InferColumnTSType<TTable[K]>;
 };
 /**
  * Build RelationRef for a local relation (belongsTo - FK in this table).
  */
-type BuildLocalRelation<_TColName extends string, TRef extends RefDefinition$1, TSchema extends SchemaDefinition$1> = GetRefTarget<TRef> extends keyof TSchema ? RelationRef<GetRefTarget<TRef> & string, InferRowType$1<TSchema[GetRefTarget<TRef>]> | null, 'belongsTo', InferRowType$1<TSchema[GetRefTarget<TRef>]>> : never;
+type BuildLocalRelation<_TColName extends string, TRef extends RefDefinition$1, TSchema extends SchemaDefinition$1> = GetRefTarget<TRef> extends keyof TSchema ? RelationRef<GetRefTarget<TRef> & string, InferRowType<TSchema[GetRefTarget<TRef>]> | null, 'belongsTo', InferRowType<TSchema[GetRefTarget<TRef>]>> : never;
 /**
  * Build local relations (belongsTo) for a table.
  */
@@ -682,7 +681,7 @@ type FindInverseRelations<TName extends string, TSchema extends SchemaDefinition
                 inverse: infer I extends string;
             };
         } ? I : TTable extends `${string}s` ? TTable : `${TTable & string}s` : never : never;
-    }[keyof TSchema[TTable]] : never]: TTable extends string ? RelationRef<TTable, Array<InferRowType$1<TSchema[TTable]>>, 'hasMany', InferRowType$1<TSchema[TTable]>> : never;
+    }[keyof TSchema[TTable]] : never]: TTable extends string ? RelationRef<TTable, Array<InferRowType<TSchema[TTable]>>, 'hasMany', InferRowType<TSchema[TTable]>> : never;
 };
 /**
  * Combine local and inverse relations for a table.
@@ -717,8 +716,8 @@ type InferTables<TSchema extends SchemaDefinition$1> = {
 /**
  * ARCH-005: Unified Schema API
  *
- * Replaces defineSchema(), TypedSchema, and GeneratedSchema with a single
- * schema() + ref() API. Relations are auto-inferred from FK declarations.
+ * Provides the schema() + ref() API. Relations are auto-inferred from FK
+ * declarations.
  *
  * @example
  * ```typescript
@@ -735,12 +734,12 @@ type InferTables<TSchema extends SchemaDefinition$1> = {
  * Supported column types in schema definitions.
  * Maps to ColumnType from ModelIR.
  */
-type SchemaColumnType$1 = ColumnType;
+type SchemaColumnType = ColumnType;
 /**
  * Column definition - short form (just type) or long form (with options).
  */
-type ColumnDef = SchemaColumnType$1 | {
-    type: SchemaColumnType$1;
+type ColumnDef = SchemaColumnType | {
+    type: SchemaColumnType;
     dbType?: string;
     nullable?: boolean;
     unique?: boolean;
@@ -767,6 +766,8 @@ interface SelfRefRoles {
  * Options for ref() foreign key declarations.
  */
 interface RefOptions {
+    /** Target schema name (omit for same-schema references) */
+    schema?: string;
     /** Is this FK nullable? → optional relation */
     nullable?: boolean;
     /** Is this FK unique? → 1:1 instead of 1:N */
@@ -774,7 +775,7 @@ interface RefOptions {
     /** ON DELETE action */
     onDelete?: OnDeleteAction;
     /** ON UPDATE action */
-    onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+    onUpdate?: OnDeleteAction;
     /** Local relation name (e.g., 'createdBy' for createdById column) */
     as?: string;
     /** Inverse relation name on target table (e.g., 'writings' instead of 'author_posts') */
@@ -841,17 +842,36 @@ interface SchemaIndexOptions {
     columns: string[];
     /** Whether this is a unique index */
     unique?: boolean;
+    /**
+     * PG15+ — for a UNIQUE index, treat NULLs as not distinct
+     * (`NULLS NOT DISTINCT`); true is rejected for non-unique indexes. Emitted
+     * as declared; coherent server-version capability gating for all index
+     * features is tracked together in #245.
+     */
+    nullsNotDistinct?: boolean;
     /** Custom index name (auto-generated if not provided) */
     name?: string;
     /** Index access method (default: btree). E.g. 'gin', 'gist', 'hnsw', 'bm25' */
     method?: string;
     /** Partial index predicate (WHERE clause) */
     where?: string;
+    /**
+     * Non-key columns to include (INCLUDE clause, PG11+).
+     * Emitted as declared; coherent server-version capability gating for all
+     * index features is tracked together in #245.
+     */
+    include?: string[];
     /** Per-column operator class overrides. Key = column name, value = opclass name */
     opclass?: Record<string, string>;
     /** Index storage parameters (WITH clause). Key = param name, value = param value */
     with?: Record<string, string>;
 }
+interface SchemaIndexValidationInput {
+    readonly columns: readonly string[];
+    readonly unique?: boolean;
+    readonly nullsNotDistinct?: boolean;
+    readonly name?: string;
+}
 interface SchemaTableOptions {
     /** Indexes for this table (simple, composite, partial, GIN, HNSW, BM25, etc.) */
     indexes?: SchemaIndexOptions[];
@@ -952,6 +972,8 @@ interface SchemaOptions {
 interface Schema<T extends SchemaDefinition> {
     /** The raw schema definition */
     readonly definition: T;
+    /** Table-level constraints supplied to schema() or reconstructed from introspection */
+    readonly constraints?: SchemaConstraints;
     /** Converted ModelIR for use with ORM */
     readonly model: ModelIR;
     /** Table names */
@@ -1018,12 +1040,12 @@ interface InferredRangeValue<T> {
 /**
  * Maps a ColumnType string to its TypeScript type.
  */
-type InferColumnType<T extends SchemaColumnType$1> = T extends 'string' | 'text' | 'uuid' ? string : T extends 'number' | 'integer' | 'decimal' ? number : T extends 'bigint' ? bigint : T extends 'boolean' ? boolean : T extends 'date' | 'time' | 'datetime' | 'timestamp' ? Date : T extends 'json' | 'jsonb' ? JsonValue : T extends 'daterange' ? InferredRangeValue<Date> : T extends 'tsrange' | 'tstzrange' ? InferredRangeValue<Date> : T extends 'int4range' | 'int8range' ? InferredRangeValue<number> : T extends 'numrange' ? InferredRangeValue<number> : unknown;
+type InferColumnType<T extends SchemaColumnType> = T extends 'string' | 'text' | 'uuid' ? string : T extends 'number' | 'integer' | 'decimal' ? number : T extends 'bigint' ? bigint : T extends 'boolean' ? boolean : T extends 'date' | 'time' | 'datetime' | 'timestamp' ? Date : T extends 'json' | 'jsonb' ? JsonValue : T extends 'daterange' ? InferredRangeValue<Date> : T extends 'tsrange' | 'tstzrange' ? InferredRangeValue<Date> : T extends 'int4range' | 'int8range' ? InferredRangeValue<number> : T extends 'numrange' ? InferredRangeValue<number> : unknown;
 /**
  * Extracts the type string from a ColumnDef (handles short and long forms).
  */
-type ExtractColumnType<C extends ColumnDef> = C extends SchemaColumnType$1 ? C : C extends {
-    type: infer T extends SchemaColumnType$1;
+type ExtractColumnType<C extends ColumnDef> = C extends SchemaColumnType ? C : C extends {
+    type: infer T extends SchemaColumnType;
 } ? T : never;
 /**
  * Checks if a ColumnDef is nullable.
@@ -1152,11 +1174,12 @@ declare function schema<T extends SchemaDefinition>(definition: T, constraints?:
 /**
  * Validation error during schema conversion.
  */
-declare class SchemaValidationError$1 extends Error {
+declare class SchemaValidationError extends Error {
     readonly table?: string | undefined;
     readonly column?: string | undefined;
     constructor(message: string, table?: string | undefined, column?: string | undefined);
 }
+declare function validateSchemaIndexOptions(tableName: string, idx: SchemaIndexValidationInput): void;
 /**
  * Converts a schema definition to ModelIR.
  *
@@ -1208,337 +1231,8 @@ interface IntrospectableAdapter {
 declare function getSchemaFromDb<T extends SchemaDefinition = SchemaDefinition>(adapter: IntrospectableAdapter, options?: GetSchemaFromDbOptions): Promise<Schema<T>>;
 
 /**
- * Schema DSL Types
- *
- * Input types for defineSchema() - the user-facing schema definition DSL.
- * These types are simpler than the IR types and serve as the "source of truth"
- * for schema definitions before they're processed into ModelIR.
- *
- * Migrated from @dbsp/schema/types.ts as part of ARCH-003.
- */
-
-/**
- * Supported column types in the schema DSL.
- * Maps to database types during DDL generation.
- */
-type SchemaColumnType = 'uuid' | 'string' | 'text' | 'integer' | 'bigint' | 'decimal' | 'boolean' | 'timestamp' | 'date' | 'time' | 'json' | 'jsonb' | 'daterange' | 'tsrange' | 'tstzrange' | 'int4range' | 'int8range' | 'numrange';
-/** Foreign key delete behavior */
-type SchemaOnDeleteAction = 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
-/**
- * Foreign key reference definition.
- * When present, takes priority over convention-based FK detection.
- */
-interface SchemaForeignKeyReference {
-    /** Target table name */
-    table: string;
-    /** Target column name (defaults to 'id') */
-    column?: string;
-    /** Delete behavior (CASCADE, SET NULL, RESTRICT, NO ACTION) */
-    onDelete?: SchemaOnDeleteAction;
-    /**
-     * Custom role name for parent direction in self-referential FKs.
-     * Required when table has multiple self-referential FKs.
-     * Example: parentRole: 'manager' for managerId FK
-     * @default 'parent' (for single self-ref FK)
-     */
-    parentRole?: string;
-    /**
-     * Custom role name for child direction in self-referential FKs.
-     * Required when table has multiple self-referential FKs.
-     * Example: childRole: 'subordinates' for managerId FK
-     * @default 'children' or pluralized parentRole (for single self-ref FK)
-     */
-    childRole?: string;
-}
-/**
- * Column definition in the schema DSL.
- */
-interface SchemaColumnDefinition {
-    /** Column data type */
-    type: SchemaColumnType;
-    /** Whether the column is the primary key */
-    primaryKey?: boolean;
-    /** Whether the column allows NULL values */
-    nullable?: boolean;
-    /** Whether the column has a unique constraint */
-    unique?: boolean;
-    /** Default value (e.g., 'now()', 'gen_random_uuid()', 0, true) */
-    default?: string | number | boolean;
-    /** Explicit foreign key reference (takes priority over conventions) */
-    references?: SchemaForeignKeyReference;
-    /** Create an index on this column (true for auto-name, string for custom name) */
-    index?: boolean | string;
-}
-/**
- * Table definition: mapping of column names to their definitions.
- */
-type SchemaTableDefinition = Record<string, SchemaColumnDefinition>;
-/**
- * All tables in the schema.
+ * Naming and self-reference convention helpers.
  */
-type SchemaTablesDefinition = Record<string, SchemaTableDefinition>;
-/**
- * Index definition for composite indexes.
- */
-interface SchemaIndexDefinition {
-    /** Columns included in the index */
-    columns: string[];
-    /** Whether this is a unique index */
-    unique?: boolean;
-    /** Custom index name (auto-generated if not provided) */
-    name?: string;
-}
-/**
- * Index configuration by table.
- */
-type SchemaIndexesDefinition = Record<string, SchemaIndexDefinition[]>;
-/**
- * Relation kinds for discriminated union.
- */
-type SchemaRelationKind = 'belongsTo' | 'hasMany' | 'manyToMany';
-/**
- * Strategy for including related data in queries.
- * - 'join': Use SQL JOIN (default for belongsTo)
- * - 'subquery': Execute subquery query
- * - 'cte': Use Common Table Expression
- * - 'lateral': Use LATERAL JOIN
- * - 'json_agg': Use JSON aggregation
- * - 'auto': Let planner decide based on relation type
- */
-type SchemaIncludeStrategy = 'join' | 'subquery' | 'cte' | 'lateral' | 'json_agg' | 'auto';
-/**
- * Base properties shared by all relation types.
- */
-interface SchemaRelationBase {
-    /** Target table name */
-    target: string;
-    /** Include strategy hint for the planner */
-    includeStrategy?: SchemaIncludeStrategy;
-}
-/**
- * BelongsTo relation: source table has FK to target table.
- * Example: posts.author → users (posts.authorId references users.id)
- */
-interface SchemaBelongsToRelation extends SchemaRelationBase {
-    kind: 'belongsTo';
-    /** Foreign key column in the source table */
-    foreignKey: string;
-    /** Target column (defaults to 'id') */
-    targetKey?: string;
-}
-/**
- * HasMany relation: target table has FK to source table.
- * Example: users.posts → posts (posts.authorId references users.id)
- */
-interface SchemaHasManyRelation extends SchemaRelationBase {
-    kind: 'hasMany';
-    /** Foreign key column in the target table */
-    foreignKey: string;
-    /** Source column (defaults to 'id') */
-    sourceKey?: string;
-}
-/**
- * ManyToMany relation: junction table connects source and target.
- * Example: posts ↔ categories via post_categories
- */
-interface SchemaManyToManyRelation extends SchemaRelationBase {
-    kind: 'manyToMany';
-    /** Junction table name */
-    through: string;
-    /** FK column in junction pointing to source */
-    sourceFk: string;
-    /** FK column in junction pointing to target */
-    targetFk: string;
-}
-/**
- * Union of all relation types.
- * Use `kind` field for type narrowing.
- */
-type SchemaRelationDefinition = SchemaBelongsToRelation | SchemaHasManyRelation | SchemaManyToManyRelation;
-/**
- * Explicit relations mapping.
- * Keys are 'sourceTable.relationName' format.
- */
-type SchemaRelationsDefinition = Record<string, SchemaRelationDefinition>;
-/**
- * Strategy hint for filtering on to-many relations.
- */
-type SchemaFilterStrategy = 'exists' | 'join';
-/**
- * Cardinality hint for relation traversal.
- */
-type SchemaCardinality = 'one' | 'many';
-/**
- * Hint definition for a specific relation path.
- */
-interface SchemaHintDefinition {
-    /** Preferred filter strategy */
-    defaultStrategy?: SchemaFilterStrategy;
-    /** Expected cardinality */
-    cardinality?: SchemaCardinality;
-}
-/**
- * All hints, keyed by 'table.relation' path.
- */
-type SchemaHintsDefinition = Record<string, SchemaHintDefinition>;
-/**
- * Convention settings for automatic FK detection and naming.
- */
-interface SchemaConventionsDefinition {
-    /**
-     * Pattern for foreign key column names.
-     * {singular} is replaced with singular table name.
-     * @default '{singular}Id'
-     */
-    fkPattern?: string;
-    /**
-     * Whether to auto-pluralize relation names.
-     * @default true
-     */
-    pluralize?: boolean;
-    /**
-     * Column names recognized as timestamps.
-     * @default ['createdAt', 'updatedAt']
-     */
-    timestamps?: string[];
-    /**
-     * Automatically create indexes on foreign key columns.
-     * FK columns are frequently used in JOINs, so indexing is a best practice.
-     * @default true
-     */
-    fkAutoIndex?: boolean;
-}
-/**
- * Complete schema definition input for defineSchema() wrapped form.
- * Prefer the new hybrid API: defineSchema(tables, config?)
- */
-interface SchemaDefinitionInput<T extends SchemaTablesDefinition = SchemaTablesDefinition> {
-    /** Table definitions */
-    tables: T;
-    /** Explicit relation definitions (override auto-detected) */
-    relations?: SchemaRelationsDefinition;
-    /** Planner hints */
-    hints?: SchemaHintsDefinition;
-    /** Convention configuration */
-    conventions?: SchemaConventionsDefinition;
-}
-/**
- * Per-table default filters applied to all queries.
- * Commonly used for soft delete filtering.
- */
-type SchemaDefaultFilters = {
-    [tableName: string]: WhereIntent;
-};
-/**
- * Configuration options for defineSchema (new API).
- */
-interface SchemaConfigInput {
-    /** Explicit relation definitions (override auto-detected) */
-    relations?: SchemaRelationsDefinition;
-    /** Planner hints */
-    hints?: SchemaHintsDefinition;
-    /** Convention configuration */
-    conventions?: SchemaConventionsDefinition;
-    /** Table-level index definitions (composite indexes) */
-    indexes?: SchemaIndexesDefinition;
-    /**
-     * Default filters applied automatically to all queries on each table.
-     * Use for soft delete (`isNull('deletedAt')`), multi-tenant, or active filtering.
-     * Override per-query with `.withoutDefaultFilters()`.
-     */
-    defaultFilters?: SchemaDefaultFilters;
-}
-/**
- * Resolved schema with all relations (explicit + inferred).
- * This is the output of defineSchema().
- */
-interface ResolvedSchema<T extends SchemaTablesDefinition = SchemaTablesDefinition> {
-    /** Original table definitions */
-    tables: T;
-    /** All relations (explicit + auto-detected) */
-    relations: SchemaRelationsDefinition;
-    /** Planner hints */
-    hints: SchemaHintsDefinition;
-    /** Resolved conventions with defaults applied */
-    conventions: Required<SchemaConventionsDefinition>;
-    /** Table-level index definitions */
-    indexes: SchemaIndexesDefinition;
-    /** Default filters per table (e.g., soft delete) */
-    defaultFilters: SchemaDefaultFilters;
-}
-/**
- * Type guard for BelongsTo relation.
- */
-declare function isBelongsTo(rel: SchemaRelationDefinition): rel is SchemaBelongsToRelation;
-/**
- * Type guard for HasMany relation.
- */
-declare function isHasMany(rel: SchemaRelationDefinition): rel is SchemaHasManyRelation;
-/**
- * Type guard for ManyToMany relation.
- */
-declare function isManyToMany(rel: SchemaRelationDefinition): rel is SchemaManyToManyRelation;
-
-/**
- * Schema DSL - defineSchema() function
- *
- * Main entry point for defining the schema Source of Truth.
- * Merges explicit definitions with convention-inferred relations.
- *
- * Migrated from @dbsp/schema/define.ts as part of ARCH-003.
- */
-
-/**
- * Define a schema with tables, relations, hints, and conventions.
- *
- * @example Simple - just tables
- * ```typescript
- * const schema = defineSchema({
- *   users: {
- *     id: { type: 'uuid', primaryKey: true },
- *     name: { type: 'string', nullable: false },
- *   },
- *   posts: {
- *     id: { type: 'uuid', primaryKey: true },
- *     authorId: { type: 'uuid', references: { table: 'users' } },
- *   },
- * });
- * ```
- *
- * @example With config
- * ```typescript
- * const schema = defineSchema(
- *   {
- *     users: { id: { type: 'uuid', primaryKey: true } },
- *     roles: { id: { type: 'uuid', primaryKey: true } },
- *   },
- *   {
- *     relations: {...}
- *   }
- * );
- * ```
- */
-declare function defineSchema<T extends SchemaTablesDefinition>(tables: T, config?: SchemaConfigInput): ResolvedSchema<T>;
-/**
- * Error thrown when schema validation fails.
- */
-declare class SchemaValidationError extends Error {
-    constructor(message: string);
-}
-
-/**
- * Schema Convention Inference
- *
- * Detects foreign keys and M:N relations using:
- * 1. Explicit `references` (highest priority)
- * 2. Convention patterns (fallback)
- *
- * M:N auto-detection: tables with exactly 2 FKs and no business columns.
- *
- * Migrated from @dbsp/schema/conventions.ts as part of ARCH-003.
- */
-
-declare const DEFAULT_CONVENTIONS: Required<SchemaConventionsDefinition>;
 /**
  * Convert table name to singular form.
  * Simple heuristic: remove trailing 's' if present.
@@ -1568,49 +1262,6 @@ declare function capitalize(name: string): string;
  * Decapitalize first letter.
  */
 declare function decapitalize(name: string): string;
-interface DetectedFK {
-    /** Column name in source table */
-    column: string;
-    /** Target table name */
-    targetTable: string;
-    /** Inferred relation name (e.g., 'author' from 'authorId') */
-    inferredName: string;
-    /** Whether this was explicitly defined via `references` */
-    explicit: boolean;
-    /** Target column (from references.column or default 'id') */
-    targetColumn: string;
-    /** Custom parent role for self-ref FKs (from parentRole or inferred) */
-    parentRole?: string;
-    /** Custom child role for self-ref FKs (from childRole or inferred) */
-    childRole?: string;
-}
-/**
- * Detect foreign keys in a table.
- * Priority: explicit `references` > convention pattern.
- */
-declare function detectForeignKeys(tableName: string, table: SchemaTableDefinition, conventions: Required<SchemaConventionsDefinition>, tableNames: Set<string>): DetectedFK[];
-interface DetectedManyToMany {
-    /** Junction table name */
-    junction: string;
-    /** First table in the M:N relation */
-    tableA: string;
-    /** Second table in the M:N relation */
-    tableB: string;
-    /** FK column pointing to tableA */
-    fkA: string;
-    /** FK column pointing to tableB */
-    fkB: string;
-}
-/**
- * Detect pure M:N junction tables.
- * Criteria: exactly 2 FK columns, no business columns.
- */
-declare function detectManyToMany(tables: SchemaTablesDefinition, conventions: Required<SchemaConventionsDefinition>, tableNames: Set<string>): DetectedManyToMany[];
-/**
- * Infer all relations from table definitions.
- * Returns a map of 'sourceTable.relationName' → RelationDefinition.
- */
-declare function inferRelationsFromSchema(tables: SchemaTablesDefinition, conventions: Required<SchemaConventionsDefinition>, explicitRelations?: SchemaRelationsDefinition): SchemaRelationsDefinition;
 
 /**
  * @module planner
@@ -4214,396 +3865,6 @@ declare class RawCteQueryBuilder<TResult = unknown> {
  */
 declare function createRawCteBuilder<TResult = unknown>(cteName: string, options: RecursiveOptions, adapter?: Adapter, schemaName?: string): RawCteQueryBuilder<TResult>;
 
-/**
- * ARCH-002 Block 6: Schema Bridge
- *
- * Converts generated schema (from dbsp generate manifest) to ModelIR.
- * This enables sync createOrm usage with codegen-first schemas.
- */
-
-/**
- * Column type in generated schema.
- */
-type GeneratedColumnType = 'string' | 'text' | 'number' | 'integer' | 'bigint' | 'decimal' | 'boolean' | 'date' | 'timestamp' | 'datetime' | 'time' | 'json' | 'jsonb' | 'uuid' | 'daterange' | 'tstzrange' | 'int4range' | 'tsrange' | 'int8range' | 'numrange';
-/**
- * Column definition in generated schema.
- */
-interface GeneratedColumn {
-    readonly type: GeneratedColumnType;
-    readonly primaryKey?: boolean;
-    readonly nullable?: boolean;
-    readonly unique?: boolean;
-    readonly autoIncrement?: boolean;
-    readonly default?: string;
-    readonly references?: {
-        readonly table: string;
-        readonly column?: string;
-        readonly onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
-        /** Create an index on this FK column (matches ColumnDefinitionSchema index field) */
-        readonly index?: boolean;
-        /** Role name for parent traversal in self-ref hierarchies (e.g., 'parent') */
-        readonly parentRole?: string;
-        /** Role name for child traversal in self-ref hierarchies (e.g., 'children') */
-        readonly childRole?: string;
-    };
-    /** Create an index on this column (true for auto-name, string for custom name) */
-    readonly index?: boolean | string;
-}
-/**
- * Table definition in generated schema.
- */
-interface GeneratedForeignKey {
-    readonly columns: readonly string[];
-    readonly references: {
-        readonly table: string;
-        readonly columns: readonly string[];
-    };
-    readonly onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
-    readonly onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
-}
-interface GeneratedIndex {
-    readonly columns: readonly string[];
-    readonly unique?: boolean;
-    readonly name?: string;
-}
-interface GeneratedTableWithConfig {
-    readonly columns: Record<string, GeneratedColumn>;
-    readonly primaryKey?: string | readonly string[];
-    readonly foreignKeys?: readonly GeneratedForeignKey[];
-    readonly indexes?: readonly GeneratedIndex[];
-}
-type GeneratedFlatTable = Record<string, GeneratedColumn>;
-type GeneratedTable = GeneratedFlatTable | GeneratedTableWithConfig;
-/**
- * Relation kind in generated schema (discriminated union).
- */
-type GeneratedRelationKind = 'belongsTo' | 'hasMany' | 'manyToMany';
-/**
- * Include strategy for relations.
- */
-type GeneratedIncludeStrategy = 'join' | 'subquery' | 'cte' | 'lateral' | 'json_agg' | 'auto';
-/**
- * BelongsTo relation in generated schema.
- */
-interface GeneratedBelongsTo {
-    readonly kind: 'belongsTo';
-    readonly target: string;
-    readonly foreignKey: string | readonly string[];
-    readonly targetKey?: string | readonly string[];
-    readonly includeStrategy?: GeneratedIncludeStrategy;
-}
-/**
- * HasMany relation in generated schema.
- */
-interface GeneratedHasMany {
-    readonly kind: 'hasMany';
-    readonly target: string;
-    readonly foreignKey: string | readonly string[];
-    readonly sourceKey?: string | readonly string[];
-    readonly includeStrategy?: GeneratedIncludeStrategy;
-    readonly cardinality?: 'one' | 'many';
-}
-/**
- * ManyToMany relation in generated schema.
- */
-interface GeneratedManyToMany {
-    readonly kind: 'manyToMany';
-    readonly target: string;
-    readonly through: string;
-    readonly sourceFk: string;
-    readonly targetFk: string;
-    readonly includeStrategy?: GeneratedIncludeStrategy;
-}
-/**
- * Relation definition in generated schema.
- */
-type GeneratedRelation = GeneratedBelongsTo | GeneratedHasMany | GeneratedManyToMany;
-/**
- * Hint definition in generated schema.
- */
-interface GeneratedHint {
-    readonly defaultStrategy?: 'exists' | 'join';
-    readonly cardinality?: 'one' | 'many';
-}
-/**
- * Conventions in generated schema.
- */
-interface GeneratedConventions {
-    readonly fkPattern: string;
-    readonly pluralize: boolean;
-    readonly timestamps: readonly string[];
-    readonly fkAutoIndex: boolean;
-}
-/**
- * Complete generated schema (output of dbsp generate manifest).
- *
- * @typeParam TTables - The tables type, preserving literal table names for autocomplete.
- *   When using `as const` on your schema definition, table names will be preserved.
- *
- * @example
- * ```typescript
- * const schema = {
- *   tables: {
- *     users: { id: { type: 'uuid', primaryKey: true }, name: { type: 'string' } },
- *     posts: { id: { type: 'uuid', primaryKey: true }, title: { type: 'string' } },
- *   },
- *   relations: {},
- *   hints: {},
- *   conventions: { fkPattern: '{singular}Id', pluralize: true, timestamps: [], fkAutoIndex: true },
- * } as const satisfies GeneratedSchema;
- *
- * // TypeScript knows: keyof typeof schema.tables = 'users' | 'posts'
- * ```
- */
-interface GeneratedSchema<TTables extends Record<string, GeneratedTable> = Record<string, GeneratedTable>> {
-    readonly tables: TTables;
-    readonly relations: Record<string, GeneratedRelation>;
-    readonly hints: Record<string, GeneratedHint>;
-    readonly conventions: GeneratedConventions;
-}
-/**
- * Map a GeneratedColumnType to its TypeScript runtime type.
- */
-type ColumnTypeToTS<T extends GeneratedColumnType> = T extends 'string' | 'text' | 'uuid' ? string : T extends 'number' | 'integer' | 'decimal' ? number : T extends 'bigint' ? bigint : T extends 'boolean' ? boolean : T extends 'date' | 'timestamp' | 'datetime' ? Date : T extends 'time' ? string : T extends 'json' | 'jsonb' ? unknown : T extends 'daterange' | 'tstzrange' | 'int4range' | 'tsrange' | 'int8range' | 'numrange' ? string : never;
-/**
- * Infer the TypeScript row type from a GeneratedTable definition.
- */
-type GeneratedColumnsOf<T extends GeneratedTable> = T extends GeneratedTableWithConfig ? T['columns'] : T;
-type InferRowType<T extends GeneratedTable> = {
-    [K in keyof GeneratedColumnsOf<T>]: GeneratedColumnsOf<T>[K] extends GeneratedColumn ? GeneratedColumnsOf<T>[K]['nullable'] extends true ? ColumnTypeToTS<GeneratedColumnsOf<T>[K]['type']> | null : ColumnTypeToTS<GeneratedColumnsOf<T>[K]['type']> : never;
-};
-/**
- * Infer the database type from a GeneratedSchema.
- * Maps each table name to its row type.
- *
- * @example
- * ```typescript
- * const schema = { tables: { users: { id: { type: 'uuid' } } } } as const satisfies GeneratedSchema;
- * type DB = InferDBFromSchema<typeof schema>;
- * // DB = { users: { id: string } }
- * ```
- */
-type InferDBFromSchema<S extends GeneratedSchema> = {
-    [TableName in keyof S['tables'] & string]: InferRowType<S['tables'][TableName]>;
-};
-/**
- * Build a ModelIR from a generated schema.
- *
- * This is the main entry point for the schema bridge.
- * It converts the output of `dbsp generate manifest` into a ModelIR
- * that can be used with createOrm.
- *
- * @example
- * ```typescript
- * import { schema } from './generated/dbsp/schema';
- * import { buildModelFromSchema, createOrm } from '@dbsp/core';
- *
- * const model = buildModelFromSchema(schema);
- * const orm = createOrm({ model, adapter });
- * ```
- */
-declare function buildModelFromSchema(schema: GeneratedSchema): ModelIR;
-/**
- * Build ModelIR directly from ResolvedSchema.
- *
- * Combines the conversion steps: ResolvedSchema → GeneratedSchema → ModelIR.
- * This is the canonical path for creating ModelIR from user-defined schemas.
- *
- * @example
- * ```typescript
- * import { defineSchema, buildModelFromResolvedSchema } from '@dbsp/core';
- *
- * const schema = defineSchema({ users: { ... } }, { relations: { ... } });
- * const model = buildModelFromResolvedSchema(schema);
- * ```
- */
-declare function buildModelFromResolvedSchema(schema: ResolvedSchema): ModelIR;
-/**
- * Type guard for GeneratedSchema.
- *
- * Note: Both GeneratedSchema and ResolvedSchema have the same structure,
- * so this check will return true for both. Use `isResolvedSchema()` to
- * specifically detect ResolvedSchema (from @dbsp/schema).
- */
-declare function isGeneratedSchema(value: unknown): value is GeneratedSchema;
-/**
- * Type guard for ResolvedSchema (from @dbsp/schema).
- *
- * Detects ResolvedSchema by checking for PostgreSQL-specific column types
- * like 'time' and 'jsonb' that only exist in ResolvedSchema.
- *
- * Note: If the schema has no such types, this may return false even for
- * a valid ResolvedSchema. In that case, the schema can be used directly
- * as a GeneratedSchema since both have the same structure.
- */
-declare function isResolvedSchema(value: unknown): boolean;
-/**
- * Normalize a schema input to GeneratedSchema.
- *
- * This function accepts either a GeneratedSchema or a ResolvedSchema
- * and returns a GeneratedSchema. If the input is already a GeneratedSchema,
- * it is returned as-is. If it's a ResolvedSchema, it is converted.
- *
- * This is the recommended way to accept schemas in APIs that need to
- * support both schema formats transparently.
- *
- * @param input - Either a GeneratedSchema or ResolvedSchema
- * @returns GeneratedSchema (possibly converted from ResolvedSchema)
- * @throws Error if the input is not a valid schema
- *
- * @example
- * ```typescript
- * import { normalizeSchema } from '@dbsp/core';
- *
- * // Works with GeneratedSchema (from codegen)
- * const schema1 = normalizeSchema(generatedSchema);
- *
- * // Works with ResolvedSchema (from defineSchema())
- * const schema2 = normalizeSchema(resolvedSchema);
- * ```
- */
-declare function normalizeSchema(input: unknown): GeneratedSchema;
-/**
- * Complete ResolvedSchema validation schema
- */
-declare const ResolvedSchemaValidation: v.ObjectSchema<{
-    readonly tables: v.SchemaWithPipe<readonly [v.UnknownSchema, v.CheckAction<unknown, "Schema keys must not include prototype-pollution names (__proto__, constructor, prototype)">, v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.ObjectSchema<{
-        readonly columns: v.SchemaWithPipe<readonly [v.UnknownSchema, v.CheckAction<unknown, "Schema keys must not include prototype-pollution names (__proto__, constructor, prototype)">, v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
-            readonly type: v.PicklistSchema<["uuid", "string", "text", "integer", "bigint", "decimal", "boolean", "timestamp", "date", "time", "json", "jsonb", "daterange", "tstzrange", "int4range", "tsrange", "int8range", "numrange"], undefined>;
-            readonly primaryKey: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly nullable: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly unique: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly autoIncrement: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly default: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>], undefined>, undefined>;
-            readonly references: v.OptionalSchema<v.ObjectSchema<{
-                readonly table: v.StringSchema<undefined>;
-                readonly column: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                readonly onDelete: v.OptionalSchema<v.PicklistSchema<["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"], undefined>, undefined>;
-                readonly index: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-                readonly parentRole: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-                readonly childRole: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>;
-            readonly index: v.OptionalSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>], undefined>, undefined>;
-        }, undefined>, undefined>]>;
-        readonly primaryKey: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
-        readonly foreignKeys: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly columns: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-            readonly references: v.ObjectSchema<{
-                readonly table: v.StringSchema<undefined>;
-                readonly columns: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>;
-            readonly onDelete: v.OptionalSchema<v.PicklistSchema<["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"], undefined>, undefined>;
-            readonly onUpdate: v.OptionalSchema<v.PicklistSchema<["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"], undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-        readonly indexes: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly columns: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-            readonly unique: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, v.SchemaWithPipe<readonly [v.UnknownSchema, v.CheckAction<unknown, "Schema keys must not include prototype-pollution names (__proto__, constructor, prototype)">, v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
-        readonly type: v.PicklistSchema<["uuid", "string", "text", "integer", "bigint", "decimal", "boolean", "timestamp", "date", "time", "json", "jsonb", "daterange", "tstzrange", "int4range", "tsrange", "int8range", "numrange"], undefined>;
-        readonly primaryKey: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        readonly nullable: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        readonly unique: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        readonly autoIncrement: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        readonly default: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.BooleanSchema<undefined>], undefined>, undefined>;
-        readonly references: v.OptionalSchema<v.ObjectSchema<{
-            readonly table: v.StringSchema<undefined>;
-            readonly column: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            readonly onDelete: v.OptionalSchema<v.PicklistSchema<["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"], undefined>, undefined>;
-            readonly index: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-            readonly parentRole: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-            readonly childRole: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>;
-        readonly index: v.OptionalSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>], undefined>, undefined>;
-    }, undefined>, undefined>]>], undefined>, undefined>]>;
-    readonly relations: v.SchemaWithPipe<readonly [v.UnknownSchema, v.CheckAction<unknown, "Schema keys must not include prototype-pollution names (__proto__, constructor, prototype)">, v.RecordSchema<v.StringSchema<undefined>, v.VariantSchema<"kind", [v.ObjectSchema<{
-        readonly kind: v.LiteralSchema<"belongsTo", undefined>;
-        readonly target: v.StringSchema<undefined>;
-        readonly foreignKey: v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>;
-        readonly targetKey: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
-        readonly includeStrategy: v.OptionalSchema<v.PicklistSchema<["join", "subquery", "cte", "lateral", "json_agg", "auto"], undefined>, undefined>;
-    }, undefined>, v.ObjectSchema<{
-        readonly kind: v.LiteralSchema<"hasMany", undefined>;
-        readonly target: v.StringSchema<undefined>;
-        readonly foreignKey: v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>;
-        readonly sourceKey: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
-        readonly includeStrategy: v.OptionalSchema<v.PicklistSchema<["join", "subquery", "cte", "lateral", "json_agg", "auto"], undefined>, undefined>;
-    }, undefined>, v.ObjectSchema<{
-        readonly kind: v.LiteralSchema<"manyToMany", undefined>;
-        readonly target: v.StringSchema<undefined>;
-        readonly through: v.StringSchema<undefined>;
-        readonly sourceFk: v.StringSchema<undefined>;
-        readonly targetFk: v.StringSchema<undefined>;
-        readonly includeStrategy: v.OptionalSchema<v.PicklistSchema<["join", "subquery", "cte", "lateral", "json_agg", "auto"], undefined>, undefined>;
-    }, undefined>], undefined>, undefined>]>;
-    readonly hints: v.SchemaWithPipe<readonly [v.UnknownSchema, v.CheckAction<unknown, "Schema keys must not include prototype-pollution names (__proto__, constructor, prototype)">, v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
-        readonly defaultStrategy: v.OptionalSchema<v.PicklistSchema<["exists", "join"], undefined>, undefined>;
-        readonly cardinality: v.OptionalSchema<v.PicklistSchema<["one", "many"], undefined>, undefined>;
-    }, undefined>, undefined>]>;
-    readonly conventions: v.ObjectSchema<{
-        readonly fkPattern: v.StringSchema<undefined>;
-        readonly pluralize: v.BooleanSchema<undefined>;
-        readonly timestamps: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-        readonly fkAutoIndex: v.BooleanSchema<undefined>;
-    }, undefined>;
-    readonly indexes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnknownSchema, v.CheckAction<unknown, "Schema keys must not include prototype-pollution names (__proto__, constructor, prototype)">, v.RecordSchema<v.StringSchema<undefined>, v.ArraySchema<v.ObjectSchema<{
-        readonly columns: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-        readonly unique: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>]>, undefined>;
-}, undefined>;
-/**
- * Type inferred from ResolvedSchemaValidation
- */
-type ValidatedResolvedSchema = v.InferOutput<typeof ResolvedSchemaValidation>;
-/**
- * Result of schema conversion.
- */
-type SchemaConversionResult = {
-    success: true;
-    schema: GeneratedSchema;
-} | {
-    success: false;
-    errors: v.BaseIssue<unknown>[];
-};
-/**
- * Convert a ResolvedSchema (from @dbsp/schema) to GeneratedSchema.
- *
- * This function validates the input using Valibot and then converts the
- * schema structure to the format expected by createOrm().
- *
- * @param input - The ResolvedSchema to convert (output of defineSchema())
- * @returns Conversion result with either the converted schema or validation errors
- *
- * @example
- * ```typescript
- * import { defineSchema } from '@dbsp/schema';
- * import { resolvedSchemaToGeneratedSchema, createOrm } from '@dbsp/core';
- *
- * const resolved = defineSchema({ tables: { users: { id: { type: 'uuid' } } } });
- * const result = resolvedSchemaToGeneratedSchema(resolved);
- *
- * if (result.success) {
- *   const orm = createOrm({ schema: result.schema, adapter });
- * } else {
- *   console.error('Schema validation failed:', result.errors);
- * }
- * ```
- */
-declare function resolvedSchemaToGeneratedSchema(input: unknown): SchemaConversionResult;
-/**
- * Assert and convert a ResolvedSchema to GeneratedSchema.
- *
- * Throws an error if validation fails. Use this when you're confident
- * the input is valid and want cleaner code without result checking.
- *
- * @param input - The ResolvedSchema to convert
- * @returns The converted GeneratedSchema
- * @throws Error if validation fails
- */
-declare function assertResolvedSchemaToGeneratedSchema(input: unknown): GeneratedSchema;
-
 /**
  * Type definitions for table-scoped DDL operations.
  *
@@ -4654,9 +3915,9 @@ type TableDDL = {
  */
 /**
  * Union type for all ORM options.
- * Prefer specific option types (OrmOptionsWithModel, OrmOptionsWithSchema, OrmOptionsWithAdapter).
+ * Prefer specific option types (OrmOptionsWithModel, OrmOptionsWithAdapter).
  */
-type OrmOptions<DB = unknown> = OrmOptionsWithModel<DB> | OrmOptionsWithSchema<GeneratedSchema, DB> | OrmOptionsWithAdapter<DB>;
+type OrmOptions<DB = unknown> = OrmOptionsWithModel<DB> | OrmOptionsWithAdapter<DB>;
 /**
  * Base options shared by all ORM option variants.
  */
@@ -4711,30 +3972,11 @@ interface OrmOptionsBase<DB = unknown> {
 }
 /**
  * OrmOptions with explicit model (sync creation).
- * Prefer OrmOptionsWithSchema for codegen-first approach.
  */
 interface OrmOptionsWithModel<DB = unknown> extends OrmOptionsBase<DB> {
     readonly model: ModelIR;
     readonly schema?: never;
 }
-/**
- * OrmOptions with generated schema (sync creation, codegen-first).
- * Preferred approach for ARCH-002 codegen-first architecture.
- *
- * @typeParam TSchema - The schema type (inferred from schema value)
- * @typeParam DB - The database type (inferred from TSchema when possible)
- *
- * @example
- * ```typescript
- * const schema = { tables: { users: { id: { type: 'uuid' } } } } as const satisfies GeneratedSchema;
- * const orm = createOrm({ schema, adapter });
- * // DB is inferred as { users: { id: string } }
- * ```
- */
-interface OrmOptionsWithSchema<TSchema extends GeneratedSchema = GeneratedSchema, DB = InferDBFromSchema<TSchema>> extends OrmOptionsBase<DB> {
-    readonly schema: TSchema;
-    readonly model?: never;
-}
 /**
  * OrmOptions without model, requires adapter for auto-introspection (async creation).
  */
@@ -4746,7 +3988,7 @@ interface OrmOptionsWithAdapter<DB = unknown> extends OrmOptionsBase<DB> {
 /**
  * ORM instance created by createOrm().
  *
- * @typeParam DB - Database schema type (Kysely-like).
+ * @typeParam DB - Database row map type.
  *   Keys are table names, values are row types.
  *   When provided, query() method provides autocomplete for table names
  *   and infers result types automatically.
@@ -4770,18 +4012,17 @@ interface OrmOptionsWithAdapter<DB = unknown> extends OrmOptionsBase<DB> {
 /**
  * PUBLIC ORM instance type — the interface consumers see from createOrm().
  *
- * String-based table entry points (select, insert, update, delete, upsert) are
- * intentionally absent. Use the typed TableRef-based methods instead:
- *   - `orm.from(table)` — SELECT
- *   - `orm.into(table)` — INSERT
- *   - `orm.modify(table)` — UPDATE
- *   - `orm.removeFrom(table)` — DELETE
- *   - `orm.upsertInto(table)` — UPSERT (INSERT ... ON CONFLICT)
+ * SELECT queries can start from either first-class table entry point:
+ *   - `orm.select(name)` - concise table-name form
+ *   - `orm.from(table)` - TableRef form with column-level types
  *
- * Internal code (NQL, planner, tests) that needs string-based access should
- * cast to `OrmInstanceInternal<DB>`.
+ * Mutations use the typed TableRef-based methods:
+ *   - `orm.into(table)` - INSERT
+ *   - `orm.modify(table)` - UPDATE
+ *   - `orm.removeFrom(table)` - DELETE
+ *   - `orm.upsertInto(table)` - UPSERT (INSERT ... ON CONFLICT)
  *
- * @typeParam DB - Database schema type (Kysely-like).
+ * @typeParam DB - Database row map type.
  *   Keys are table names, values are row types.
  *
  * @example
@@ -4799,7 +4040,7 @@ interface OrmOptionsWithAdapter<DB = unknown> extends OrmOptionsBase<DB> {
  *
  * @example
  * ```typescript
- * // With Schema wrapper (from schema() / defineSchema())
+ * // With Schema wrapper from schema()
  * const db = schema({ users: { id: 'integer', name: 'string' } });
  * type MyOrm = OrmOf<typeof db>;  // unwraps Schema<T> → InferDB<T>
  *
@@ -4845,19 +4086,43 @@ interface OrmInstance<DB = Record<string, unknown>> {
      * Use destructuring to get individual table references, then pass
      * them to `from()` for type-safe queries.
      *
+     * Each entry also carries the runtime DDL helpers (`.truncate()`,
+     * `.indexes.list()`, `.alterColumn()`, …) via the `TableDDL` mixin, mirroring
+     * what `wrapTablesProxyWithDDL` produces at runtime.
+     *
      * @example
      * ```typescript
      * const { users, posts } = orm.tables;
      * const activeUsers = await orm.from(users).where(eq(users.active, true)).all();
+     * const indexes = await orm.tables.users.indexes.list();
      * ```
      *
      * @since DX-040-SURFACE
      */
     readonly tables: {
-        [K in keyof DB & string]: TableRef<K, RowToColumnRefs<K, DB[K]>, any>;
+        [K in keyof DB & string]: TableRef<K, RowToColumnRefs<K, DB[K]>, any> & TableDDL;
     };
     /**
-     * Start a type-safe SELECT query from a TableRef.
+     * Start building a SELECT query from a table name (string-based API).
+     *
+     * This is the ordinary table-name API used throughout guides and examples.
+     * Use `orm.from(orm.tables.<table>)` when you want the stricter TableRef-based
+     * form with column-level type information for filters, ordering, and result
+     * inference.
+     *
+     * @typeParam K - Table name (inferred from DB keys when typed)
+     * @typeParam TResult - Override result type (defaults to DB[K])
+     * @param from - The root table name to select from
+     * @returns A QueryBuilder for constructing the select
+     */
+    select<K extends keyof DB & string, TResult = DB[K]>(from: K): QueryBuilder<TResult>;
+    /**
+     * Start building a SELECT query from a typed TableRef.
+     *
+     * This is the stricter table-reference API. Use it when you want column refs
+     * from `orm.tables.<table>` to carry column-level types into filters and other
+     * query clauses. Use `orm.select('<table>')` when the shorter table-name form is
+     * enough.
      *
      * @typeParam TTable - The TableRef type (inferred from the argument)
      * @param table - A TableRef from `orm.tables`
@@ -4871,18 +4136,6 @@ interface OrmInstance<DB = Record<string, unknown>> {
      *
      * @since DX-040-SURFACE
      */
-    /**
-     * Start building a SELECT query from a table name (string-based API).
-     *
-     * @deprecated Use `orm.from(orm.tables.<table>)` for type-safe queries.
-     * String-based select is kept for backward compatibility and test convenience.
-     *
-     * @typeParam K - Table name (inferred from DB keys when typed)
-     * @typeParam TResult - Override result type (defaults to DB[K])
-     * @param from - The root table name to select from
-     * @returns A QueryBuilder for constructing the select
-     */
-    select<K extends keyof DB & string, TResult = DB[K]>(from: K): QueryBuilder<TResult>;
     from<TTable extends TableRef<any, any, any>>(table: TTable): QueryBuilder<InferTableRow<TTable>>;
     /**
      * Start a SELECT query from a BatchValuesRef source (unnest-backed virtual table).
@@ -6251,10 +5504,10 @@ declare function coalesce(fields: readonly string[], as: string): ExpressionSpec
  */
 declare function raw(sqlFragment: string, as: string): ExpressionSpec;
 /**
- * Creates a column alias expression using native Kysely API.
+ * Creates a column alias expression as a typed dbsp expression intent.
  * Preferred over raw() for simple column aliasing as it's type-safe and dialect-portable.
  *
- * Uses Kysely's `eb.ref(column).as(alias)` internally - no raw SQL.
+ * Compilers render the alias from structured column and alias fields - no raw SQL.
  *
  * @param column - Column name to select
  * @param alias - Alias for the result column
@@ -6279,8 +5532,8 @@ declare function col(column: string, alias: string): ExpressionSpec;
  * Creates a relation column expression for selecting a column from a related table.
  * Auto-creates JOINs via the include mechanism and selects with custom alias.
  *
- * Uses native Kysely API internally - no raw SQL. The compiler resolves the relation
- * to its join alias and uses `eb.ref(alias.column).as(as)`.
+ * Uses structured relation-column intent - no raw SQL. The compiler resolves the
+ * relation to its join alias and renders a dialect-specific aliased column.
  *
  * @param relation - Relation path to traverse (dot-separated for multi-level)
  * @param column - Column name to select from the target relation
@@ -7312,7 +6565,7 @@ declare function pipeOnErrorHooks(...hooks: OnErrorHook[]): OnErrorHook;
 /**
  * DX-023: Lightweight ModelIR Definition
  *
- * Provides a simplified API for defining relations when using Kysely's Database type.
+ * Provides a simplified API for defining relations from a database row map type.
  * Instead of verbose column definitions, developers can focus solely on relations
  * using shorthand syntax with automatic FK inference.
  *
@@ -7743,7 +6996,7 @@ interface SimplifiedOrmOptions<T extends SchemaDefinition = SchemaDefinition> {
 /**
  * Create an ORM instance with the specified configuration.
  *
- * @typeParam DB - Database schema type (Kysely-like).
+ * @typeParam DB - Database row map type.
  *   Keys are table names, values are row types.
  *   When provided, query() provides autocomplete and type inference.
  *
@@ -8366,4 +7619,4 @@ declare const assertIntentHasOrderBy: (result: AssertionQueryResult, expected: b
  */
 declare function runAssertions(blocks: AssertionBlock[], results: AssertionQueryResult[], queries: string[], hasDb?: boolean): AssertionSummary;
 
-export { ASSERTION_TYPES, AdapterRequiredError, type AdjacencyOptions, type AfterMutationHook, type AfterQueryHook, type AggregateOptions, type AliasedColumn, type AliasedExprColumn, type AllColumns, AmbiguousPlanError, AmbiguousRelationError, type Assertion, type AssertionBlock, type AssertionOutcome, type AssertionQueryResult, type AssertionSummary, type AssertionType, BRAND, type BatchValuesOptions, type BatchValuesRef, type BeforeMutationHook, type BeforeQueryHook, type BrandKey, COLUMN_META, type CardinalityShorthand, CaseBuilder, type CaseValue, type ColumnDef, type ColumnMetaKey, ColumnNotFoundError, type ColumnRef, type ColumnSpec, type ColumnTypeToTS, CteBuilder, type CteDump, CteQueryBuilder, type CursorPaginateOptions, type CursorPaginatedResult, DEFAULT_CONVENTIONS, DEFAULT_FEATURE_CHECKERS, DUCKDB_CAPABILITIES, type DefaultFilters, type DefineModelOptions, DeleteBuilder, type DistinctField, type DumpMetaInput, type EdgeTableOptions, type EmitWarningOptions, ErrorCode, type ErrorHookContext, Errors, ExecutionError, type ExprInput, ExpressionRef, type ExpressionSpec, type FeatureChecker, type FeatureUsage, type FilterOperators, type FilterValue, type FullTextSearchField, type FullTextSearchOptions, type GeneratedBelongsTo, type GeneratedColumn, type GeneratedColumnType, type GeneratedConventions, type GeneratedHasMany, type GeneratedHint, type GeneratedManyToMany, type GeneratedRelation, type GeneratedRelationKind, type GeneratedSchema, type GeneratedTable, type GetSchemaFromDbOptions, type HierarchyOptions, type HookErrorHandler, type HookManager, type HookPriority, type HydrateOptions, IRREGULAR_PLURALS, type IncludeOptions, type IncludeOptionsWithRecursive, type InferColumn, type InferColumnType, type InferColumnTypes, type InferDB, type InferDBFromSchema, type InferRefColumn, type InferRow, type InferRowType, type InferSchemaDB, type InferTableRow, type InferTables, type InferredRangeValue, InsertBuilder, IntentBuilder, type IntentBuilderState, type IntentSummary, InvalidOperationError, InvalidRelationDefinitionError, type JoinOptions, type JsonValue, type LightweightRelationsDef, type ListHierarchyOptions, type ListIndexOptions, type Logger, MSSQL_CAPABILITIES, MYSQL_CAPABILITIES, ModelIRImpl, type MutationDump, type MutationHookContext, type MutationOperation, NamingConventionMismatchError, type NegotiationResult, type NestedInclude, type SchemaColumnType$1 as NewSchemaColumnType, NotFoundError, type NqlBuilder, type NqlRawFragment, type NqlTag, type OnErrorHook, type OrderByInput, type OrderByRecord, type OrderBySpec, type OrmInstance, type OrmOf, type OrmOptions, type OrmOptionsWithAdapter, type OrmOptionsWithModel, type OrmOptionsWithSchema, POSTGRESQL_CAPABILITIES, type PaginateOptions, type PaginatedResult, type ParseError, type ParseResult, type ParsedRelationDef, type ParsedRelationKey, type PathOptions, type PrioritizedHook, type QueryAssertionResult, type QueryBuilder, type QueryHookContext, type QueryResultType, RELATION_META, type RangeType, RawCteQueryBuilder, type RecursiveDump, type RecursiveIncludeConfig, type RecursiveOptions, RecursiveShapeMismatchError, type RefDefinition, type RefOptions, type RelationHints, type RelationKey, type RelationMetaKey, RelationNotFoundError, type RelationObjectDef, type RelationPathIncludeNode, type RelationPathUsage, type RelationRef, type RelationShorthand, type RelationTupleDef, type ResolvedSchema, ResolvedSchemaValidation, ResultHydrator, SQLITE_CAPABILITIES, SQL_RAW_MARKER, type Schema, type SchemaBelongsToRelation, type SchemaCardinality, type SchemaColumnDefinition, type SchemaColumnType, type SchemaConfigInput, type SchemaConstraints, type SchemaConventionsDefinition, type SchemaConversionResult, type SchemaDefinition, type SchemaDefinitionInput, SchemaValidationError$1 as SchemaError, type SchemaExtras, type SchemaFilterStrategy, type SchemaForeignKeyReference, type SchemaHasManyRelation, type SchemaHintDefinition, type SchemaHintsDefinition, type SchemaIndexDefinition, type SchemaIndexOptions, type SchemaIndexesDefinition, type SchemaManyToManyRelation, type SchemaOnDeleteAction, type SchemaOptions, type SchemaRelationDefinition, type SchemaRelationKind, type SchemaRelationsDefinition, type SchemaTableDefinition, type SchemaTableOptions, type SchemaTablesDefinition, SchemaValidationError, type SelectField, type SelfRefRoles, type SetOperationBuilder, type SimplifiedOrmOptions, type SqlRawExpression, type StreamOptions, SubqueryBuilder, SubqueryExpression, TABLE_META, type TableAssertionData, type TableDDL, type TableDef, type TableIndexes, type TableMetaKey, TableNotFoundError, type TableRef, type TraversalDirection, UnhandledTypeInDialect, UnknownDialectError, UnsafeOperationError, UnsupportedCapabilityError, UnsupportedFeatureError, UnsupportedStrategyError, UpdateBuilder, UpsertBuilder, type ValidatedResolvedSchema, type WarningCategory, type WhereFilter, WindowBuilder, aggOrderBy, and, any, array, arrayAgg, assertCapability, assertContains, assertDbColumnExists, assertDbOutput, assertDbRowsEquals, assertDbRowsMax, assertDbRowsMin, assertDbValueEquals, assertEquals, assertIntentHasGroupBy, assertIntentHasOrderBy, assertIntentHasWhere, assertIntentTable, assertIntentType, assertIntentWith, assertMatches, assertParamsEquals, assertParamsLength, assertParamsType, assertParamsValue, assertResolvedSchemaToGeneratedSchema, assertSQLColumn, assertSQLEquals, assertSQLJoin, assertSQLTable, assertSuccess, assertTypeSupported, batchValues, buildModelFromResolvedSchema, buildModelFromSchema, capitalize, caseWhen, cast, coalesce, col, composeAfterMutationHooks, composeAfterQueryHooks, composeBeforeMutationHooks, composeBeforeQueryHooks, composeOnErrorHooks, countDistinctRelationPathsByName, createDialectCapabilities, createHookManager, createNqlTag, createOrm, createPseudoColumnMetadata, createRawCteBuilder, createRecursiveMetadata, decapitalize, defaultLogger, defineModel, defineSchema, denseRank, deriveRelationPathFromIntentPath, detectForeignKeys, detectManyToMany, distinct, emitWarning, eq, every, exists, ref as exprRef, extendDialect, extractPseudoColumnKeywords, findClosestMatch, fn, fullTextSearch, getAvailableDialects, getDialectCapabilities, getLogger, getRelationKind, getSchemaFromDb, gt, gte, inArray, inSubquery, inferForeignKey, inferRelationsFromSchema, isAliasedColumn, isAllColumns, isBatchValuesRef, isBelongsTo, isCardinalityShorthand, isColumnRef, isDistinctField, isDistinctFrom, isExpressionSpec, isGeneratedSchema, isHasMany, isKnownDialect, isManyToMany, isNotNull, isNull, isOverallSuccess, isRecursiveIncludeOptions, isRecursiveRelation, isRef, isRelationObjectDef, isRelationRef, isRelationTupleDef, isResolvedSchema, isSelfReferential, isSqlRaw, isSubqueryExpression, isTableRef, isWhereIntent, lag, lead, like, literal, lt, lte, namedArg, negotiateFeatures, neq, none, normalizeSQL, normalizeSchema, not, notExists, nqlRaw, objectToWhereIntent, op, or, outerRef, param, parseAssertionFile, parseRelationDef, parseRelationKey, pipeAfterMutationHooks, pipeAfterQueryHooks, pipeBeforeMutationHooks, pipeBeforeQueryHooks, pipeOnErrorHooks, plan, planRecursive, pluralize, rangeContainedBy, rangeContains, rangeOverlaps, rank, raw, rawExists, rawNotExists, ref$1 as ref, registerDialect, relationColumn, requiresDatabase, resetLogger, resolveQueryIndex, resolvedSchemaToGeneratedSchema, rowNumber, runAssertions, schema, schemaToModelIR, setLogger, silentLogger, singularize, some, sortByPriority, sql, star, stringAgg, subquery, supportsDDLGeneration, supportsExecution, supportsIntrospection, supportsRawSql, supportsStreaming, supportsTransactions, textScore, unary, validateAssertionBlocks, validateRecursiveInclude, validateRecursiveShape, validateTypeName, wAvg, wCount, wMax, wMin, wSum, withPriority };
+export { ASSERTION_TYPES, AdapterRequiredError, type AdjacencyOptions, type AfterMutationHook, type AfterQueryHook, type AggregateOptions, type AliasedColumn, type AliasedExprColumn, type AllColumns, AmbiguousPlanError, AmbiguousRelationError, type Assertion, type AssertionBlock, type AssertionOutcome, type AssertionQueryResult, type AssertionSummary, type AssertionType, BRAND, type BatchValuesOptions, type BatchValuesRef, type BeforeMutationHook, type BeforeQueryHook, type BrandKey, COLUMN_META, type CardinalityShorthand, CaseBuilder, type CaseValue, type ColumnDef, type ColumnMetaKey, ColumnNotFoundError, type ColumnRef, type ColumnSpec, CteBuilder, type CteDump, CteQueryBuilder, type CursorPaginateOptions, type CursorPaginatedResult, DEFAULT_FEATURE_CHECKERS, DUCKDB_CAPABILITIES, type DefaultFilters, type DefineModelOptions, DeleteBuilder, type DistinctField, type DumpMetaInput, type EdgeTableOptions, type EmitWarningOptions, ErrorCode, type ErrorHookContext, Errors, ExecutionError, type ExprInput, ExpressionRef, type ExpressionSpec, type FeatureChecker, type FeatureUsage, type FilterOperators, type FilterValue, type FullTextSearchField, type FullTextSearchOptions, type GetSchemaFromDbOptions, type HierarchyOptions, type HookErrorHandler, type HookManager, type HookPriority, type HydrateOptions, IRREGULAR_PLURALS, type IncludeOptions, type IncludeOptionsWithRecursive, type InferColumn, type InferColumnType, type InferColumnTypes, type InferDB, type InferRefColumn, type InferRow, type InferSchemaDB, type InferTableRow, type InferTables, type InferredRangeValue, InsertBuilder, IntentBuilder, type IntentBuilderState, type IntentSummary, InvalidOperationError, InvalidRelationDefinitionError, type JoinOptions, type JsonValue, type LightweightRelationsDef, type ListHierarchyOptions, type ListIndexOptions, type Logger, MSSQL_CAPABILITIES, MYSQL_CAPABILITIES, ModelIRImpl, type MutationDump, type MutationHookContext, type MutationOperation, NamingConventionMismatchError, type NegotiationResult, type NestedInclude, type SchemaColumnType as NewSchemaColumnType, NotFoundError, type NqlBuilder, type NqlRawFragment, type NqlTag, type OnErrorHook, type OrderByInput, type OrderByRecord, type OrderBySpec, type OrmInstance, type OrmOf, type OrmOptions, type OrmOptionsWithAdapter, type OrmOptionsWithModel, POSTGRESQL_CAPABILITIES, type PaginateOptions, type PaginatedResult, type ParseError, type ParseResult, type ParsedRelationDef, type ParsedRelationKey, type PathOptions, type PrioritizedHook, type QueryAssertionResult, type QueryBuilder, type QueryHookContext, type QueryResultType, RELATION_META, type RangeType, RawCteQueryBuilder, type RecursiveDump, type RecursiveIncludeConfig, type RecursiveOptions, RecursiveShapeMismatchError, type RefDefinition, type RefOptions, type RelationHints, type RelationKey, type RelationMetaKey, RelationNotFoundError, type RelationObjectDef, type RelationPathIncludeNode, type RelationPathUsage, type RelationRef, type RelationShorthand, type RelationTupleDef, ResultHydrator, SQLITE_CAPABILITIES, SQL_RAW_MARKER, type Schema, type SchemaColumnType, type SchemaConstraints, type SchemaDefinition, SchemaValidationError as SchemaError, type SchemaExtras, type SchemaIndexOptions, type SchemaIndexValidationInput, type SchemaOptions, type SchemaTableOptions, SchemaValidationError, type SelectField, type SelfRefRoles, type SetOperationBuilder, type SimplifiedOrmOptions, type SqlRawExpression, type StreamOptions, SubqueryBuilder, SubqueryExpression, TABLE_META, type TableAssertionData, type TableDDL, type TableDef, type TableIndexes, type TableMetaKey, TableNotFoundError, type TableRef, type TraversalDirection, UnhandledTypeInDialect, UnknownDialectError, UnsafeOperationError, UnsupportedCapabilityError, UnsupportedFeatureError, UnsupportedStrategyError, UpdateBuilder, UpsertBuilder, type WarningCategory, type WhereFilter, WindowBuilder, aggOrderBy, and, any, array, arrayAgg, assertCapability, assertContains, assertDbColumnExists, assertDbOutput, assertDbRowsEquals, assertDbRowsMax, assertDbRowsMin, assertDbValueEquals, assertEquals, assertIntentHasGroupBy, assertIntentHasOrderBy, assertIntentHasWhere, assertIntentTable, assertIntentType, assertIntentWith, assertMatches, assertParamsEquals, assertParamsLength, assertParamsType, assertParamsValue, assertSQLColumn, assertSQLEquals, assertSQLJoin, assertSQLTable, assertSuccess, assertTypeSupported, batchValues, capitalize, caseWhen, cast, coalesce, col, composeAfterMutationHooks, composeAfterQueryHooks, composeBeforeMutationHooks, composeBeforeQueryHooks, composeOnErrorHooks, countDistinctRelationPathsByName, createDialectCapabilities, createHookManager, createNqlTag, createOrm, createPseudoColumnMetadata, createRawCteBuilder, createRecursiveMetadata, decapitalize, defaultLogger, defineModel, denseRank, deriveRelationPathFromIntentPath, distinct, emitWarning, eq, every, exists, ref as exprRef, extendDialect, extractPseudoColumnKeywords, findClosestMatch, fn, fullTextSearch, getAvailableDialects, getDialectCapabilities, getLogger, getRelationKind, getSchemaFromDb, gt, gte, inArray, inSubquery, inferForeignKey, isAliasedColumn, isAllColumns, isBatchValuesRef, isCardinalityShorthand, isColumnRef, isDistinctField, isDistinctFrom, isExpressionSpec, isKnownDialect, isNotNull, isNull, isOverallSuccess, isRecursiveIncludeOptions, isRecursiveRelation, isRef, isRelationObjectDef, isRelationRef, isRelationTupleDef, isSelfReferential, isSqlRaw, isSubqueryExpression, isTableRef, isWhereIntent, lag, lead, like, literal, lt, lte, namedArg, negotiateFeatures, neq, none, normalizeSQL, not, notExists, nqlRaw, objectToWhereIntent, op, or, outerRef, param, parseAssertionFile, parseRelationDef, parseRelationKey, pipeAfterMutationHooks, pipeAfterQueryHooks, pipeBeforeMutationHooks, pipeBeforeQueryHooks, pipeOnErrorHooks, plan, planRecursive, pluralize, rangeContainedBy, rangeContains, rangeOverlaps, rank, raw, rawExists, rawNotExists, ref$1 as ref, registerDialect, relationColumn, requiresDatabase, resetLogger, resolveQueryIndex, rowNumber, runAssertions, schema, schemaToModelIR, setLogger, silentLogger, singularize, some, sortByPriority, sql, star, stringAgg, subquery, supportsDDLGeneration, supportsExecution, supportsIntrospection, supportsRawSql, supportsStreaming, supportsTransactions, textScore, unary, validateAssertionBlocks, validateRecursiveInclude, validateRecursiveShape, validateSchemaIndexOptions, validateTypeName, wAvg, wCount, wMax, wMin, wSum, withPriority };