metal-orm 1.0.13 → 1.0.15

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { O as OperandNode, C as ColumnDef, a as ColumnNode, B as BinaryExpressionNode, E as ExpressionNode, L as LogicalExpressionNode, N as NullExpressionNode, b as LiteralNode, I as InExpressionNode, c as BetweenExpressionNode, J as JsonPathNode, d as CaseExpressionNode, S as SelectQueryNode, e as ExistsExpressionNode, W as WindowFunctionNode, f as OrderDirection, F as FunctionNode, g as ScalarSubqueryNode, T as TableDef, h as InsertQueryNode, i as InsertCompiler, j as CompiledQuery, U as UpdateQueryNode, k as UpdateCompiler, D as DeleteQueryNode, l as DeleteCompiler, m as Dialect, n as CompilerContext, o as ForeignKeyReference, p as IndexColumn, q as IndexDef, r as DbExecutor, H as HydrationPlan, R as RelationMap, s as OrmContext, t as Entity, u as HasManyRelation, v as BelongsToRelation, w as BelongsToManyRelation, x as HasManyCollection, y as BelongsToReference, M as ManyToManyCollection, z as SelectQueryBuilder } from './select-CCp1oz9p.cjs';
-export { a0 as CascadeMode, A as CheckConstraint, a5 as ColumnToTs, Q as ColumnType, Y as DefaultValue, al as DomainEventHandler, af as EntityStatus, aj as HasDomainEvents, a6 as InferRow, am as OrmContextOptions, ak as OrmInterceptor, an as QueryLogEntry, ao as QueryLogger, ag as QueryResult, X as RawDefaultValue, V as ReferentialAction, ai as RelationChange, a1 as RelationDef, ah as RelationKey, _ as RelationKinds, $ as RelationType, K as TableHooks, G as TableOptions, ae as addDomainEvent, a3 as belongsTo, a4 as belongsToMany, Z as col, a7 as createColumn, a8 as createLiteral, P as defineTable, a2 as hasMany, ab as isCaseExpressionNode, ad as isExpressionSelectionNode, aa as isFunctionNode, a9 as isOperandNode, ac as isWindowFunctionNode } from './select-CCp1oz9p.cjs';
+import { O as OperandNode, C as ColumnRef, a as ColumnNode, B as BinaryExpressionNode, E as ExpressionNode, L as LogicalExpressionNode, N as NullExpressionNode, b as LiteralNode, I as InExpressionNode, c as BetweenExpressionNode, J as JsonPathNode, d as CaseExpressionNode, S as SelectQueryNode, e as ExistsExpressionNode, W as WindowFunctionNode, f as OrderDirection, F as FunctionNode, g as ScalarSubqueryNode, h as ColumnDef, T as TableRef, i as TableDef, j as InsertQueryNode, k as InsertCompiler, l as CompiledQuery, D as Dialect, m as DialectKey, U as UpdateQueryNode, n as UpdateCompiler, o as DeleteQueryNode, p as DeleteCompiler, q as CompilerContext, r as ForeignKeyReference, s as IndexColumn, t as IndexDef, u as DbExecutor, H as HydrationPlan, R as RelationMap, v as OrmContext, w as Entity, x as HasManyRelation, y as HasOneRelation, z as BelongsToRelation, A as BelongsToManyRelation, G as HasManyCollection, K as BelongsToReference, M as ManyToManyCollection, P as SelectQueryBuilder } from './select-Bkv8g8u_.cjs';
+export { a4 as CascadeMode, Q as CheckConstraint, aa as ColumnToTs, Z as ColumnType, a0 as DefaultValue, au as DomainEventHandler, ao as EntityStatus, as as HasDomainEvents, ac as HasOneReference, am as HydrationMetadata, ak as HydrationPivotPlan, al as HydrationRelationPlan, ab as InferRow, av as OrmContextOptions, at as OrmInterceptor, aw as QueryLogEntry, ax as QueryLogger, ap as QueryResult, $ as RawDefaultValue, _ as ReferentialAction, ar as RelationChange, a5 as RelationDef, aq as RelationKey, a2 as RelationKinds, a3 as RelationType, az as SimpleQueryRunner, X as TableHooks, V as TableOptions, an as addDomainEvent, a8 as belongsTo, a9 as belongsToMany, a1 as col, ad as createColumn, aA as createExecutorFromQueryRunner, ae as createLiteral, Y as defineTable, a6 as hasMany, a7 as hasOne, ah as isCaseExpressionNode, aj as isExpressionSelectionNode, ag as isFunctionNode, af as isOperandNode, ai as isWindowFunctionNode, ay as rowsToQueryResult } from './select-Bkv8g8u_.cjs';
 
 /**
  * Converts a primitive or existing operand into an operand node
@@ -7,40 +7,40 @@ export { a0 as CascadeMode, A as CheckConstraint, a5 as ColumnToTs, Q as ColumnT
  * @returns OperandNode representing the value
  */
 declare const valueToOperand: (value: unknown) => OperandNode;
-declare const columnOperand: (col: ColumnDef | ColumnNode) => ColumnNode;
+declare const columnOperand: (col: ColumnRef | ColumnNode) => ColumnNode;
 /**
  * Creates an equality expression (left = right)
  * @param left - Left operand
  * @param right - Right operand
  * @returns Binary expression node with equality operator
  */
-declare const eq: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDef | string | number) => BinaryExpressionNode;
+declare const eq: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number | boolean) => BinaryExpressionNode;
 /**
  * Creates a not equal expression (left != right)
  */
-declare const neq: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDef | string | number) => BinaryExpressionNode;
+declare const neq: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number | boolean) => BinaryExpressionNode;
 /**
  * Creates a greater-than expression (left > right)
  * @param left - Left operand
  * @param right - Right operand
  * @returns Binary expression node with greater-than operator
  */
-declare const gt: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDef | string | number) => BinaryExpressionNode;
+declare const gt: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number) => BinaryExpressionNode;
 /**
  * Creates a greater than or equal expression (left >= right)
  */
-declare const gte: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDef | string | number) => BinaryExpressionNode;
+declare const gte: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number) => BinaryExpressionNode;
 /**
  * Creates a less-than expression (left < right)
  * @param left - Left operand
  * @param right - Right operand
  * @returns Binary expression node with less-than operator
  */
-declare const lt: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDef | string | number) => BinaryExpressionNode;
+declare const lt: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number) => BinaryExpressionNode;
 /**
  * Creates a less than or equal expression (left <= right)
  */
-declare const lte: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDef | string | number) => BinaryExpressionNode;
+declare const lte: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number) => BinaryExpressionNode;
 /**
  * Creates a LIKE pattern matching expression
  * @param left - Left operand
@@ -48,7 +48,7 @@ declare const lte: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDe
  * @param escape - Optional escape character
  * @returns Binary expression node with LIKE operator
  */
-declare const like: (left: OperandNode | ColumnDef, pattern: string, escape?: string) => BinaryExpressionNode;
+declare const like: (left: OperandNode | ColumnRef, pattern: string, escape?: string) => BinaryExpressionNode;
 /**
  * Creates a NOT LIKE pattern matching expression
  * @param left - Left operand
@@ -56,7 +56,7 @@ declare const like: (left: OperandNode | ColumnDef, pattern: string, escape?: st
  * @param escape - Optional escape character
  * @returns Binary expression node with NOT LIKE operator
  */
-declare const notLike: (left: OperandNode | ColumnDef, pattern: string, escape?: string) => BinaryExpressionNode;
+declare const notLike: (left: OperandNode | ColumnRef, pattern: string, escape?: string) => BinaryExpressionNode;
 /**
  * Creates a logical AND expression
  * @param operands - Expressions to combine with AND
@@ -74,27 +74,27 @@ declare const or: (...operands: ExpressionNode[]) => LogicalExpressionNode;
  * @param left - Operand to check for null
  * @returns Null expression node with IS NULL operator
  */
-declare const isNull: (left: OperandNode | ColumnDef) => NullExpressionNode;
+declare const isNull: (left: OperandNode | ColumnRef) => NullExpressionNode;
 /**
  * Creates an IS NOT NULL expression
  * @param left - Operand to check for non-null
  * @returns Null expression node with IS NOT NULL operator
  */
-declare const isNotNull: (left: OperandNode | ColumnDef) => NullExpressionNode;
+declare const isNotNull: (left: OperandNode | ColumnRef) => NullExpressionNode;
 /**
  * Creates an IN expression (value IN list)
  * @param left - Operand to check
  * @param values - Values to check against
  * @returns IN expression node
  */
-declare const inList: (left: OperandNode | ColumnDef, values: (string | number | LiteralNode)[]) => InExpressionNode;
+declare const inList: (left: OperandNode | ColumnRef, values: (string | number | LiteralNode)[]) => InExpressionNode;
 /**
  * Creates a NOT IN expression (value NOT IN list)
  * @param left - Operand to check
  * @param values - Values to check against
  * @returns NOT IN expression node
  */
-declare const notInList: (left: OperandNode | ColumnDef, values: (string | number | LiteralNode)[]) => InExpressionNode;
+declare const notInList: (left: OperandNode | ColumnRef, values: (string | number | LiteralNode)[]) => InExpressionNode;
 /**
  * Creates a BETWEEN expression (value BETWEEN lower AND upper)
  * @param left - Operand to check
@@ -102,7 +102,7 @@ declare const notInList: (left: OperandNode | ColumnDef, values: (string | numbe
  * @param upper - Upper bound
  * @returns BETWEEN expression node
  */
-declare const between: (left: OperandNode | ColumnDef, lower: OperandNode | ColumnDef | string | number, upper: OperandNode | ColumnDef | string | number) => BetweenExpressionNode;
+declare const between: (left: OperandNode | ColumnRef, lower: OperandNode | ColumnRef | string | number, upper: OperandNode | ColumnRef | string | number) => BetweenExpressionNode;
 /**
  * Creates a NOT BETWEEN expression (value NOT BETWEEN lower AND upper)
  * @param left - Operand to check
@@ -110,14 +110,14 @@ declare const between: (left: OperandNode | ColumnDef, lower: OperandNode | Colu
  * @param upper - Upper bound
  * @returns NOT BETWEEN expression node
  */
-declare const notBetween: (left: OperandNode | ColumnDef, lower: OperandNode | ColumnDef | string | number, upper: OperandNode | ColumnDef | string | number) => BetweenExpressionNode;
+declare const notBetween: (left: OperandNode | ColumnRef, lower: OperandNode | ColumnRef | string | number, upper: OperandNode | ColumnRef | string | number) => BetweenExpressionNode;
 /**
  * Creates a JSON path expression
  * @param col - Source column
  * @param path - JSON path expression
  * @returns JSON path node
  */
-declare const jsonPath: (col: ColumnDef | ColumnNode, path: string) => JsonPathNode;
+declare const jsonPath: (col: ColumnRef | ColumnNode, path: string) => JsonPathNode;
 /**
  * Creates a CASE expression
  * @param conditions - Array of WHEN-THEN conditions
@@ -126,8 +126,8 @@ declare const jsonPath: (col: ColumnDef | ColumnNode, path: string) => JsonPathN
  */
 declare const caseWhen: (conditions: {
     when: ExpressionNode;
-    then: OperandNode | ColumnDef | string | number | boolean | null;
-}[], elseValue?: OperandNode | ColumnDef | string | number | boolean | null) => CaseExpressionNode;
+    then: OperandNode | ColumnRef | string | number | boolean | null;
+}[], elseValue?: OperandNode | ColumnRef | string | number | boolean | null) => CaseExpressionNode;
 /**
  * Creates an EXISTS expression
  * @param subquery - Subquery to check for existence
@@ -169,7 +169,7 @@ declare const ntile: (n: number) => WindowFunctionNode;
  * @param defaultValue - Default value if no row exists
  * @returns Window function node for LAG
  */
-declare const lag: (col: ColumnDef | ColumnNode, offset?: number, defaultValue?: any) => WindowFunctionNode;
+declare const lag: (col: ColumnRef | ColumnNode, offset?: number, defaultValue?: any) => WindowFunctionNode;
 /**
  * Creates a LEAD window function
  * @param col - Column to lead
@@ -177,19 +177,19 @@ declare const lag: (col: ColumnDef | ColumnNode, offset?: number, defaultValue?:
  * @param defaultValue - Default value if no row exists
  * @returns Window function node for LEAD
  */
-declare const lead: (col: ColumnDef | ColumnNode, offset?: number, defaultValue?: any) => WindowFunctionNode;
+declare const lead: (col: ColumnRef | ColumnNode, offset?: number, defaultValue?: any) => WindowFunctionNode;
 /**
  * Creates a FIRST_VALUE window function
  * @param col - Column to get first value from
  * @returns Window function node for FIRST_VALUE
  */
-declare const firstValue: (col: ColumnDef | ColumnNode) => WindowFunctionNode;
+declare const firstValue: (col: ColumnRef | ColumnNode) => WindowFunctionNode;
 /**
  * Creates a LAST_VALUE window function
  * @param col - Column to get last value from
  * @returns Window function node for LAST_VALUE
  */
-declare const lastValue: (col: ColumnDef | ColumnNode) => WindowFunctionNode;
+declare const lastValue: (col: ColumnRef | ColumnNode) => WindowFunctionNode;
 /**
  * Creates a custom window function
  * @param name - Window function name
@@ -198,8 +198,8 @@ declare const lastValue: (col: ColumnDef | ColumnNode) => WindowFunctionNode;
  * @param orderBy - Optional ORDER BY clauses
  * @returns Window function node
  */
-declare const windowFunction: (name: string, args?: (ColumnDef | ColumnNode | LiteralNode | JsonPathNode)[], partitionBy?: (ColumnDef | ColumnNode)[], orderBy?: {
-    column: ColumnDef | ColumnNode;
+declare const windowFunction: (name: string, args?: (ColumnRef | ColumnNode | LiteralNode | JsonPathNode)[], partitionBy?: (ColumnRef | ColumnNode)[], orderBy?: {
+    column: ColumnRef | ColumnNode;
     direction: OrderDirection;
 }[]) => WindowFunctionNode;
 
@@ -208,43 +208,62 @@ declare const windowFunction: (name: string, args?: (ColumnDef | ColumnNode | Li
  * @param col - Column to count
  * @returns Function node with COUNT
  */
-declare const count: (col: ColumnDef | ColumnNode) => FunctionNode;
+declare const count: (col: ColumnRef | ColumnNode) => FunctionNode;
 /**
  * Creates a SUM function expression
  * @param col - Column to sum
  * @returns Function node with SUM
  */
-declare const sum: (col: ColumnDef | ColumnNode) => FunctionNode;
+declare const sum: (col: ColumnRef | ColumnNode) => FunctionNode;
 /**
  * Creates an AVG function expression
  * @param col - Column to average
  * @returns Function node with AVG
  */
-declare const avg: (col: ColumnDef | ColumnNode) => FunctionNode;
+declare const avg: (col: ColumnRef | ColumnNode) => FunctionNode;
 
 /**
  * Visitor for expression nodes
  */
 interface ExpressionVisitor<R> {
-    visitBinaryExpression(node: BinaryExpressionNode): R;
-    visitLogicalExpression(node: LogicalExpressionNode): R;
-    visitNullExpression(node: NullExpressionNode): R;
-    visitInExpression(node: InExpressionNode): R;
-    visitExistsExpression(node: ExistsExpressionNode): R;
-    visitBetweenExpression(node: BetweenExpressionNode): R;
+    visitBinaryExpression?(node: BinaryExpressionNode): R;
+    visitLogicalExpression?(node: LogicalExpressionNode): R;
+    visitNullExpression?(node: NullExpressionNode): R;
+    visitInExpression?(node: InExpressionNode): R;
+    visitExistsExpression?(node: ExistsExpressionNode): R;
+    visitBetweenExpression?(node: BetweenExpressionNode): R;
+    otherwise?(node: ExpressionNode): R;
 }
 /**
  * Visitor for operand nodes
  */
 interface OperandVisitor<R> {
-    visitColumn(node: ColumnNode): R;
-    visitLiteral(node: LiteralNode): R;
-    visitFunction(node: FunctionNode): R;
-    visitJsonPath(node: JsonPathNode): R;
-    visitScalarSubquery(node: ScalarSubqueryNode): R;
-    visitCaseExpression(node: CaseExpressionNode): R;
-    visitWindowFunction(node: WindowFunctionNode): R;
+    visitColumn?(node: ColumnNode): R;
+    visitLiteral?(node: LiteralNode): R;
+    visitFunction?(node: FunctionNode): R;
+    visitJsonPath?(node: JsonPathNode): R;
+    visitScalarSubquery?(node: ScalarSubqueryNode): R;
+    visitCaseExpression?(node: CaseExpressionNode): R;
+    visitWindowFunction?(node: WindowFunctionNode): R;
+    otherwise?(node: OperandNode): R;
 }
+type ExpressionDispatch = <R>(node: any, visitor: ExpressionVisitor<R>) => R;
+type OperandDispatch = <R>(node: any, visitor: OperandVisitor<R>) => R;
+/**
+ * Registers a dispatcher for a custom expression node type.
+ * Allows new node kinds without modifying the core switch.
+ */
+declare const registerExpressionDispatcher: (type: string, dispatcher: ExpressionDispatch) => void;
+/**
+ * Registers a dispatcher for a custom operand node type.
+ * Allows new node kinds without modifying the core switch.
+ */
+declare const registerOperandDispatcher: (type: string, dispatcher: OperandDispatch) => void;
+/**
+ * Clears all registered dispatchers. Primarily for tests.
+ */
+declare const clearExpressionDispatchers: () => void;
+declare const clearOperandDispatchers: () => void;
 /**
  * Dispatches an expression node to the visitor
  * @param node - Expression node to visit
@@ -258,6 +277,15 @@ declare const visitExpression: <R>(node: ExpressionNode, visitor: ExpressionVisi
  */
 declare const visitOperand: <R>(node: OperandNode, visitor: OperandVisitor<R>) => R;
 
+/**
+ * Adapts a schema ColumnDef to an AST-friendly ColumnRef.
+ */
+declare const toColumnRef: (col: ColumnRef | ColumnDef) => ColumnRef;
+/**
+ * Adapts a schema TableDef to an AST-friendly TableRef.
+ */
+declare const toTableRef: (table: TableRef | TableDef) => TableRef;
+
 /**
  * Maintains immutable state for building INSERT queries
  */
@@ -270,6 +298,7 @@ declare class InsertQueryState {
     withReturning(columns: ColumnNode[]): InsertQueryState;
 }
 
+type InsertDialectInput = Dialect | DialectKey;
 /**
  * Builder for INSERT queries
  */
@@ -281,7 +310,8 @@ declare class InsertQueryBuilder<T> {
     values(rowOrRows: Record<string, unknown> | Record<string, unknown>[]): InsertQueryBuilder<T>;
     returning(...columns: (ColumnDef | ColumnNode)[]): InsertQueryBuilder<T>;
     compile(compiler: InsertCompiler): CompiledQuery;
-    toSql(compiler: InsertCompiler): string;
+    compile(dialect: InsertDialectInput): CompiledQuery;
+    toSql(arg: InsertCompiler | InsertDialectInput): string;
     getAST(): InsertQueryNode;
 }
 
@@ -298,6 +328,7 @@ declare class UpdateQueryState {
     withReturning(columns: ColumnNode[]): UpdateQueryState;
 }
 
+type UpdateDialectInput = Dialect | DialectKey;
 /**
  * Builder for UPDATE queries
  */
@@ -310,7 +341,8 @@ declare class UpdateQueryBuilder<T> {
     where(expr: ExpressionNode): UpdateQueryBuilder<T>;
     returning(...columns: (ColumnDef | ColumnNode)[]): UpdateQueryBuilder<T>;
     compile(compiler: UpdateCompiler): CompiledQuery;
-    toSql(compiler: UpdateCompiler): string;
+    compile(dialect: UpdateDialectInput): CompiledQuery;
+    toSql(arg: UpdateCompiler | UpdateDialectInput): string;
     getAST(): UpdateQueryNode;
 }
 
@@ -326,6 +358,7 @@ declare class DeleteQueryState {
     withReturning(columns: ColumnNode[]): DeleteQueryState;
 }
 
+type DeleteDialectInput = Dialect | DialectKey;
 /**
  * Builder for DELETE queries
  */
@@ -337,64 +370,107 @@ declare class DeleteQueryBuilder<T> {
     where(expr: ExpressionNode): DeleteQueryBuilder<T>;
     returning(...columns: (ColumnDef | ColumnNode)[]): DeleteQueryBuilder<T>;
     compile(compiler: DeleteCompiler): CompiledQuery;
-    toSql(compiler: DeleteCompiler): string;
+    compile(dialect: DeleteDialectInput): CompiledQuery;
+    toSql(arg: DeleteCompiler | DeleteDialectInput): string;
     getAST(): DeleteQueryNode;
 }
 
+interface FunctionTableNode {
+    type: 'FunctionTable';
+    schema?: string;
+    name: string;
+    args?: unknown[];
+    lateral?: boolean;
+    withOrdinality?: boolean;
+    alias?: string;
+    columnAliases?: string[];
+}
+interface FunctionTableNode {
+    type: 'FunctionTable';
+    schema?: string;
+    name: string;
+    args?: unknown[];
+    lateral?: boolean;
+    withOrdinality?: boolean;
+    alias?: string;
+    columnAliases?: string[];
+}
+
 /**
- * Shared SQL compiler for dialects with standard LIMIT/OFFSET pagination.
- * Concrete dialects override only the minimal hooks (identifier quoting,
- * JSON path, placeholders, RETURNING support) instead of re-implementing
- * the entire compile pipeline.
+ * Strategy interface for compiling pagination clauses.
+ * Allows dialects to customize how pagination (LIMIT/OFFSET, ROWS FETCH, etc.) is generated.
  */
-declare abstract class SqlDialectBase extends Dialect {
+interface PaginationStrategy {
     /**
-     * Quotes an identifier (dialect-specific).
+     * Compiles pagination logic into SQL clause.
+     * @param limit - The limit value, if present.
+     * @param offset - The offset value, if present.
+     * @returns SQL pagination clause (e.g., " LIMIT 10 OFFSET 0") or empty string if no pagination.
      */
-    abstract quoteIdentifier(id: string): string;
+    compilePagination(limit?: number, offset?: number): string;
+}
+
+/**
+ * Strategy interface for handling RETURNING clauses in DML statements (INSERT, UPDATE, DELETE).
+ * Different SQL dialects have varying levels of support for RETURNING clauses.
+ */
+interface ReturningStrategy {
     /**
-     * Compiles SELECT query AST to SQL using common rules.
+     * Compiles a RETURNING clause for DML statements.
+     * @param returning - Array of columns to return, or undefined if none.
+     * @param ctx - The compiler context for expression compilation.
+     * @returns SQL RETURNING clause or empty string if not supported.
+     * @throws Error if RETURNING is not supported by this dialect.
      */
-    protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
-    protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string;
+    compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string;
     /**
-     * Compiles a single SELECT (no set operations, no CTE prefix).
+     * Formats column list for RETURNING clause.
+     * @param returning - Array of columns to format.
+     * @param quoteIdentifier - Function to quote identifiers according to dialect rules.
+     * @returns Formatted column list (e.g., "table.col1, table.col2").
      */
+    formatReturningColumns(returning: ColumnNode[], quoteIdentifier: (id: string) => string): string;
+}
+
+declare abstract class SqlDialectBase extends Dialect {
+    abstract quoteIdentifier(id: string): string;
+    protected paginationStrategy: PaginationStrategy;
+    protected returningStrategy: ReturningStrategy;
+    protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
+    private compileSelectWithSetOps;
+    protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string;
+    protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string;
+    private compileInsertColumnList;
+    private compileInsertValues;
     private compileSelectCore;
     protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string;
+    private compileUpdateAssignments;
     protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string;
-    /**
-     * Default RETURNING compilation: no support.
-     */
-    protected compileReturning(returning: ColumnNode[] | undefined, _ctx: CompilerContext): string;
     protected formatReturningColumns(returning: ColumnNode[]): string;
-    /**
-     * DISTINCT clause. Override for DISTINCT ON support.
-     */
     protected compileDistinct(ast: SelectQueryNode): string;
     protected compileSelectColumns(ast: SelectQueryNode, ctx: CompilerContext): string;
-    protected compileFrom(ast: SelectQueryNode['from']): string;
+    protected compileFrom(ast: SelectQueryNode['from'], ctx?: CompilerContext): string;
+    protected compileFunctionTable(fn: FunctionTableNode, ctx?: CompilerContext): string;
+    protected compileTableSource(table: TableSourceNode): string;
     protected compileTableName(table: {
         name: string;
         schema?: string;
     }): string;
-    protected compileJoins(ast: SelectQueryNode, ctx: CompilerContext): string;
-    protected compileGroupBy(ast: SelectQueryNode): string;
     protected compileHaving(ast: SelectQueryNode, ctx: CompilerContext): string;
-    protected compileOrderBy(ast: SelectQueryNode): string;
-    /**
-     * Default LIMIT/OFFSET pagination clause.
-     */
-    protected compilePagination(ast: SelectQueryNode, _orderByClause: string): string;
-    protected compileCtes(ast: SelectQueryNode, ctx: CompilerContext): string;
     protected stripTrailingSemicolon(sql: string): string;
     protected wrapSetOperand(sql: string): string;
 }
+interface TableSourceNode {
+    name: string;
+    schema?: string;
+    alias?: string;
+}
 
 /**
  * MySQL dialect implementation
  */
 declare class MySqlDialect extends SqlDialectBase {
+    protected readonly dialect = "mysql";
     /**
      * Creates a new MySqlDialect instance
      */
@@ -417,6 +493,7 @@ declare class MySqlDialect extends SqlDialectBase {
  * Microsoft SQL Server dialect implementation
  */
 declare class SqlServerDialect extends Dialect {
+    protected readonly dialect = "mssql";
     /**
      * Creates a new SqlServerDialect instance
      */
@@ -460,6 +537,7 @@ declare class SqlServerDialect extends Dialect {
  * SQLite dialect implementation
  */
 declare class SqliteDialect extends SqlDialectBase {
+    protected readonly dialect = "sqlite";
     /**
      * Creates a new SqliteDialect instance
      */
@@ -484,6 +562,7 @@ declare class SqliteDialect extends SqlDialectBase {
  * PostgreSQL dialect implementation
  */
 declare class PostgresDialect extends SqlDialectBase {
+    protected readonly dialect = "postgres";
     /**
      * Creates a new PostgresDialect instance
      */
@@ -504,6 +583,12 @@ declare class PostgresDialect extends SqlDialectBase {
     supportsReturning(): boolean;
 }
 
+interface ColumnDiff {
+    typeChanged?: boolean;
+    nullabilityChanged?: boolean;
+    defaultChanged?: boolean;
+    autoIncrementChanged?: boolean;
+}
 interface DatabaseColumn {
     name: string;
     type: string;
@@ -537,82 +622,9 @@ interface DatabaseSchema {
     tables: DatabaseTable[];
 }
 
-type TableLike = {
-    name: string;
-    schema?: string;
-};
-/**
- * Common behavior for schema dialects (DDL).
- * Concrete dialects only override the small surface area instead of reimplementing everything.
- */
-declare abstract class BaseSchemaDialect implements SchemaDialect {
-    abstract name: DialectName;
-    abstract quoteIdentifier(id: string): string;
-    abstract renderColumnType(column: ColumnDef): string;
-    abstract renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined;
-    abstract renderIndex(table: TableDef, index: IndexDef): string;
-    supportsPartialIndexes(): boolean;
-    formatTableName(table: TableLike): string;
-    renderDefault(value: unknown, _column: ColumnDef): string;
-    renderReference(ref: ForeignKeyReference, _table: TableDef): string;
-    renderTableOptions(_table: TableDef): string | undefined;
-    dropTableSql(table: DatabaseTable): string[];
-    abstract dropColumnSql(table: DatabaseTable, column: string): string[];
-    abstract dropIndexSql(table: DatabaseTable, index: string): string[];
-    warnDropColumn(_table: DatabaseTable, _column: string): string | undefined;
-}
-
-declare class PostgresSchemaDialect extends BaseSchemaDialect {
-    name: DialectName;
-    quoteIdentifier(id: string): string;
-    renderColumnType(column: ColumnDef): string;
-    renderAutoIncrement(column: ColumnDef): string | undefined;
-    renderIndex(table: TableDef, index: IndexDef): string;
-    supportsPartialIndexes(): boolean;
-    dropColumnSql(table: DatabaseTable, column: string): string[];
-    dropIndexSql(table: DatabaseTable, index: string): string[];
-}
-
-declare class MySqlSchemaDialect extends BaseSchemaDialect {
-    name: DialectName;
-    quoteIdentifier(id: string): string;
-    renderColumnType(column: ColumnDef): string;
-    renderDefault(value: unknown): string;
-    renderAutoIncrement(column: ColumnDef): string | undefined;
-    renderIndex(table: TableDef, index: IndexDef): string;
-    renderTableOptions(table: TableDef): string | undefined;
-    dropColumnSql(table: DatabaseTable, column: string): string[];
-    dropIndexSql(table: DatabaseTable, index: string): string[];
-}
-
-declare class SQLiteSchemaDialect extends BaseSchemaDialect {
-    name: DialectName;
-    quoteIdentifier(id: string): string;
-    renderColumnType(column: ColumnDef): string;
-    renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined;
-    preferInlinePkAutoincrement(column: ColumnDef, table: TableDef, pk: string[]): boolean;
-    renderDefault(value: unknown): string;
-    renderIndex(table: TableDef, index: IndexDef): string;
-    dropColumnSql(_table: DatabaseTable, _column: string): string[];
-    dropIndexSql(_table: DatabaseTable, index: string): string[];
-    warnDropColumn(table: DatabaseTable, column: string): string | undefined;
-}
-
-declare class MSSqlSchemaDialect extends BaseSchemaDialect {
-    name: DialectName;
-    quoteIdentifier(id: string): string;
-    renderColumnType(column: ColumnDef): string;
-    renderDefault(value: unknown): string;
-    renderAutoIncrement(column: ColumnDef): string | undefined;
-    renderIndex(table: TableDef, index: IndexDef): string;
-    supportsPartialIndexes(): boolean;
-    dropColumnSql(table: DatabaseTable, column: string): string[];
-    dropIndexSql(table: DatabaseTable, index: string): string[];
-}
-
-type DialectName = 'postgres' | 'mysql' | 'sqlite' | 'mssql';
+type DialectName = 'postgres' | 'mysql' | 'sqlite' | 'mssql' | (string & {});
 interface SchemaDialect {
-    name: DialectName;
+    readonly name: DialectName;
     quoteIdentifier(id: string): string;
     formatTableName(table: TableDef | DatabaseTable): string;
     renderColumnType(column: ColumnDef): string;
@@ -622,22 +634,18 @@ interface SchemaDialect {
     renderIndex(table: TableDef, index: IndexDef): string;
     renderTableOptions(table: TableDef): string | undefined;
     supportsPartialIndexes(): boolean;
-    preferInlinePkAutoincrement?(column: ColumnDef, table: TableDef, pk: string[]): boolean;
-    dropColumnSql(table: DatabaseTable, column: string): string[];
-    dropIndexSql(table: DatabaseTable, index: string): string[];
-    dropTableSql(table: DatabaseTable): string[];
+    dropColumnSql?(table: DatabaseTable, column: string): string[];
+    dropIndexSql?(table: DatabaseTable, index: string): string[];
+    dropTableSql?(table: DatabaseTable): string[];
     warnDropColumn?(table: DatabaseTable, column: string): string | undefined;
+    alterColumnSql?(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string[];
+    warnAlterColumn?(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string | undefined;
 }
+
 interface SchemaGenerateResult {
     tableSql: string;
     indexSql: string[];
 }
-declare const escapeLiteral: (value: string) => string;
-declare const formatLiteral: (value: unknown, dialect: DialectName) => string;
-declare const resolvePrimaryKey: (table: TableDef) => string[];
-declare const quoteQualified: (dialect: SchemaDialect, identifier: string) => string;
-declare const renderIndexColumns: (dialect: SchemaDialect, columns: (string | IndexColumn)[]) => string;
-declare const deriveIndexName: (table: TableDef, index: IndexDef) => string;
 interface RenderColumnOptions {
     includePrimary?: boolean;
 }
@@ -670,6 +678,11 @@ interface SynchronizeOptions extends SchemaDiffOptions {
 }
 declare const synchronizeSchema: (expectedTables: TableDef[], actualSchema: DatabaseSchema, dialect: SchemaDialect, executor: DbExecutor, options?: SynchronizeOptions) => Promise<SchemaPlan>;
 
+interface IntrospectContext {
+    dialect: Dialect;
+    executor: DbExecutor;
+}
+
 /**
  * Dialect-agnostic options for schema introspection.
  */
@@ -683,7 +696,7 @@ interface IntrospectOptions {
  * Strategy interface implemented per dialect to introspect an existing database schema.
  */
 interface SchemaIntrospector {
-    introspect(executor: DbExecutor, options: IntrospectOptions): Promise<DatabaseSchema>;
+    introspect(ctx: IntrospectContext, options: IntrospectOptions): Promise<DatabaseSchema>;
 }
 
 /**
@@ -691,6 +704,310 @@ interface SchemaIntrospector {
  */
 declare const introspectSchema: (executor: DbExecutor, dialect: DialectName, options?: IntrospectOptions) => Promise<DatabaseSchema>;
 
+declare const registerSchemaIntrospector: (dialect: DialectName, introspector: SchemaIntrospector) => void;
+declare const getSchemaIntrospector: (dialect: DialectName) => SchemaIntrospector | undefined;
+
+type OperandInput$2 = OperandNode | ColumnDef | string | number | boolean | null;
+/**
+ * Helper: LOWER(str)
+ */
+declare const lower: (value: OperandInput$2) => FunctionNode;
+/**
+ * Helper: UPPER(str)
+ */
+declare const upper: (value: OperandInput$2) => FunctionNode;
+/**
+ * Helper: ASCII(str)
+ */
+declare const ascii: (value: OperandInput$2) => FunctionNode;
+/**
+ * Helper: CHAR(code[, code...])
+ */
+declare const char: (...codes: OperandInput$2[]) => FunctionNode;
+/**
+ * Helper: CHAR_LENGTH(str)
+ */
+declare const charLength: (value: OperandInput$2) => FunctionNode;
+/**
+ * Helper: LENGTH(str)
+ */
+declare const length: (value: OperandInput$2) => FunctionNode;
+/**
+ * Helper: TRIM([chars FROM] str)
+ */
+declare const trim: (value: OperandInput$2, chars?: OperandInput$2) => FunctionNode;
+/**
+ * Helper: LTRIM(str)
+ */
+declare const ltrim: (value: OperandInput$2) => FunctionNode;
+/**
+ * Helper: RTRIM(str)
+ */
+declare const rtrim: (value: OperandInput$2) => FunctionNode;
+/**
+ * Helper: CONCAT(arg1, arg2, ...)
+ */
+declare const concat: (...args: OperandInput$2[]) => FunctionNode;
+/**
+ * Helper: CONCAT_WS(separator, arg1, arg2, ...)
+ */
+declare const concatWs: (separator: OperandInput$2, ...args: OperandInput$2[]) => FunctionNode;
+/**
+ * Helper: SUBSTR(str, start[, length])
+ */
+declare const substr: (value: OperandInput$2, start: OperandInput$2, length?: OperandInput$2) => FunctionNode;
+/**
+ * Helper: LEFT(str, length)
+ */
+declare const left: (value: OperandInput$2, len: OperandInput$2) => FunctionNode;
+/**
+ * Helper: RIGHT(str, length)
+ */
+declare const right: (value: OperandInput$2, len: OperandInput$2) => FunctionNode;
+/**
+ * Helper: POSITION(substring IN string)
+ */
+declare const position: (substring: OperandInput$2, value: OperandInput$2) => FunctionNode;
+/**
+ * Helper: INSTR(string, substring)
+ */
+declare const instr: (value: OperandInput$2, substring: OperandInput$2) => FunctionNode;
+/**
+ * Helper: LOCATE(substring, string[, start])
+ */
+declare const locate: (substring: OperandInput$2, value: OperandInput$2, start?: OperandInput$2) => FunctionNode;
+/**
+ * Helper: REPLACE(string, search, replace)
+ */
+declare const replace: (value: OperandInput$2, search: OperandInput$2, replacement: OperandInput$2) => FunctionNode;
+/**
+ * Helper: REPEAT(string, count)
+ */
+declare const repeat: (value: OperandInput$2, count: OperandInput$2) => FunctionNode;
+/**
+ * Helper: LPAD(string, length, padstr)
+ */
+declare const lpad: (value: OperandInput$2, len: OperandInput$2, pad: OperandInput$2) => FunctionNode;
+/**
+ * Helper: RPAD(string, length, padstr)
+ */
+declare const rpad: (value: OperandInput$2, len: OperandInput$2, pad: OperandInput$2) => FunctionNode;
+/**
+ * Helper: SPACE(count)
+ */
+declare const space: (count: OperandInput$2) => FunctionNode;
+
+type OperandInput$1 = OperandNode | ColumnDef | string | number | boolean | null;
+/**
+ * Helper: ABS(x) - Returns the absolute value of a number
+ */
+declare const abs: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: ACOS(x) - Returns the arccosine (inverse cosine)
+ */
+declare const acos: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: ASIN(x) - Returns the arcsine (inverse sine)
+ */
+declare const asin: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: ATAN(x) - Returns the arctangent (inverse tangent)
+ */
+declare const atan: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: ATAN2(y, x) - Returns the arctangent of the two arguments
+ */
+declare const atan2: (y: OperandInput$1, x: OperandInput$1) => FunctionNode;
+/**
+ * Helper: CEIL(x) / CEILING(x) - Returns the smallest integer >= x
+ */
+declare const ceil: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: CEILING(x) - Alias for CEIL
+ */
+declare const ceiling: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: COS(x) - Returns the cosine of a number (in radians)
+ */
+declare const cos: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: COT(x) - Returns the cotangent of a number
+ */
+declare const cot: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: DEGREES(x) - Converts radians to degrees
+ */
+declare const degrees: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: EXP(x) - Returns e raised to the power of the argument
+ */
+declare const exp: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: FLOOR(x) - Returns the largest integer <= x
+ */
+declare const floor: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: LN(x) - Returns the natural logarithm (base e)
+ */
+declare const ln: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: LOG(x) - Returns the base-10 logarithm
+ */
+declare const log: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: LOG10(x) - Returns the base-10 logarithm
+ */
+declare const log10: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: LOG(base, x) - Returns the logarithm of x for a specific base
+ */
+declare const logBase: (base: OperandInput$1, value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: MOD(x, y) - Returns the remainder of x/y
+ */
+declare const mod: (x: OperandInput$1, y: OperandInput$1) => FunctionNode;
+/**
+ * Helper: PI() - Returns the value of PI (approx. 3.14159...)
+ */
+declare const pi: () => FunctionNode;
+/**
+ * Helper: POWER(x, y) - Returns x raised to the power of y
+ */
+declare const power: (x: OperandInput$1, y: OperandInput$1) => FunctionNode;
+/**
+ * Helper: POW(x, y) - Alias for POWER
+ */
+declare const pow: (x: OperandInput$1, y: OperandInput$1) => FunctionNode;
+/**
+ * Helper: RADIANS(x) - Converts degrees to radians
+ */
+declare const radians: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: RAND() / RANDOM() - Returns a random number
+ */
+declare const random: () => FunctionNode;
+/**
+ * Helper: RAND() - Alias for RANDOM (returns float 0-1)
+ */
+declare const rand: () => FunctionNode;
+/**
+ * Helper: ROUND(x[, decimals]) - Rounds a number to specified decimal places
+ */
+declare const round: (value: OperandInput$1, decimals?: OperandInput$1) => FunctionNode;
+/**
+ * Helper: SIGN(x) - Returns the sign of a number (-1, 0, 1)
+ */
+declare const sign: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: SIN(x) - Returns the sine of a number (in radians)
+ */
+declare const sin: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: SQRT(x) - Returns the square root of a number
+ */
+declare const sqrt: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: TAN(x) - Returns the tangent of a number (in radians)
+ */
+declare const tan: (value: OperandInput$1) => FunctionNode;
+/**
+ * Helper: TRUNC(x[, decimals]) / TRUNCATE(x, decimals) - Truncates a number without rounding
+ */
+declare const trunc: (value: OperandInput$1, decimals?: OperandInput$1) => FunctionNode;
+/**
+ * Helper: TRUNCATE(x, decimals) - Alias for TRUNC
+ */
+declare const truncate: (value: OperandInput$1, decimals: OperandInput$1) => FunctionNode;
+
+type OperandInput = OperandNode | ColumnDef | string | number | boolean | null;
+/**
+ * Helper: NOW() - Returns the current local date and time
+ */
+declare const now: () => FunctionNode;
+/**
+ * Helper: CURRENT_DATE - Returns only the current date (no time)
+ */
+declare const currentDate: () => FunctionNode;
+/**
+ * Helper: CURRENT_TIME - Returns only the current time
+ */
+declare const currentTime: () => FunctionNode;
+/**
+ * Helper: UTC_NOW() - Returns current UTC/GMT date and time
+ */
+declare const utcNow: () => FunctionNode;
+/**
+ * Helper: EXTRACT(part FROM date) - Extracts a part (year, month, day, hour, etc.) from a date
+ * @param part - The date part to extract (e.g., 'YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'SECOND')
+ * @param date - The date/datetime value
+ */
+declare const extract: (part: OperandInput, date: OperandInput) => FunctionNode;
+/**
+ * Helper: YEAR(date) - Extracts the year from a date
+ */
+declare const year: (date: OperandInput) => FunctionNode;
+/**
+ * Helper: MONTH(date) - Extracts the month from a date
+ */
+declare const month: (date: OperandInput) => FunctionNode;
+/**
+ * Helper: DAY(date) - Extracts the day from a date
+ */
+declare const day: (date: OperandInput) => FunctionNode;
+/**
+ * Helper: DATE_ADD(date, interval, unit) - Adds a specific time interval to a date
+ * @param date - The date/datetime value
+ * @param interval - The number of units to add
+ * @param unit - The unit type (e.g., 'DAY', 'MONTH', 'YEAR', 'HOUR', 'MINUTE', 'SECOND')
+ */
+declare const dateAdd: (date: OperandInput, interval: OperandInput, unit: OperandInput) => FunctionNode;
+/**
+ * Helper: DATE_SUB(date, interval, unit) - Subtracts a specific time interval from a date
+ * @param date - The date/datetime value
+ * @param interval - The number of units to subtract
+ * @param unit - The unit type (e.g., 'DAY', 'MONTH', 'YEAR', 'HOUR', 'MINUTE', 'SECOND')
+ */
+declare const dateSub: (date: OperandInput, interval: OperandInput, unit: OperandInput) => FunctionNode;
+/**
+ * Helper: DATE_DIFF(date1, date2) - Returns the difference between two dates in days
+ * @param date1 - The end date
+ * @param date2 - The start date
+ */
+declare const dateDiff: (date1: OperandInput, date2: OperandInput) => FunctionNode;
+/**
+ * Helper: DATE_FORMAT(date, format) - Converts a date to a formatted string
+ * @param date - The date/datetime value
+ * @param format - The format string (dialect-specific)
+ */
+declare const dateFormat: (date: OperandInput, format: OperandInput) => FunctionNode;
+/**
+ * Helper: UNIX_TIMESTAMP() - Returns the current Unix epoch (seconds since 1970)
+ */
+declare const unixTimestamp: () => FunctionNode;
+/**
+ * Helper: FROM_UNIXTIME(timestamp) - Converts Unix epoch seconds to a date
+ * @param timestamp - Unix timestamp in seconds
+ */
+declare const fromUnixTime: (timestamp: OperandInput) => FunctionNode;
+/**
+ * Helper: END_OF_MONTH(date) - Returns the last day of the month for a given date
+ */
+declare const endOfMonth: (date: OperandInput) => FunctionNode;
+/**
+ * Helper: DAY_OF_WEEK(date) - Returns the index of the weekday
+ */
+declare const dayOfWeek: (date: OperandInput) => FunctionNode;
+/**
+ * Helper: WEEK_OF_YEAR(date) - Returns the week number of the year
+ */
+declare const weekOfYear: (date: OperandInput) => FunctionNode;
+/**
+ * Helper: DATE_TRUNC(part, date) - Resets date precision (e.g., first day of the month/year)
+ * @param part - The truncation precision (e.g., 'YEAR', 'MONTH', 'DAY')
+ * @param date - The date/datetime value
+ */
+declare const dateTrunc: (part: OperandInput, date: OperandInput) => FunctionNode;
+
 /**
  * Browser-compatible implementation of AsyncLocalStorage
  * Provides a simple in-memory store for browser environments
@@ -858,6 +1175,7 @@ declare const createEntityFromRow: <TTable extends TableDef>(ctx: OrmContext, ta
 
 type Rows$3 = Record<string, any>[];
 declare const loadHasManyRelation: (ctx: OrmContext, rootTable: TableDef, _relationName: string, relation: HasManyRelation) => Promise<Map<string, Rows$3>>;
+declare const loadHasOneRelation: (ctx: OrmContext, rootTable: TableDef, _relationName: string, relation: HasOneRelation) => Promise<Map<string, Record<string, any>>>;
 declare const loadBelongsToRelation: (ctx: OrmContext, rootTable: TableDef, _relationName: string, relation: BelongsToRelation) => Promise<Map<string, Record<string, any>>>;
 declare const loadBelongsToManyRelation: (ctx: OrmContext, rootTable: TableDef, _relationName: string, relation: BelongsToManyRelation) => Promise<Map<string, Rows$3>>;
 
@@ -948,4 +1266,38 @@ declare class DefaultManyToManyCollection<TTarget> implements ManyToManyCollecti
 
 declare function executeHydrated<TTable extends TableDef>(ctx: OrmContext, qb: SelectQueryBuilder<any, TTable>): Promise<Entity<TTable>[]>;
 
-export { AsyncLocalStorage, BaseSchemaDialect, BelongsToManyRelation, BelongsToReference, BelongsToRelation, BetweenExpressionNode, BinaryExpressionNode, CaseExpressionNode, ColumnDef, ColumnNode, type DatabaseCheck, type DatabaseColumn, type DatabaseIndex, type DatabaseSchema, type DatabaseTable, DbExecutor, DefaultBelongsToReference, DefaultHasManyCollection, DefaultManyToManyCollection, DeleteQueryBuilder, type DialectName, Entity, ExistsExpressionNode, ExpressionNode, type ExpressionVisitor, ForeignKeyReference, FunctionNode, HasManyCollection, HasManyRelation, InExpressionNode, IndexColumn, IndexDef, InsertQueryBuilder, type IntrospectOptions, JsonPathNode, LiteralNode, LogicalExpressionNode, MSSqlSchemaDialect, ManyToManyCollection, MySqlDialect, MySqlSchemaDialect, NullExpressionNode, OperandNode, type OperandVisitor, OrmContext, PostgresDialect, PostgresSchemaDialect, RelationMap, type RenderColumnOptions, SQLiteSchemaDialect, ScalarSubqueryNode, type SchemaChange, type SchemaChangeKind, type SchemaDialect, type SchemaDiffOptions, type SchemaGenerateResult, type SchemaIntrospector, type SchemaPlan, SelectQueryBuilder, SqlServerDialect, SqliteDialect, type SynchronizeOptions, TableDef, TypeScriptGenerator, UpdateQueryBuilder, WindowFunctionNode, and, avg, between, caseWhen, columnOperand, count, createEntityFromRow, createEntityProxy, denseRank, deriveIndexName, diffSchema, eq, escapeLiteral, executeHydrated, exists, firstValue, formatLiteral, generateCreateTableSql, generateSchemaSql, gt, gte, hydrateRows, inList, introspectSchema, isNotNull, isNull, jsonPath, lag, lastValue, lead, like, loadBelongsToManyRelation, loadBelongsToRelation, loadHasManyRelation, lt, lte, neq, notBetween, notExists, notInList, notLike, ntile, or, quoteQualified, rank, renderColumnDefinition, renderIndexColumns, resolvePrimaryKey, rowNumber, sum, synchronizeSchema, valueToOperand, visitExpression, visitOperand, windowFunction };
+interface PostgresClientLike {
+    query(text: string, params?: unknown[]): Promise<{
+        rows: Array<Record<string, unknown>>;
+    }>;
+}
+declare function createPostgresExecutor(client: PostgresClientLike): DbExecutor;
+
+interface MysqlClientLike {
+    query(sql: string, params?: unknown[]): Promise<[any, any?]>;
+    beginTransaction?(): Promise<void>;
+    commit?(): Promise<void>;
+    rollback?(): Promise<void>;
+}
+declare function createMysqlExecutor(client: MysqlClientLike): DbExecutor;
+
+interface SqliteClientLike {
+    all(sql: string, params?: unknown[]): Promise<Array<Record<string, unknown>>>;
+    run?(sql: string, params?: unknown[]): Promise<unknown>;
+    beginTransaction?(): Promise<void>;
+    commitTransaction?(): Promise<void>;
+    rollbackTransaction?(): Promise<void>;
+}
+declare function createSqliteExecutor(client: SqliteClientLike): DbExecutor;
+
+interface MssqlClientLike {
+    query(sql: string, params?: unknown[]): Promise<{
+        recordset: Array<Record<string, unknown>>;
+    }>;
+    beginTransaction?(): Promise<void>;
+    commit?(): Promise<void>;
+    rollback?(): Promise<void>;
+}
+declare function createMssqlExecutor(client: MssqlClientLike): DbExecutor;
+
+export { AsyncLocalStorage, BelongsToManyRelation, BelongsToReference, BelongsToRelation, BetweenExpressionNode, BinaryExpressionNode, CaseExpressionNode, ColumnDef, type ColumnDiff, ColumnNode, ColumnRef, type DatabaseCheck, type DatabaseColumn, type DatabaseIndex, type DatabaseSchema, type DatabaseTable, DbExecutor, DefaultBelongsToReference, DefaultHasManyCollection, DefaultManyToManyCollection, DeleteQueryBuilder, type DialectName, Entity, ExistsExpressionNode, ExpressionNode, type ExpressionVisitor, ForeignKeyReference, FunctionNode, HasManyCollection, HasManyRelation, HasOneRelation, HydrationPlan, InExpressionNode, IndexColumn, IndexDef, InsertQueryBuilder, type IntrospectOptions, JsonPathNode, LiteralNode, LogicalExpressionNode, ManyToManyCollection, type MssqlClientLike, MySqlDialect, type MysqlClientLike, NullExpressionNode, OperandNode, type OperandVisitor, OrmContext, type PostgresClientLike, PostgresDialect, RelationMap, type RenderColumnOptions, ScalarSubqueryNode, type SchemaChange, type SchemaChangeKind, type SchemaDiffOptions, type SchemaGenerateResult, type SchemaIntrospector, type SchemaPlan, SelectQueryBuilder, SqlServerDialect, type SqliteClientLike, SqliteDialect, type SynchronizeOptions, TableDef, TableRef, TypeScriptGenerator, UpdateQueryBuilder, WindowFunctionNode, abs, acos, and, ascii, asin, atan, atan2, avg, between, caseWhen, ceil, ceiling, char, charLength, clearExpressionDispatchers, clearOperandDispatchers, columnOperand, concat, concatWs, cos, cot, count, createEntityFromRow, createEntityProxy, createMssqlExecutor, createMysqlExecutor, createPostgresExecutor, createSqliteExecutor, currentDate, currentTime, dateAdd, dateDiff, dateFormat, dateSub, dateTrunc, day, dayOfWeek, degrees, denseRank, diffSchema, endOfMonth, eq, executeHydrated, exists, exp, extract, firstValue, floor, fromUnixTime, generateCreateTableSql, generateSchemaSql, getSchemaIntrospector, gt, gte, hydrateRows, inList, instr, introspectSchema, isNotNull, isNull, jsonPath, lag, lastValue, lead, left, length, like, ln, loadBelongsToManyRelation, loadBelongsToRelation, loadHasManyRelation, loadHasOneRelation, locate, log, log10, logBase, lower, lpad, lt, lte, ltrim, mod, month, neq, notBetween, notExists, notInList, notLike, now, ntile, or, pi, position, pow, power, radians, rand, random, rank, registerExpressionDispatcher, registerOperandDispatcher, registerSchemaIntrospector, renderColumnDefinition, repeat, replace, right, round, rowNumber, rpad, rtrim, sign, sin, space, sqrt, substr, sum, synchronizeSchema, tan, toColumnRef, toTableRef, trim, trunc, truncate, unixTimestamp, upper, utcNow, valueToOperand, visitExpression, visitOperand, weekOfYear, windowFunction, year };