metal-orm 1.0.33 → 1.0.34

package/dist/index.d.ts

@@ -1,5 +1,714 @@
-import { L as LiteralNode, O as OperandNode, C as ColumnRef, a as ColumnNode, B as BinaryExpressionNode, E as ExpressionNode, b as LogicalExpressionNode, N as NullExpressionNode, 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 FunctionTableNode, s as DerivedTableNode, t as TableSourceNode, u as ForeignKeyReference, v as IndexColumn, w as IndexDef, x as DbExecutor, H as HydrationPlan, y as NamingStrategy, R as RelationMap, z as EntityContext, A as Entity, G as HasManyRelation, K as HasOneRelation, M as BelongsToRelation, P as BelongsToManyRelation, Q as HasManyCollection, V as BelongsToReference, X as ManyToManyCollection, Y as OrmSession, Z as SelectQueryBuilder, _ as ExecutionContext, $ as HydrationContext } from './select-BuMpVcVt.js';
-export { aL as AnyDomainEvent, ab as CascadeMode, a0 as CheckConstraint, ai as ColumnToTs, a4 as ColumnType, ay as DbExecutorFactory, a7 as DefaultValue, aK as DomainEvent, aD as DomainEventBus, aB as DomainEventHandler, aF as EntityStatus, az as ExternalTransaction, aN as HasDomainEvents, ak as HasOneReference, au as HydrationMetadata, as as HydrationPivotPlan, at as HydrationRelationPlan, aj as InferRow, aC as InitialHandlers, aA as Orm, aM as OrmDomainEvent, av as OrmInterceptor, ax as OrmOptions, aw as OrmSessionOptions, aO as QueryLogEntry, aP as QueryLogger, aR as QueryResult, a6 as RawDefaultValue, a5 as ReferentialAction, aI as RelationChange, aJ as RelationChangeEntry, ac as RelationDef, aH as RelationKey, a9 as RelationKinds, ah as RelationTargetTable, aa as RelationType, aT as SimpleQueryRunner, a2 as TableHooks, a1 as TableOptions, aG as TrackedEntity, aE as addDomainEvent, af as belongsTo, ag as belongsToMany, a8 as col, al as createColumn, aU as createExecutorFromQueryRunner, am as createLiteral, aQ as createQueryLoggingExecutor, a3 as defineTable, ad as hasMany, ae as hasOne, ap as isCaseExpressionNode, ar as isExpressionSelectionNode, ao as isFunctionNode, an as isOperandNode, aq as isWindowFunctionNode, aS as rowsToQueryResult } from './select-BuMpVcVt.js';
+/**
+ * Supported column data types for database schema definitions
+ */
+type ColumnType = 'INT' | 'INTEGER' | 'BIGINT' | 'VARCHAR' | 'TEXT' | 'JSON' | 'ENUM' | 'DECIMAL' | 'FLOAT' | 'DOUBLE' | 'UUID' | 'BINARY' | 'VARBINARY' | 'BLOB' | 'BYTEA' | 'DATE' | 'DATETIME' | 'TIMESTAMP' | 'TIMESTAMPTZ' | 'BOOLEAN' | 'int' | 'integer' | 'bigint' | 'varchar' | 'text' | 'json' | 'enum' | 'decimal' | 'float' | 'double' | 'uuid' | 'binary' | 'varbinary' | 'blob' | 'bytea' | 'date' | 'datetime' | 'timestamp' | 'timestamptz' | 'boolean';
+type ReferentialAction = 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
+interface RawDefaultValue {
+    raw: string;
+}
+type DefaultValue = unknown | RawDefaultValue;
+interface ForeignKeyReference {
+    /** Target table name */
+    table: string;
+    /** Target column name */
+    column: string;
+    /** Optional constraint name */
+    name?: string;
+    /** ON DELETE action */
+    onDelete?: ReferentialAction;
+    /** ON UPDATE action */
+    onUpdate?: ReferentialAction;
+    /** Whether the constraint is deferrable (Postgres) */
+    deferrable?: boolean;
+}
+/**
+ * Definition of a database column
+ */
+interface ColumnDef<T extends ColumnType = ColumnType> {
+    /** Column name (filled at runtime by defineTable) */
+    name: string;
+    /** Data type of the column */
+    type: T;
+    /** Whether this column is a primary key */
+    primary?: boolean;
+    /** Whether this column cannot be null */
+    notNull?: boolean;
+    /** Whether this column must be unique (or name of the unique constraint) */
+    unique?: boolean | string;
+    /** Default value for the column */
+    default?: DefaultValue;
+    /** Whether the column auto-increments / identity */
+    autoIncrement?: boolean;
+    /** Identity strategy where supported */
+    generated?: 'always' | 'byDefault';
+    /** Inline check constraint expression */
+    check?: string;
+    /** Foreign key reference */
+    references?: ForeignKeyReference;
+    /** Column comment/description */
+    comment?: string;
+    /** Additional arguments for the column type (e.g., VARCHAR length) */
+    args?: any[];
+    /** Table name this column belongs to (filled at runtime by defineTable) */
+    table?: string;
+}
+/**
+ * Factory for creating column definitions with common data types
+ */
+declare const col: {
+    /**
+     * Creates an integer column definition
+     * @returns ColumnDef with INT type
+     */
+    int: () => ColumnDef<"INT">;
+    /**
+     * Creates a big integer column definition
+     */
+    bigint: () => ColumnDef<"BIGINT">;
+    /**
+     * Creates a variable character column definition
+     * @param length - Maximum length of the string
+     * @returns ColumnDef with VARCHAR type
+     */
+    varchar: (length: number) => ColumnDef<"VARCHAR">;
+    /**
+     * Creates a fixed precision decimal column definition
+     */
+    decimal: (precision: number, scale?: number) => ColumnDef<"DECIMAL">;
+    /**
+     * Creates a floating point column definition
+     */
+    float: (precision?: number) => ColumnDef<"FLOAT">;
+    /**
+     * Creates a UUID column definition
+     */
+    uuid: () => ColumnDef<"UUID">;
+    /**
+     * Creates a binary large object column definition
+     */
+    blob: () => ColumnDef<"BLOB">;
+    /**
+     * Creates a fixed-length binary column definition
+     */
+    binary: (length?: number) => ColumnDef<"BINARY">;
+    /**
+     * Creates a variable-length binary column definition
+     */
+    varbinary: (length?: number) => ColumnDef<"VARBINARY">;
+    /**
+     * Creates a Postgres bytea column definition
+     */
+    bytea: () => ColumnDef<"BYTEA">;
+    /**
+     * Creates a timestamp column definition
+     */
+    timestamp: () => ColumnDef<"TIMESTAMP">;
+    /**
+     * Creates a timestamptz column definition
+     */
+    timestamptz: () => ColumnDef<"TIMESTAMPTZ">;
+    /**
+     * Creates a date column definition
+     */
+    date: () => ColumnDef<"DATE">;
+    /**
+     * Creates a datetime column definition
+     */
+    datetime: () => ColumnDef<"DATETIME">;
+    /**
+     * Creates a JSON column definition
+     * @returns ColumnDef with JSON type
+     */
+    json: () => ColumnDef<"JSON">;
+    /**
+     * Creates a boolean column definition
+     * @returns ColumnDef with BOOLEAN type
+     */
+    boolean: () => ColumnDef<"BOOLEAN">;
+    /**
+     * Creates an enum column definition
+     * @param values - Enum values
+     */
+    enum: (values: string[]) => ColumnDef<"ENUM">;
+    /**
+     * Marks a column definition as a primary key
+     * @param def - Column definition to modify
+     * @returns Modified ColumnDef with primary: true
+     */
+    primaryKey: <T extends ColumnType>(def: ColumnDef<T>) => ColumnDef<T>;
+    /**
+     * Marks a column as NOT NULL
+     */
+    notNull: <T extends ColumnType>(def: ColumnDef<T>) => ColumnDef<T>;
+    /**
+     * Marks a column as UNIQUE
+     */
+    unique: <T extends ColumnType>(def: ColumnDef<T>, name?: string) => ColumnDef<T>;
+    /**
+     * Sets a default value for the column
+     */
+    default: <T extends ColumnType>(def: ColumnDef<T>, value: unknown) => ColumnDef<T>;
+    /**
+     * Sets a raw SQL default value for the column
+     */
+    defaultRaw: <T extends ColumnType>(def: ColumnDef<T>, expression: string) => ColumnDef<T>;
+    /**
+     * Marks a column as auto-increment / identity
+     */
+    autoIncrement: <T extends ColumnType>(def: ColumnDef<T>, strategy?: ColumnDef["generated"]) => ColumnDef<T>;
+    /**
+     * Adds a foreign key reference
+     */
+    references: <T extends ColumnType>(def: ColumnDef<T>, ref: ForeignKeyReference) => ColumnDef<T>;
+    /**
+     * Adds a check constraint to the column
+     */
+    check: <T extends ColumnType>(def: ColumnDef<T>, expression: string) => ColumnDef<T>;
+};
+
+/**
+ * Types of relationships supported between tables
+ */
+declare const RelationKinds: {
+    /** One-to-one relationship */
+    readonly HasOne: "HAS_ONE";
+    /** One-to-many relationship */
+    readonly HasMany: "HAS_MANY";
+    /** Many-to-one relationship */
+    readonly BelongsTo: "BELONGS_TO";
+    /** Many-to-many relationship with pivot metadata */
+    readonly BelongsToMany: "BELONGS_TO_MANY";
+};
+/**
+ * Type representing the supported relationship kinds
+ */
+type RelationType = (typeof RelationKinds)[keyof typeof RelationKinds];
+type CascadeMode = 'none' | 'all' | 'persist' | 'remove' | 'link';
+/**
+ * One-to-many relationship definition
+ */
+interface HasManyRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.HasMany;
+    target: TTarget;
+    foreignKey: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
+/**
+ * One-to-one relationship definition
+ */
+interface HasOneRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.HasOne;
+    target: TTarget;
+    foreignKey: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
+/**
+ * Many-to-one relationship definition
+ */
+interface BelongsToRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.BelongsTo;
+    target: TTarget;
+    foreignKey: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
+/**
+ * Many-to-many relationship definition with rich pivot metadata
+ */
+interface BelongsToManyRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.BelongsToMany;
+    target: TTarget;
+    pivotTable: TableDef;
+    pivotForeignKeyToRoot: string;
+    pivotForeignKeyToTarget: string;
+    localKey?: string;
+    targetKey?: string;
+    pivotPrimaryKey?: string;
+    defaultPivotColumns?: string[];
+    cascade?: CascadeMode;
+}
+/**
+ * Union type representing any supported relationship definition
+ */
+type RelationDef = HasManyRelation | HasOneRelation | BelongsToRelation | BelongsToManyRelation;
+/**
+ * Creates a one-to-many relationship definition
+ * @param target - Target table of the relationship
+ * @param foreignKey - Foreign key column name on the child table
+ * @param localKey - Local key column name (optional)
+ * @returns HasManyRelation definition
+ *
+ * @example
+ * ```typescript
+ * hasMany(usersTable, 'user_id')
+ * ```
+ */
+declare const hasMany: <TTarget extends TableDef>(target: TTarget, foreignKey: string, localKey?: string, cascade?: CascadeMode) => HasManyRelation<TTarget>;
+/**
+ * Creates a one-to-one relationship definition
+ * @param target - Target table of the relationship
+ * @param foreignKey - Foreign key column name on the child table
+ * @param localKey - Local key column name (optional)
+ * @returns HasOneRelation definition
+ */
+declare const hasOne: <TTarget extends TableDef>(target: TTarget, foreignKey: string, localKey?: string, cascade?: CascadeMode) => HasOneRelation<TTarget>;
+/**
+ * Creates a many-to-one relationship definition
+ * @param target - Target table of the relationship
+ * @param foreignKey - Foreign key column name on the child table
+ * @param localKey - Local key column name (optional)
+ * @returns BelongsToRelation definition
+ *
+ * @example
+ * ```typescript
+ * belongsTo(usersTable, 'user_id')
+ * ```
+ */
+declare const belongsTo: <TTarget extends TableDef>(target: TTarget, foreignKey: string, localKey?: string, cascade?: CascadeMode) => BelongsToRelation<TTarget>;
+/**
+ * Creates a many-to-many relationship definition with pivot metadata
+ * @param target - Target table
+ * @param pivotTable - Intermediate pivot table definition
+ * @param options - Pivot metadata configuration
+ * @returns BelongsToManyRelation definition
+ */
+declare const belongsToMany: <TTarget extends TableDef>(target: TTarget, pivotTable: TableDef, options: {
+    pivotForeignKeyToRoot: string;
+    pivotForeignKeyToTarget: string;
+    localKey?: string;
+    targetKey?: string;
+    pivotPrimaryKey?: string;
+    defaultPivotColumns?: string[];
+    cascade?: CascadeMode;
+}) => BelongsToManyRelation<TTarget>;
+
+interface IndexColumn {
+    column: string;
+    order?: 'ASC' | 'DESC';
+    nulls?: 'FIRST' | 'LAST';
+}
+interface IndexDef {
+    name?: string;
+    columns: (string | IndexColumn)[];
+    unique?: boolean;
+    where?: string;
+}
+interface CheckConstraint {
+    name?: string;
+    expression: string;
+}
+interface TableOptions {
+    schema?: string;
+    primaryKey?: string[];
+    indexes?: IndexDef[];
+    checks?: CheckConstraint[];
+    comment?: string;
+    engine?: string;
+    charset?: string;
+    collation?: string;
+}
+interface TableHooks {
+    beforeInsert?(ctx: unknown, entity: any): Promise<void> | void;
+    afterInsert?(ctx: unknown, entity: any): Promise<void> | void;
+    beforeUpdate?(ctx: unknown, entity: any): Promise<void> | void;
+    afterUpdate?(ctx: unknown, entity: any): Promise<void> | void;
+    beforeDelete?(ctx: unknown, entity: any): Promise<void> | void;
+    afterDelete?(ctx: unknown, entity: any): Promise<void> | void;
+}
+/**
+ * Definition of a database table with its columns and relationships
+ * @typeParam T - Type of the columns record
+ */
+interface TableDef<T extends Record<string, ColumnDef> = Record<string, ColumnDef>> {
+    /** Name of the table */
+    name: string;
+    /** Optional schema/catalog name */
+    schema?: string;
+    /** Record of column definitions keyed by column name */
+    columns: T;
+    /** Record of relationship definitions keyed by relation name */
+    relations: Record<string, RelationDef>;
+    /** Optional lifecycle hooks */
+    hooks?: TableHooks;
+    /** Composite primary key definition (falls back to column.primary flags) */
+    primaryKey?: string[];
+    /** Secondary indexes */
+    indexes?: IndexDef[];
+    /** Table-level check constraints */
+    checks?: CheckConstraint[];
+    /** Table comment/description */
+    comment?: string;
+    /** Dialect-specific options */
+    engine?: string;
+    charset?: string;
+    collation?: string;
+}
+/**
+ * Creates a table definition with columns and relationships
+ * @typeParam T - Type of the columns record
+ * @param name - Name of the table
+ * @param columns - Record of column definitions
+ * @param relations - Record of relationship definitions (optional)
+ * @returns Complete table definition with runtime-filled column metadata
+ *
+ * @example
+ * ```typescript
+ * const usersTable = defineTable('users', {
+ *   id: col.primaryKey(col.int()),
+ *   name: col.varchar(255),
+ *   email: col.varchar(255)
+ * });
+ * ```
+ */
+declare const defineTable: <T extends Record<string, ColumnDef>>(name: string, columns: T, relations?: Record<string, RelationDef>, hooks?: TableHooks, options?: TableOptions) => TableDef<T>;
+
+/**
+ * Resolves a relation definition to its target table type.
+ */
+type RelationTargetTable<TRel extends RelationDef> = TRel extends HasManyRelation<infer TTarget> ? TTarget : TRel extends HasOneRelation<infer TTarget> ? TTarget : TRel extends BelongsToRelation<infer TTarget> ? TTarget : TRel extends BelongsToManyRelation<infer TTarget> ? TTarget : never;
+/**
+ * Maps a ColumnDef to its TypeScript type representation
+ */
+type ColumnToTs<T extends ColumnDef> = T['type'] extends 'INT' | 'INTEGER' | 'int' | 'integer' ? number : T['type'] extends 'BIGINT' | 'bigint' ? number | bigint : T['type'] extends 'DECIMAL' | 'decimal' | 'FLOAT' | 'float' | 'DOUBLE' | 'double' ? number : T['type'] extends 'BOOLEAN' | 'boolean' ? boolean : T['type'] extends 'JSON' | 'json' ? unknown : T['type'] extends 'BLOB' | 'blob' | 'BINARY' | 'binary' | 'VARBINARY' | 'varbinary' | 'BYTEA' | 'bytea' ? Buffer : T['type'] extends 'DATE' | 'date' | 'DATETIME' | 'datetime' | 'TIMESTAMP' | 'timestamp' | 'TIMESTAMPTZ' | 'timestamptz' ? string : string;
+/**
+ * Infers a row shape from a table definition
+ */
+type InferRow<TTable extends TableDef> = {
+    [K in keyof TTable['columns']]: ColumnToTs<TTable['columns'][K]>;
+};
+type RelationResult$1<T extends RelationDef> = T extends HasManyRelation<infer TTarget> ? InferRow<TTarget>[] : T extends HasOneRelation<infer TTarget> ? InferRow<TTarget> | null : T extends BelongsToRelation<infer TTarget> ? InferRow<TTarget> | null : T extends BelongsToManyRelation<infer TTarget> ? (InferRow<TTarget> & {
+    _pivot?: any;
+})[] : never;
+/**
+ * Maps relation names to the expected row results
+ */
+type RelationMap<TTable extends TableDef> = {
+    [K in keyof TTable['relations']]: RelationResult$1<TTable['relations'][K]>;
+};
+interface HasManyCollection<TChild> {
+    load(): Promise<TChild[]>;
+    getItems(): TChild[];
+    add(data: Partial<TChild>): TChild;
+    attach(entity: TChild): void;
+    remove(entity: TChild): void;
+    clear(): void;
+}
+interface BelongsToReference<TParent> {
+    load(): Promise<TParent | null>;
+    get(): TParent | null;
+    set(data: Partial<TParent> | TParent | null): TParent | null;
+}
+interface HasOneReference<TChild> {
+    load(): Promise<TChild | null>;
+    get(): TChild | null;
+    set(data: Partial<TChild> | TChild | null): TChild | null;
+}
+interface ManyToManyCollection<TTarget> {
+    load(): Promise<TTarget[]>;
+    getItems(): TTarget[];
+    attach(target: TTarget | number | string): void;
+    detach(target: TTarget | number | string): void;
+    syncByIds(ids: (number | string)[]): Promise<void>;
+}
+type EntityInstance<TTable extends TableDef, TRow = InferRow<TTable>> = TRow & {
+    [K in keyof RelationMap<TTable>]: TTable['relations'][K] extends HasManyRelation<infer TTarget> ? HasManyCollection<EntityInstance<TTarget>> : TTable['relations'][K] extends HasOneRelation<infer TTarget> ? HasOneReference<EntityInstance<TTarget>> : TTable['relations'][K] extends BelongsToManyRelation<infer TTarget> ? ManyToManyCollection<EntityInstance<TTarget>> : TTable['relations'][K] extends BelongsToRelation<infer TTarget> ? BelongsToReference<EntityInstance<TTarget>> : never;
+} & {
+    $load<K extends keyof RelationMap<TTable>>(relation: K): Promise<RelationMap<TTable>[K]>;
+};
+
+/**
+ * SQL operators used in query conditions
+ */
+declare const SQL_OPERATORS: {
+    /** Equality operator */
+    readonly EQUALS: "=";
+    /** Not equals operator */
+    readonly NOT_EQUALS: "!=";
+    /** Greater than operator */
+    readonly GREATER_THAN: ">";
+    /** Greater than or equal operator */
+    readonly GREATER_OR_EQUAL: ">=";
+    /** Less than operator */
+    readonly LESS_THAN: "<";
+    /** Less than or equal operator */
+    readonly LESS_OR_EQUAL: "<=";
+    /** LIKE pattern matching operator */
+    readonly LIKE: "LIKE";
+    /** NOT LIKE pattern matching operator */
+    readonly NOT_LIKE: "NOT LIKE";
+    /** IN membership operator */
+    readonly IN: "IN";
+    /** NOT IN membership operator */
+    readonly NOT_IN: "NOT IN";
+    /** BETWEEN range operator */
+    readonly BETWEEN: "BETWEEN";
+    /** NOT BETWEEN range operator */
+    readonly NOT_BETWEEN: "NOT BETWEEN";
+    /** IS NULL null check operator */
+    readonly IS_NULL: "IS NULL";
+    /** IS NOT NULL null check operator */
+    readonly IS_NOT_NULL: "IS NOT NULL";
+    /** Logical AND operator */
+    readonly AND: "AND";
+    /** Logical OR operator */
+    readonly OR: "OR";
+    /** EXISTS operator */
+    readonly EXISTS: "EXISTS";
+    /** NOT EXISTS operator */
+    readonly NOT_EXISTS: "NOT EXISTS";
+};
+/**
+ * Type representing any supported SQL operator
+ */
+type SqlOperator = (typeof SQL_OPERATORS)[keyof typeof SQL_OPERATORS];
+/**
+ * Types of SQL joins supported
+ */
+declare const JOIN_KINDS: {
+    /** INNER JOIN type */
+    readonly INNER: "INNER";
+    /** LEFT JOIN type */
+    readonly LEFT: "LEFT";
+    /** RIGHT JOIN type */
+    readonly RIGHT: "RIGHT";
+    /** CROSS JOIN type */
+    readonly CROSS: "CROSS";
+};
+/**
+ * Type representing any supported join kind
+ */
+type JoinKind = (typeof JOIN_KINDS)[keyof typeof JOIN_KINDS];
+/**
+ * Ordering directions for result sorting
+ */
+declare const ORDER_DIRECTIONS: {
+    /** Ascending order */
+    readonly ASC: "ASC";
+    /** Descending order */
+    readonly DESC: "DESC";
+};
+/**
+ * Type representing any supported order direction
+ */
+type OrderDirection = (typeof ORDER_DIRECTIONS)[keyof typeof ORDER_DIRECTIONS];
+/**
+ * Supported database dialects
+ */
+declare const SUPPORTED_DIALECTS: {
+    /** MySQL database dialect */
+    readonly MYSQL: "mysql";
+    /** SQLite database dialect */
+    readonly SQLITE: "sqlite";
+    /** Microsoft SQL Server dialect */
+    readonly MSSQL: "mssql";
+    /** PostgreSQL database dialect */
+    readonly POSTGRES: "postgres";
+};
+/**
+ * Type representing any supported database dialect
+ */
+type DialectName$1 = (typeof SUPPORTED_DIALECTS)[keyof typeof SUPPORTED_DIALECTS];
+
+/**
+ * Minimal column reference used by AST builders.
+ * Accepts any object with a name and optional table/alias fields
+ * (schema ColumnDef/TableDef remain structurally compatible).
+ */
+interface ColumnRef {
+    name: string;
+    table?: string;
+    alias?: string;
+}
+/**
+ * Minimal table reference used by AST builders.
+ * Keeps AST decoupled from full schema TableDef shape.
+ */
+interface TableRef {
+    name: string;
+    schema?: string;
+    alias?: string;
+}
+
+/**
+ * AST node representing a literal value
+ */
+interface LiteralNode {
+    type: 'Literal';
+    /** The literal value (string, number, boolean, or null) */
+    value: string | number | boolean | null;
+}
+/**
+ * AST node representing a column reference
+ */
+interface ColumnNode {
+    type: 'Column';
+    /** Table name the column belongs to */
+    table: string;
+    /** Column name */
+    name: string;
+    /** Optional alias for the column */
+    alias?: string;
+    /** Optional scope marker (e.g., 'outer' for correlated references) */
+    scope?: 'outer' | 'default';
+}
+/**
+ * AST node representing a function call
+ */
+interface FunctionNode {
+    type: 'Function';
+    /** Function name (e.g., COUNT, SUM) */
+    name: string;
+    /** Optional canonical function key for dialect-aware rendering */
+    fn?: string;
+    /** Function arguments */
+    args: OperandNode[];
+    /** Optional alias for the function result */
+    alias?: string;
+    /** Optional ORDER BY clause used by aggregations like GROUP_CONCAT */
+    orderBy?: OrderByNode[];
+    /** Optional separator argument used by GROUP_CONCAT-like functions */
+    separator?: OperandNode;
+    /** Optional DISTINCT modifier */
+    distinct?: boolean;
+}
+/**
+ * AST node representing a JSON path expression
+ */
+interface JsonPathNode {
+    type: 'JsonPath';
+    /** Source column */
+    column: ColumnNode;
+    /** JSON path expression */
+    path: string;
+    /** Optional alias for the result */
+    alias?: string;
+}
+/**
+ * AST node representing a scalar subquery
+ */
+interface ScalarSubqueryNode {
+    type: 'ScalarSubquery';
+    /** Subquery to execute */
+    query: SelectQueryNode;
+    /** Optional alias for the subquery result */
+    alias?: string;
+}
+/**
+ * AST node representing a CASE expression
+ */
+interface CaseExpressionNode {
+    type: 'CaseExpression';
+    /** WHEN-THEN conditions */
+    conditions: {
+        when: ExpressionNode;
+        then: OperandNode;
+    }[];
+    /** Optional ELSE clause */
+    else?: OperandNode;
+    /** Optional alias for the result */
+    alias?: string;
+}
+/**
+ * AST node representing a window function
+ */
+interface WindowFunctionNode {
+    type: 'WindowFunction';
+    /** Window function name (e.g., ROW_NUMBER, RANK) */
+    name: string;
+    /** Function arguments */
+    args: (ColumnNode | LiteralNode | JsonPathNode)[];
+    /** Optional PARTITION BY clause */
+    partitionBy?: ColumnNode[];
+    /** Optional ORDER BY clause */
+    orderBy?: OrderByNode[];
+    /** Optional alias for the result */
+    alias?: string;
+}
+/**
+ * Union type representing any operand that can be used in expressions
+ */
+type OperandNode = ColumnNode | LiteralNode | FunctionNode | JsonPathNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode;
+declare const isOperandNode: (node: any) => node is OperandNode;
+declare const isFunctionNode: (node: any) => node is FunctionNode;
+declare const isCaseExpressionNode: (node: any) => node is CaseExpressionNode;
+declare const isWindowFunctionNode: (node: any) => node is WindowFunctionNode;
+declare const isExpressionSelectionNode: (node: ColumnRef | FunctionNode | CaseExpressionNode | WindowFunctionNode) => node is FunctionNode | CaseExpressionNode | WindowFunctionNode;
+/**
+ * AST node representing a binary expression (e.g., column = value)
+ */
+interface BinaryExpressionNode {
+    type: 'BinaryExpression';
+    /** Left operand */
+    left: OperandNode;
+    /** Comparison operator */
+    operator: SqlOperator;
+    /** Right operand */
+    right: OperandNode;
+    /** Optional escape character for LIKE expressions */
+    escape?: LiteralNode;
+}
+/**
+ * AST node representing a logical expression (AND/OR)
+ */
+interface LogicalExpressionNode {
+    type: 'LogicalExpression';
+    /** Logical operator (AND or OR) */
+    operator: 'AND' | 'OR';
+    /** Operands to combine */
+    operands: ExpressionNode[];
+}
+/**
+ * AST node representing a null check expression
+ */
+interface NullExpressionNode {
+    type: 'NullExpression';
+    /** Operand to check for null */
+    left: OperandNode;
+    /** Null check operator */
+    operator: 'IS NULL' | 'IS NOT NULL';
+}
+/**
+ * AST node representing an IN/NOT IN expression
+ */
+interface InExpressionNode {
+    type: 'InExpression';
+    /** Left operand to check */
+    left: OperandNode;
+    /** IN/NOT IN operator */
+    operator: 'IN' | 'NOT IN';
+    /** Values to check against */
+    right: OperandNode[];
+}
+/**
+ * AST node representing an EXISTS/NOT EXISTS expression
+ */
+interface ExistsExpressionNode {
+    type: 'ExistsExpression';
+    /** EXISTS/NOT EXISTS operator */
+    operator: SqlOperator;
+    /** Subquery to check */
+    subquery: SelectQueryNode;
+}
+/**
+ * AST node representing a BETWEEN/NOT BETWEEN expression
+ */
+interface BetweenExpressionNode {
+    type: 'BetweenExpression';
+    /** Operand to check */
+    left: OperandNode;
+    /** BETWEEN/NOT BETWEEN operator */
+    operator: 'BETWEEN' | 'NOT BETWEEN';
+    /** Lower bound */
+    lower: OperandNode;
+    /** Upper bound */
+    upper: OperandNode;
+}
+/**
+ * Union type representing any supported expression node
+ */
+type ExpressionNode = BinaryExpressionNode | LogicalExpressionNode | NullExpressionNode | InExpressionNode | ExistsExpressionNode | BetweenExpressionNode;
 
 type LiteralValue = LiteralNode['value'];
 type ValueOperandInput = OperandNode | LiteralValue;
@@ -195,132 +904,1843 @@ declare const lead: (col: ColumnRef | ColumnNode, offset?: number, defaultValue?
  * @param col - Column to get first value from
  * @returns Window function node for FIRST_VALUE
  */
-declare const firstValue: (col: ColumnRef | 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: ColumnRef | ColumnNode) => WindowFunctionNode;
+/**
+ * Creates a custom window function
+ * @param name - Window function name
+ * @param args - Function arguments
+ * @param partitionBy - Optional PARTITION BY columns
+ * @param orderBy - Optional ORDER BY clauses
+ * @returns Window function node
+ */
+declare const windowFunction: (name: string, args?: (ColumnRef | ColumnNode | LiteralNode | JsonPathNode)[], partitionBy?: (ColumnRef | ColumnNode)[], orderBy?: {
+    column: ColumnRef | ColumnNode;
+    direction: OrderDirection;
+}[]) => WindowFunctionNode;
+
+/**
+ * Creates a COUNT function expression
+ * @param col - Column to count
+ * @returns Function node with COUNT
+ */
+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: ColumnRef | ColumnNode) => FunctionNode;
+/**
+ * Creates an AVG function expression
+ * @param col - Column to average
+ * @returns Function node with AVG
+ */
+declare const avg: (col: ColumnRef | ColumnNode) => FunctionNode;
+/**
+ * Creates a MIN function expression
+ * @param col - Column to take the minimum of
+ * @returns Function node with MIN
+ */
+declare const min: (col: ColumnRef | ColumnNode) => FunctionNode;
+/**
+ * Creates a MAX function expression
+ * @param col - Column to take the maximum of
+ * @returns Function node with MAX
+ */
+declare const max: (col: ColumnRef | ColumnNode) => FunctionNode;
+type GroupConcatOrderByInput = {
+    column: ColumnRef | ColumnNode;
+    direction?: OrderDirection;
+};
+type GroupConcatOptions = {
+    separator?: ValueOperandInput;
+    orderBy?: GroupConcatOrderByInput[];
+};
+/**
+ * Aggregates grouped strings into a single value.
+ */
+declare const groupConcat: (col: ColumnRef | ColumnNode, options?: GroupConcatOptions) => 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;
+    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;
+    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
+ * @param visitor - Visitor implementation
+ */
+declare const visitExpression: <R>(node: ExpressionNode, visitor: ExpressionVisitor<R>) => R;
+/**
+ * Dispatches an operand node to the visitor
+ * @param node - Operand node to visit
+ * @param visitor - Visitor implementation
+ */
+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;
+
+/**
+ * AST node representing a JOIN clause
+ */
+interface JoinNode {
+    type: 'Join';
+    /** Type of join (INNER, LEFT, RIGHT, etc.) */
+    kind: JoinKind;
+    /** Table to join */
+    table: TableSourceNode;
+    /** Join condition expression */
+    condition: ExpressionNode;
+    /** Optional metadata for non-SQL concerns (e.g., relation name) */
+    meta?: Record<string, unknown>;
+}
+
+/**
+ * AST node representing a table reference in a query
+ */
+interface TableNode {
+    type: 'Table';
+    /** Table name */
+    name: string;
+    /** Optional schema name */
+    schema?: string;
+    /** Optional table alias */
+    alias?: string;
+}
+/**
+ * AST node representing a function used as a table source (table-valued function)
+ */
+interface FunctionTableNode {
+    type: 'FunctionTable';
+    /** Function name */
+    name: string;
+    /** Optional schema for the function (some dialects) */
+    schema?: string;
+    /** Function arguments as operand nodes */
+    args?: any[];
+    /** Optional alias for the function table */
+    alias?: string;
+    /** LATERAL flag */
+    lateral?: boolean;
+    /** WITH ORDINALITY flag */
+    withOrdinality?: boolean;
+    /** Optional column aliases */
+    columnAliases?: string[];
+}
+/**
+ * AST node representing a derived table (subquery with an alias)
+ */
+interface DerivedTableNode {
+    type: 'DerivedTable';
+    /** Subquery providing the rows */
+    query: SelectQueryNode;
+    /** Required alias for the derived table */
+    alias: string;
+    /** Optional column aliases */
+    columnAliases?: string[];
+}
+type TableSourceNode = TableNode | FunctionTableNode | DerivedTableNode;
+/**
+ * AST node representing an ORDER BY clause
+ */
+interface OrderByNode {
+    type: 'OrderBy';
+    /** Column to order by */
+    column: ColumnNode;
+    /** Order direction (ASC or DESC) */
+    direction: OrderDirection;
+}
+/**
+ * AST node representing a Common Table Expression (CTE)
+ */
+interface CommonTableExpressionNode {
+    type: 'CommonTableExpression';
+    /** CTE name */
+    name: string;
+    /** Optional column names */
+    columns?: string[];
+    /** CTE query */
+    query: SelectQueryNode;
+    /** Whether the CTE is recursive */
+    recursive: boolean;
+}
+/**
+ * Supported set operation kinds for compound SELECT queries
+ */
+type SetOperationKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'EXCEPT';
+/**
+ * AST node representing a set operation (UNION, INTERSECT, etc.)
+ */
+interface SetOperationNode {
+    type: 'SetOperation';
+    /** Operator to combine queries */
+    operator: SetOperationKind;
+    /** Right-hand query in the compound expression */
+    query: SelectQueryNode;
+}
+/**
+ * AST node representing a complete SELECT query
+ */
+interface SelectQueryNode {
+    type: 'SelectQuery';
+    /** Optional CTEs (WITH clauses) */
+    ctes?: CommonTableExpressionNode[];
+    /** FROM clause table (either a Table or a FunctionTable) */
+    from: TableSourceNode;
+    /** SELECT clause columns */
+    columns: (ColumnNode | FunctionNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode)[];
+    /** JOIN clauses */
+    joins: JoinNode[];
+    /** Optional WHERE clause */
+    where?: ExpressionNode;
+    /** Optional GROUP BY clause */
+    groupBy?: ColumnNode[];
+    /** Optional HAVING clause */
+    having?: ExpressionNode;
+    /** Optional ORDER BY clause */
+    orderBy?: OrderByNode[];
+    /** Optional LIMIT clause */
+    limit?: number;
+    /** Optional OFFSET clause */
+    offset?: number;
+    /** Optional query metadata */
+    meta?: Record<string, unknown>;
+    /** Optional DISTINCT clause */
+    distinct?: ColumnNode[];
+    /** Optional set operations chaining this query with others */
+    setOps?: SetOperationNode[];
+}
+interface InsertQueryNode {
+    type: 'InsertQuery';
+    /** Target table */
+    into: TableNode;
+    /** Column order for inserted values */
+    columns: ColumnNode[];
+    /** Rows of values to insert */
+    values: OperandNode[][];
+    /** Optional RETURNING clause */
+    returning?: ColumnNode[];
+}
+interface UpdateAssignmentNode {
+    /** Column to update */
+    column: ColumnNode;
+    /** Value to set */
+    value: OperandNode;
+}
+interface UpdateQueryNode {
+    type: 'UpdateQuery';
+    /** Table being updated */
+    table: TableNode;
+    /** Assignments for SET clause */
+    set: UpdateAssignmentNode[];
+    /** Optional WHERE clause */
+    where?: ExpressionNode;
+    /** Optional RETURNING clause */
+    returning?: ColumnNode[];
+}
+interface DeleteQueryNode {
+    type: 'DeleteQuery';
+    /** Table to delete from */
+    from: TableNode;
+    /** Optional WHERE clause */
+    where?: ExpressionNode;
+    /** Optional RETURNING clause */
+    returning?: ColumnNode[];
+}
+
+/**
+ * Plan describing pivot columns needed for hydration
+ */
+interface HydrationPivotPlan {
+    table: string;
+    primaryKey: string;
+    aliasPrefix: string;
+    columns: string[];
+}
+/**
+ * Plan for hydrating relationship data
+ */
+interface HydrationRelationPlan {
+    /** Name of the relationship */
+    name: string;
+    /** Alias prefix for the relationship */
+    aliasPrefix: string;
+    /** Type of relationship */
+    type: RelationType;
+    /** Target table name */
+    targetTable: string;
+    /** Target table primary key */
+    targetPrimaryKey: string;
+    /** Foreign key column */
+    foreignKey: string;
+    /** Local key column */
+    localKey: string;
+    /** Columns to include */
+    columns: string[];
+    /** Optional pivot plan for many-to-many relationships */
+    pivot?: HydrationPivotPlan;
+}
+/**
+ * Complete hydration plan for a query
+ */
+interface HydrationPlan {
+    /** Root table name */
+    rootTable: string;
+    /** Root table primary key */
+    rootPrimaryKey: string;
+    /** Root table columns */
+    rootColumns: string[];
+    /** Relationship hydration plans */
+    relations: HydrationRelationPlan[];
+}
+/**
+ * Metadata bag for attaching hydration to query ASTs without coupling AST types.
+ */
+interface HydrationMetadata {
+    hydration?: HydrationPlan;
+    [key: string]: unknown;
+}
+
+interface FunctionRenderContext {
+    node: FunctionNode;
+    compiledArgs: string[];
+    /** Helper to compile additional operands (e.g., separators or ORDER BY columns) */
+    compileOperand: (operand: OperandNode) => string;
+}
+type FunctionRenderer = (ctx: FunctionRenderContext) => string;
+interface FunctionStrategy {
+    /**
+     * Returns a renderer for a specific function name (e.g. "DATE_ADD").
+     * Returns undefined if this dialect doesn't support the function.
+     */
+    getRenderer(functionName: string): FunctionRenderer | undefined;
+}
+
+/**
+ * Context for SQL compilation with parameter management
+ */
+interface CompilerContext {
+    /** Array of parameters */
+    params: unknown[];
+    /** Function to add a parameter and get its placeholder */
+    addParameter(value: unknown): string;
+}
+/**
+ * Result of SQL compilation
+ */
+interface CompiledQuery {
+    /** Generated SQL string */
+    sql: string;
+    /** Parameters for the query */
+    params: unknown[];
+}
+interface SelectCompiler {
+    compileSelect(ast: SelectQueryNode): CompiledQuery;
+}
+interface InsertCompiler {
+    compileInsert(ast: InsertQueryNode): CompiledQuery;
+}
+interface UpdateCompiler {
+    compileUpdate(ast: UpdateQueryNode): CompiledQuery;
+}
+interface DeleteCompiler {
+    compileDelete(ast: DeleteQueryNode): CompiledQuery;
+}
+/**
+ * Abstract base class for SQL dialect implementations
+ */
+declare abstract class Dialect implements SelectCompiler, InsertCompiler, UpdateCompiler, DeleteCompiler {
+    /** Dialect identifier used for function rendering and formatting */
+    protected abstract readonly dialect: DialectName$1;
+    /**
+     * Compiles a SELECT query AST to SQL
+     * @param ast - Query AST to compile
+     * @returns Compiled query with SQL and parameters
+     */
+    compileSelect(ast: SelectQueryNode): CompiledQuery;
+    compileInsert(ast: InsertQueryNode): CompiledQuery;
+    compileUpdate(ast: UpdateQueryNode): CompiledQuery;
+    compileDelete(ast: DeleteQueryNode): CompiledQuery;
+    supportsReturning(): boolean;
+    /**
+     * Compiles SELECT query AST to SQL (to be implemented by concrete dialects)
+     * @param ast - Query AST
+     * @param ctx - Compiler context
+     * @returns SQL string
+     */
+    protected abstract compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
+    protected abstract compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string;
+    protected abstract compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string;
+    protected abstract compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string;
+    /**
+     * Quotes an SQL identifier (to be implemented by concrete dialects)
+     * @param id - Identifier to quote
+     * @returns Quoted identifier
+     */
+    abstract quoteIdentifier(id: string): string;
+    /**
+     * Compiles a WHERE clause
+     * @param where - WHERE expression
+     * @param ctx - Compiler context
+     * @returns SQL WHERE clause or empty string
+     */
+    protected compileWhere(where: ExpressionNode | undefined, ctx: CompilerContext): string;
+    protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string;
+    /**
+     * Generates subquery for EXISTS expressions
+     * Rule: Always forces SELECT 1, ignoring column list
+     * Maintains FROM, JOINs, WHERE, GROUP BY, ORDER BY, LIMIT/OFFSET
+     * Does not add ';' at the end
+     * @param ast - Query AST
+     * @param ctx - Compiler context
+     * @returns SQL for EXISTS subquery
+     */
+    protected compileSelectForExists(ast: SelectQueryNode, ctx: CompilerContext): string;
+    /**
+     * Creates a new compiler context
+     * @returns Compiler context with parameter management
+     */
+    protected createCompilerContext(): CompilerContext;
+    /**
+     * Formats a parameter placeholder
+     * @param index - Parameter index
+     * @returns Formatted placeholder string
+     */
+    protected formatPlaceholder(index: number): string;
+    /**
+     * Whether the current dialect supports a given set operation.
+     * Override in concrete dialects to restrict support.
+     */
+    protected supportsSetOperation(kind: SetOperationKind): boolean;
+    /**
+     * Validates set-operation semantics:
+     * - Ensures the dialect supports requested operators.
+     * - Enforces that only the outermost compound query may have ORDER/LIMIT/OFFSET.
+     * @param ast - Query to validate
+     * @param isOutermost - Whether this node is the outermost compound query
+     */
+    protected validateSetOperations(ast: SelectQueryNode, isOutermost?: boolean): void;
+    /**
+     * Hoists CTEs from set-operation operands to the outermost query so WITH appears once.
+     * @param ast - Query AST
+     * @returns Normalized AST without inner CTEs and a list of hoisted CTEs
+     */
+    private hoistCtes;
+    /**
+     * Normalizes a SELECT AST before compilation (validation + CTE hoisting).
+     * @param ast - Query AST
+     * @returns Normalized query AST
+     */
+    protected normalizeSelectAst(ast: SelectQueryNode): SelectQueryNode;
+    private readonly expressionCompilers;
+    private readonly operandCompilers;
+    protected readonly functionStrategy: FunctionStrategy;
+    protected constructor(functionStrategy?: FunctionStrategy);
+    /**
+     * Creates a new Dialect instance (for testing purposes)
+     * @param functionStrategy - Optional function strategy
+     * @returns New Dialect instance
+     */
+    static create(functionStrategy?: FunctionStrategy): Dialect;
+    /**
+     * Registers an expression compiler for a specific node type
+     * @param type - Expression node type
+     * @param compiler - Compiler function
+     */
+    protected registerExpressionCompiler<T extends ExpressionNode>(type: T['type'], compiler: (node: T, ctx: CompilerContext) => string): void;
+    /**
+     * Registers an operand compiler for a specific node type
+     * @param type - Operand node type
+     * @param compiler - Compiler function
+     */
+    protected registerOperandCompiler<T extends OperandNode>(type: T['type'], compiler: (node: T, ctx: CompilerContext) => string): void;
+    /**
+     * Compiles an expression node
+     * @param node - Expression node to compile
+     * @param ctx - Compiler context
+     * @returns Compiled SQL expression
+     */
+    protected compileExpression(node: ExpressionNode, ctx: CompilerContext): string;
+    /**
+     * Compiles an operand node
+     * @param node - Operand node to compile
+     * @param ctx - Compiler context
+     * @returns Compiled SQL operand
+     */
+    protected compileOperand(node: OperandNode, ctx: CompilerContext): string;
+    private registerDefaultExpressionCompilers;
+    private registerDefaultOperandCompilers;
+    protected compileJsonPath(node: JsonPathNode): string;
+    /**
+     * Compiles a function operand, using the dialect's function strategy.
+     */
+    protected compileFunctionOperand(fnNode: FunctionNode, ctx: CompilerContext): string;
+}
+
+type DialectKey = 'postgres' | 'mysql' | 'sqlite' | 'mssql' | (string & {});
+
+/**
+ * Node types that can be used in query projections
+ */
+type ProjectionNode = ColumnNode | FunctionNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode;
+/**
+ * Manages the state of a SELECT query being built
+ */
+declare class SelectQueryState {
+    /**
+     * Table definition for the query
+     */
+    readonly table: TableDef;
+    /**
+     * Abstract Syntax Tree (AST) representation of the query
+     */
+    readonly ast: SelectQueryNode;
+    /**
+     * Creates a new SelectQueryState instance
+     * @param table - Table definition
+     * @param ast - Optional existing AST
+     */
+    constructor(table: TableDef, ast?: SelectQueryNode);
+    /**
+     * Creates a new SelectQueryState with updated AST
+     * @param nextAst - Updated AST
+     * @returns New SelectQueryState instance
+     */
+    private clone;
+    /**
+     * Adds columns to the query
+     * @param newCols - Columns to add
+     * @returns New SelectQueryState with added columns
+     */
+    withColumns(newCols: ProjectionNode[]): SelectQueryState;
+    /**
+     * Adds a join to the query
+     * @param join - Join node to add
+     * @returns New SelectQueryState with added join
+     */
+    withJoin(join: JoinNode): SelectQueryState;
+    /**
+     * Replaces the FROM clause.
+     * @param from - Table source for the FROM clause
+     * @returns New SelectQueryState with updated FROM
+     */
+    withFrom(from: TableSourceNode): SelectQueryState;
+    /**
+     * Adds a WHERE clause to the query
+     * @param predicate - WHERE predicate expression
+     * @returns New SelectQueryState with WHERE clause
+     */
+    withWhere(predicate: ExpressionNode): SelectQueryState;
+    /**
+     * Adds a HAVING clause to the query
+     * @param predicate - HAVING predicate expression
+     * @returns New SelectQueryState with HAVING clause
+     */
+    withHaving(predicate: ExpressionNode): SelectQueryState;
+    /**
+     * Adds GROUP BY columns to the query
+     * @param columns - Columns to group by
+     * @returns New SelectQueryState with GROUP BY clause
+     */
+    withGroupBy(columns: ColumnNode[]): SelectQueryState;
+    /**
+     * Adds ORDER BY clauses to the query
+     * @param orderBy - ORDER BY nodes
+     * @returns New SelectQueryState with ORDER BY clause
+     */
+    withOrderBy(orderBy: OrderByNode[]): SelectQueryState;
+    /**
+     * Adds DISTINCT columns to the query
+     * @param columns - Columns to make distinct
+     * @returns New SelectQueryState with DISTINCT clause
+     */
+    withDistinct(columns: ColumnNode[]): SelectQueryState;
+    /**
+     * Adds a LIMIT clause to the query
+     * @param limit - Maximum number of rows to return
+     * @returns New SelectQueryState with LIMIT clause
+     */
+    withLimit(limit: number): SelectQueryState;
+    /**
+     * Adds an OFFSET clause to the query
+     * @param offset - Number of rows to skip
+     * @returns New SelectQueryState with OFFSET clause
+     */
+    withOffset(offset: number): SelectQueryState;
+    /**
+     * Adds a Common Table Expression (CTE) to the query
+     * @param cte - CTE node to add
+     * @returns New SelectQueryState with CTE
+     */
+    withCte(cte: CommonTableExpressionNode): SelectQueryState;
+    /**
+     * Adds a set operation (UNION/INTERSECT/EXCEPT) to the query
+     * @param op - Set operation node to add
+     * @returns New SelectQueryState with set operation
+     */
+    withSetOperation(op: SetOperationNode): SelectQueryState;
+}
+
+/**
+ * Manages hydration planning for query results
+ */
+declare class HydrationPlanner {
+    private readonly table;
+    private readonly plan?;
+    /**
+     * Creates a new HydrationPlanner instance
+     * @param table - Table definition
+     * @param plan - Optional existing hydration plan
+     */
+    constructor(table: TableDef, plan?: HydrationPlan);
+    /**
+     * Captures root table columns for hydration planning
+     * @param columns - Columns to capture
+     * @returns Updated HydrationPlanner with captured columns
+     */
+    captureRootColumns(columns: ProjectionNode[]): HydrationPlanner;
+    /**
+     * Includes a relation in the hydration plan
+     * @param rel - Relation definition
+     * @param relationName - Name of the relation
+     * @param aliasPrefix - Alias prefix for relation columns
+     * @param columns - Columns to include from the relation
+     * @returns Updated HydrationPlanner with included relation
+     */
+    includeRelation(rel: RelationDef, relationName: string, aliasPrefix: string, columns: string[], pivot?: {
+        aliasPrefix: string;
+        columns: string[];
+    }): HydrationPlanner;
+    /**
+     * Gets the current hydration plan
+     * @returns Current hydration plan or undefined
+     */
+    getPlan(): HydrationPlan | undefined;
+    /**
+     * Gets the current hydration plan or creates a default one
+     * @returns Current hydration plan or default plan
+     */
+    private getPlanOrDefault;
+    /**
+     * Builds a relation plan for hydration
+     * @param rel - Relation definition
+     * @param relationName - Name of the relation
+     * @param aliasPrefix - Alias prefix for relation columns
+     * @param columns - Columns to include from the relation
+     * @returns Hydration relation plan
+     */
+    private buildRelationPlan;
+}
+
+/**
+ * Manages hydration planning for query results
+ */
+declare class HydrationManager {
+    private readonly table;
+    private readonly planner;
+    /**
+     * Creates a new HydrationManager instance
+     * @param table - Table definition
+     * @param planner - Hydration planner
+     */
+    constructor(table: TableDef, planner: HydrationPlanner);
+    /**
+     * Creates a new HydrationManager with updated planner
+     * @param nextPlanner - Updated hydration planner
+     * @returns New HydrationManager instance
+     */
+    private clone;
+    /**
+     * Handles column selection for hydration planning
+     * @param state - Current query state
+     * @param newColumns - Newly selected columns
+     * @returns Updated HydrationManager with captured columns
+     */
+    onColumnsSelected(state: SelectQueryState, newColumns: ProjectionNode[]): HydrationManager;
+    /**
+     * Handles relation inclusion for hydration planning
+     * @param state - Current query state
+     * @param relation - Relation definition
+     * @param relationName - Name of the relation
+     * @param aliasPrefix - Alias prefix for the relation
+     * @param targetColumns - Target columns to include
+     * @returns Updated HydrationManager with included relation
+     */
+    onRelationIncluded(state: SelectQueryState, relation: RelationDef, relationName: string, aliasPrefix: string, targetColumns: string[], pivot?: {
+        aliasPrefix: string;
+        columns: string[];
+    }): HydrationManager;
+    /**
+     * Applies hydration plan to the AST
+     * @param ast - Query AST to modify
+     * @returns AST with hydration metadata
+     */
+    applyToAst(ast: SelectQueryNode): SelectQueryNode;
+    /**
+     * Gets the current hydration plan
+     * @returns Hydration plan or undefined if none exists
+     */
+    getPlan(): HydrationPlan | undefined;
+    /**
+     * Attaches hydration metadata to a query AST node.
+     */
+    private attachHydrationMeta;
+    /**
+     * Determines whether the query needs pagination rewriting to keep LIMIT/OFFSET
+     * applied to parent rows when eager-loading multiplicative relations.
+     */
+    private requiresParentPagination;
+    private hasMultiplyingRelations;
+    /**
+     * Rewrites the query using CTEs so LIMIT/OFFSET target distinct parent rows
+     * instead of the joined result set.
+     *
+     * The strategy:
+     * - Hoist the original query (minus limit/offset) into a base CTE.
+     * - Select distinct parent ids from that base CTE with the original ordering and pagination.
+     * - Join the base CTE against the paged ids to retrieve the joined rows for just that page.
+     */
+    private wrapForParentPagination;
+    private nextCteName;
+    private getProjectionNames;
+    private buildProjectionAliasMap;
+    private mapOrderBy;
+    private buildPagingColumns;
+}
+
+/**
+ * Result of column selection operation
+ */
+interface ColumnSelectionResult {
+    /**
+     * Updated query state
+     */
+    state: SelectQueryState;
+    /**
+     * Columns that were added
+     */
+    addedColumns: ProjectionNode[];
+}
+/**
+ * Service for manipulating query AST (Abstract Syntax Tree)
+ */
+declare class QueryAstService {
+    private readonly table;
+    private readonly state;
+    /**
+     * Creates a new QueryAstService instance
+     * @param table - Table definition
+     * @param state - Current query state
+     */
+    constructor(table: TableDef, state: SelectQueryState);
+    /**
+     * Selects columns for the query
+     * @param columns - Columns to select (key: alias, value: column definition or expression)
+     * @returns Column selection result with updated state and added columns
+     */
+    select(columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>): ColumnSelectionResult;
+    /**
+     * Selects raw column expressions (best-effort parser for simple references/functions)
+     * @param cols - Raw column expressions
+     * @returns Column selection result with updated state and added columns
+     */
+    selectRaw(cols: string[]): ColumnSelectionResult;
+    /**
+     * Adds a Common Table Expression (CTE) to the query
+     * @param name - Name of the CTE
+     * @param query - Query for the CTE
+     * @param columns - Optional column names for the CTE
+     * @param recursive - Whether the CTE is recursive
+     * @returns Updated query state with CTE
+     */
+    withCte(name: string, query: SelectQueryNode, columns?: string[], recursive?: boolean): SelectQueryState;
+    /**
+     * Adds a set operation (UNION/UNION ALL/INTERSECT/EXCEPT) to the query
+     * @param operator - Set operator
+     * @param query - Right-hand side query
+     * @returns Updated query state with set operation
+     */
+    withSetOperation(operator: SetOperationKind, query: SelectQueryNode): SelectQueryState;
+    /**
+     * Replaces the FROM clause for the current query.
+     * @param from - Table source to use in the FROM clause
+     * @returns Updated query state with new FROM
+     */
+    withFrom(from: TableSourceNode): SelectQueryState;
+    /**
+     * Selects a subquery as a column
+     * @param alias - Alias for the subquery
+     * @param query - Subquery to select
+     * @returns Updated query state with subquery selection
+     */
+    selectSubquery(alias: string, query: SelectQueryNode): SelectQueryState;
+    /**
+     * Adds a JOIN clause to the query
+     * @param join - Join node to add
+     * @returns Updated query state with JOIN
+     */
+    withJoin(join: JoinNode): SelectQueryState;
+    /**
+     * Adds a WHERE clause to the query
+     * @param expr - Expression for the WHERE clause
+     * @returns Updated query state with WHERE clause
+     */
+    withWhere(expr: ExpressionNode): SelectQueryState;
+    /**
+     * Adds a GROUP BY clause to the query
+     * @param col - Column to group by
+     * @returns Updated query state with GROUP BY clause
+     */
+    withGroupBy(col: ColumnDef | ColumnNode): SelectQueryState;
+    /**
+     * Adds a HAVING clause to the query
+     * @param expr - Expression for the HAVING clause
+     * @returns Updated query state with HAVING clause
+     */
+    withHaving(expr: ExpressionNode): SelectQueryState;
+    /**
+     * Adds an ORDER BY clause to the query
+     * @param col - Column to order by
+     * @param direction - Order direction (ASC/DESC)
+     * @returns Updated query state with ORDER BY clause
+     */
+    withOrderBy(col: ColumnDef | ColumnNode, direction: OrderDirection): SelectQueryState;
+    /**
+     * Adds a DISTINCT clause to the query
+     * @param cols - Columns to make distinct
+     * @returns Updated query state with DISTINCT clause
+     */
+    withDistinct(cols: ColumnNode[]): SelectQueryState;
+    /**
+     * Adds a LIMIT clause to the query
+     * @param limit - Maximum number of rows to return
+     * @returns Updated query state with LIMIT clause
+     */
+    withLimit(limit: number): SelectQueryState;
+    /**
+     * Adds an OFFSET clause to the query
+     * @param offset - Number of rows to skip
+     * @returns Updated query state with OFFSET clause
+     */
+    withOffset(offset: number): SelectQueryState;
+    /**
+     * Combines expressions with AND operator
+     * @param existing - Existing expression
+     * @param next - New expression to combine
+     * @returns Combined expression
+     */
+    private combineExpressions;
+}
+
+/**
+ * Result of a relation operation
+ */
+interface RelationResult {
+    /**
+     * Updated query state
+     */
+    state: SelectQueryState;
+    /**
+     * Updated hydration manager
+     */
+    hydration: HydrationManager;
+}
+
+/**
+ * Join kinds allowed when including a relation using `.include(...)`.
+ */
+type RelationIncludeJoinKind = typeof JOIN_KINDS.LEFT | typeof JOIN_KINDS.INNER;
+/**
+ * Options for including a relation in a query
+ */
+interface RelationIncludeOptions {
+    columns?: string[];
+    aliasPrefix?: string;
+    filter?: ExpressionNode;
+    joinKind?: RelationIncludeJoinKind;
+    pivot?: {
+        columns?: string[];
+        aliasPrefix?: string;
+    };
+}
+
+/**
+ * Service for handling relation operations (joins, includes, etc.)
+ */
+declare class RelationService {
+    private readonly table;
+    private readonly state;
+    private readonly hydration;
+    private readonly createQueryAstService;
+    private readonly projectionHelper;
+    /**
+     * Creates a new RelationService instance
+     * @param table - Table definition
+     * @param state - Current query state
+     * @param hydration - Hydration manager
+     */
+    constructor(table: TableDef, state: SelectQueryState, hydration: HydrationManager, createQueryAstService: (table: TableDef, state: SelectQueryState) => QueryAstService);
+    /**
+     * Joins a relation to the query
+     * @param relationName - Name of the relation to join
+     * @param joinKind - Type of join to use
+     * @param extraCondition - Additional join condition
+     * @returns Relation result with updated state and hydration
+     */
+    joinRelation(relationName: string, joinKind: JoinKind, extraCondition?: ExpressionNode): RelationResult;
+    /**
+     * Matches records based on a relation with an optional predicate
+     * @param relationName - Name of the relation to match
+     * @param predicate - Optional predicate expression
+     * @returns Relation result with updated state and hydration
+     */
+    match(relationName: string, predicate?: ExpressionNode): RelationResult;
+    /**
+     * Includes a relation in the query result
+     * @param relationName - Name of the relation to include
+     * @param options - Options for relation inclusion
+     * @returns Relation result with updated state and hydration
+     */
+    include(relationName: string, options?: RelationIncludeOptions): RelationResult;
+    /**
+     * Applies relation correlation to a query AST
+     * @param relationName - Name of the relation
+     * @param ast - Query AST to modify
+     * @returns Modified query AST with relation correlation
+     */
+    applyRelationCorrelation(relationName: string, ast: SelectQueryNode, additionalCorrelation?: ExpressionNode): SelectQueryNode;
+    /**
+     * Creates a join node for a relation
+     * @param state - Current query state
+     * @param relationName - Name of the relation
+     * @param joinKind - Type of join to use
+     * @param extraCondition - Additional join condition
+     * @returns Updated query state with join
+     */
+    private withJoin;
+    /**
+     * Selects columns for a relation
+     * @param state - Current query state
+     * @param hydration - Hydration manager
+     * @param columns - Columns to select
+     * @returns Relation result with updated state and hydration
+     */
+    private selectColumns;
+    /**
+     * Gets a relation definition by name
+     * @param relationName - Name of the relation
+     * @returns Relation definition
+     * @throws Error if relation is not found
+     */
+    private getRelation;
+    /**
+     * Creates a QueryAstService instance
+     * @param state - Current query state
+     * @returns QueryAstService instance
+     */
+    private astService;
+    private rootTableName;
+}
+
+/**
+ * Dependencies for query builder operations
+ */
+interface SelectQueryBuilderDependencies {
+    /**
+     * Creates a new query state
+     * @param table - Table definition
+     * @returns New query state
+     */
+    createState: (table: TableDef) => SelectQueryState;
+    /**
+     * Creates a new hydration manager
+     * @param table - Table definition
+     * @returns New hydration manager
+     */
+    createHydration: (table: TableDef) => HydrationManager;
+    /**
+     * Creates a new hydration planner
+     * @param table - Table definition
+     * @returns Hydration planner
+     */
+    createHydrationPlanner: (table: TableDef) => HydrationPlanner;
+    /**
+     * Creates a new query AST service
+     * @param table - Table definition
+     * @param state - Query state
+     * @returns New query AST service
+     */
+    createQueryAstService: (table: TableDef, state: SelectQueryState) => QueryAstService;
+    /**
+     * Creates a new relation service
+     * @param table - Table definition
+     * @param state - Query state
+     * @param hydration - Hydration manager
+     * @returns New relation service
+     */
+    createRelationService: (table: TableDef, state: SelectQueryState, hydration: HydrationManager) => RelationService;
+}
+
+type QueryResult = {
+    columns: string[];
+    values: unknown[][];
+};
+interface DbExecutor {
+    executeSql(sql: string, params?: unknown[]): Promise<QueryResult[]>;
+    beginTransaction?(): Promise<void>;
+    commitTransaction?(): Promise<void>;
+    rollbackTransaction?(): Promise<void>;
+}
+/**
+ * Convert an array of row objects into a QueryResult.
+ */
+declare function rowsToQueryResult(rows: Array<Record<string, unknown>>): QueryResult;
 /**
- * Creates a LAST_VALUE window function
- * @param col - Column to get last value from
- * @returns Window function node for LAST_VALUE
+ * Minimal contract that most SQL clients can implement.
  */
-declare const lastValue: (col: ColumnRef | ColumnNode) => WindowFunctionNode;
+interface SimpleQueryRunner {
+    query(sql: string, params?: unknown[]): Promise<Array<Record<string, unknown>>>;
+    beginTransaction?(): Promise<void>;
+    commitTransaction?(): Promise<void>;
+    rollbackTransaction?(): Promise<void>;
+}
 /**
- * Creates a custom window function
- * @param name - Window function name
- * @param args - Function arguments
- * @param partitionBy - Optional PARTITION BY columns
- * @param orderBy - Optional ORDER BY clauses
- * @returns Window function node
+ * Generic factory: turn any SimpleQueryRunner into a DbExecutor.
  */
-declare const windowFunction: (name: string, args?: (ColumnRef | ColumnNode | LiteralNode | JsonPathNode)[], partitionBy?: (ColumnRef | ColumnNode)[], orderBy?: {
-    column: ColumnRef | ColumnNode;
-    direction: OrderDirection;
-}[]) => WindowFunctionNode;
+declare function createExecutorFromQueryRunner(runner: SimpleQueryRunner): DbExecutor;
+
+type EntityConstructor = new (...args: any[]) => any;
+type EntityOrTableTarget = EntityConstructor | TableDef;
+type EntityOrTableTargetResolver = EntityOrTableTarget | (() => EntityOrTableTarget);
 
 /**
- * Creates a COUNT function expression
- * @param col - Column to count
- * @returns Function node with COUNT
- */
-declare const count: (col: ColumnRef | ColumnNode) => FunctionNode;
+ * Entity status enum representing the lifecycle state of an entity
+ */
+declare enum EntityStatus {
+    /** Entity is newly created and not yet persisted */
+    New = "new",
+    /** Entity is managed by the ORM and synchronized with the database */
+    Managed = "managed",
+    /** Entity has been modified but not yet persisted */
+    Dirty = "dirty",
+    /** Entity has been marked for removal */
+    Removed = "removed",
+    /** Entity is detached from the ORM context */
+    Detached = "detached"
+}
 /**
- * Creates a SUM function expression
- * @param col - Column to sum
- * @returns Function node with SUM
- */
-declare const sum: (col: ColumnRef | ColumnNode) => FunctionNode;
+ * Represents an entity being tracked by the ORM
+ */
+interface TrackedEntity {
+    /** The table definition this entity belongs to */
+    table: TableDef;
+    /** The actual entity instance */
+    entity: any;
+    /** Primary key value of the entity */
+    pk: string | number | null;
+    /** Current status of the entity */
+    status: EntityStatus;
+    /** Original values of the entity when it was loaded */
+    original: Record<string, any> | null;
+}
 /**
- * Creates an AVG function expression
- * @param col - Column to average
- * @returns Function node with AVG
+ * Type representing a key for relation navigation
+ */
+type RelationKey = string;
+/**
+ * Represents a change operation on a relation
+ * @typeParam T - Type of the related entity
+ */
+type RelationChange<T> = {
+    kind: 'add';
+    entity: T;
+} | {
+    kind: 'attach';
+    entity: T;
+} | {
+    kind: 'remove';
+    entity: T;
+} | {
+    kind: 'detach';
+    entity: T;
+};
+/**
+ * Represents a relation change entry in the unit of work
+ */
+interface RelationChangeEntry {
+    /** Root entity that owns the relation */
+    root: any;
+    /** Key of the relation being changed */
+    relationKey: RelationKey;
+    /** Table definition of the root entity */
+    rootTable: TableDef;
+    /** Name of the relation */
+    relationName: string;
+    /** Relation definition */
+    relation: RelationDef;
+    /** The change being applied */
+    change: RelationChange<any>;
+}
+/**
+ * Represents a domain event that can be emitted by entities
+ * @typeParam TType - Type of the event (string literal)
  */
-declare const avg: (col: ColumnRef | ColumnNode) => FunctionNode;
+interface DomainEvent<TType extends string = string> {
+    /** Type identifier for the event */
+    readonly type: TType;
+    /** Timestamp when the event occurred */
+    readonly occurredAt?: Date;
+}
 /**
- * Creates a MIN function expression
- * @param col - Column to take the minimum of
- * @returns Function node with MIN
+ * Type representing any domain event
  */
-declare const min: (col: ColumnRef | ColumnNode) => FunctionNode;
+type AnyDomainEvent = DomainEvent<string>;
 /**
- * Creates a MAX function expression
- * @param col - Column to take the maximum of
- * @returns Function node with MAX
+ * Type representing ORM-specific domain events
  */
-declare const max: (col: ColumnRef | ColumnNode) => FunctionNode;
-type GroupConcatOrderByInput = {
-    column: ColumnRef | ColumnNode;
-    direction?: OrderDirection;
-};
-type GroupConcatOptions = {
-    separator?: ValueOperandInput;
-    orderBy?: GroupConcatOrderByInput[];
-};
+type OrmDomainEvent = AnyDomainEvent;
 /**
- * Aggregates grouped strings into a single value.
+ * Interface for entities that can emit domain events
+ * @typeParam E - Type of domain events this entity can emit
  */
-declare const groupConcat: (col: ColumnRef | ColumnNode, options?: GroupConcatOptions) => FunctionNode;
+interface HasDomainEvents<E extends DomainEvent = AnyDomainEvent> {
+    /** Array of domain events emitted by this entity */
+    domainEvents?: E[];
+}
 
 /**
- * Visitor for expression nodes
+ * Strategy interface for converting database names to TypeScript identifiers
  */
-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;
-    otherwise?(node: ExpressionNode): R;
+interface NamingStrategy {
+    /**
+     * Converts a table name to a TypeScript symbol name
+     * @param table - Table node, function table node, or name
+     * @returns Valid TypeScript identifier
+     */
+    tableToSymbol(table: TableSourceNode | string): string;
+    /**
+     * Converts a column reference to a property name
+     * @param column - Column node
+     * @returns Valid TypeScript property name
+     */
+    columnToProperty(column: ColumnNode): string;
+}
+
+interface QueryContext {
+    sql: string;
+    params: unknown[];
+}
+type QueryInterceptor = (ctx: QueryContext, next: () => Promise<QueryResult[]>) => Promise<QueryResult[]>;
+declare class InterceptorPipeline {
+    private interceptors;
+    use(interceptor: QueryInterceptor): void;
+    run(ctx: QueryContext, executor: DbExecutor): Promise<QueryResult[]>;
+}
+
+interface OrmOptions<E extends DomainEvent = OrmDomainEvent> {
+    dialect: Dialect;
+    executorFactory: DbExecutorFactory;
+    interceptors?: InterceptorPipeline;
+    namingStrategy?: NamingStrategy;
+}
+interface DbExecutorFactory {
+    createExecutor(options?: {
+        tx?: ExternalTransaction;
+    }): DbExecutor;
+    createTransactionalExecutor(): DbExecutor;
+}
+interface ExternalTransaction {
+}
+declare class Orm<E extends DomainEvent = OrmDomainEvent> {
+    readonly dialect: Dialect;
+    readonly interceptors: InterceptorPipeline;
+    readonly namingStrategy: NamingStrategy;
+    private readonly executorFactory;
+    constructor(opts: OrmOptions<E>);
+    createSession(options?: {
+        tx?: ExternalTransaction;
+    }): OrmSession<E>;
+    transaction<T>(fn: (session: OrmSession<E>) => Promise<T>): Promise<T>;
+}
+
+declare class IdentityMap {
+    private readonly buckets;
+    get bucketsMap(): Map<string, Map<string, TrackedEntity>>;
+    getEntity(table: TableDef, pk: string | number): any | undefined;
+    register(tracked: TrackedEntity): void;
+    remove(tracked: TrackedEntity): void;
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+    clear(): void;
+    private toIdentityKey;
+}
+
+declare class UnitOfWork {
+    private readonly dialect;
+    private readonly executor;
+    private readonly identityMap;
+    private readonly hookContext;
+    private readonly trackedEntities;
+    constructor(dialect: Dialect, executor: DbExecutor, identityMap: IdentityMap, hookContext: () => unknown);
+    get identityBuckets(): Map<string, Map<string, TrackedEntity>>;
+    getTracked(): TrackedEntity[];
+    getEntity(table: TableDef, pk: string | number): any | undefined;
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+    findTracked(entity: any): TrackedEntity | undefined;
+    setEntity(table: TableDef, pk: string | number, entity: any): void;
+    trackNew(table: TableDef, entity: any, pk?: string | number): void;
+    trackManaged(table: TableDef, pk: string | number, entity: any): void;
+    markDirty(entity: any): void;
+    markRemoved(entity: any): void;
+    flush(): Promise<void>;
+    reset(): void;
+    private flushInsert;
+    private flushUpdate;
+    private flushDelete;
+    private runHook;
+    private computeChanges;
+    private extractColumns;
+    private executeCompiled;
+    private getReturningColumns;
+    private applyReturningResults;
+    private normalizeColumnName;
+    private registerIdentity;
+    private createSnapshot;
+    private getPrimaryKeyValue;
+}
+
+type EventOfType<E extends DomainEvent, TType extends E['type']> = Extract<E, {
+    type: TType;
+}>;
+type DomainEventHandler<E extends DomainEvent, Context> = (event: E, ctx: Context) => Promise<void> | void;
+type InitialHandlers<E extends DomainEvent, Context> = {
+    [K in E['type']]?: DomainEventHandler<EventOfType<E, K>, Context>[];
+};
+declare class DomainEventBus<E extends DomainEvent, Context> {
+    private readonly handlers;
+    constructor(initialHandlers?: InitialHandlers<E, Context>);
+    on<TType extends E['type']>(type: TType, handler: DomainEventHandler<EventOfType<E, TType>, Context>): void;
+    register<TType extends E['type']>(type: TType, handler: DomainEventHandler<EventOfType<E, TType>, Context>): void;
+    dispatch(trackedEntities: Iterable<TrackedEntity>, ctx: Context): Promise<void>;
 }
+declare const addDomainEvent: <E extends DomainEvent>(entity: HasDomainEvents<E>, event: E) => void;
+
+declare class RelationChangeProcessor {
+    private readonly unitOfWork;
+    private readonly dialect;
+    private readonly executor;
+    private readonly relationChanges;
+    constructor(unitOfWork: UnitOfWork, dialect: Dialect, executor: DbExecutor);
+    registerChange(entry: RelationChangeEntry): void;
+    reset(): void;
+    process(): Promise<void>;
+    private handleHasManyChange;
+    private handleHasOneChange;
+    private handleBelongsToChange;
+    private handleBelongsToManyChange;
+    private assignHasManyForeignKey;
+    private detachHasManyChild;
+    private assignHasOneForeignKey;
+    private detachHasOneChild;
+    private insertPivotRow;
+    private deletePivotRow;
+    private resolvePrimaryKeyValue;
+}
+
 /**
- * Visitor for operand nodes
+ * Represents a single SQL query log entry
  */
-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;
-    otherwise?(node: OperandNode): R;
+interface QueryLogEntry {
+    /** The SQL query that was executed */
+    sql: string;
+    /** Parameters used in the query */
+    params?: unknown[];
 }
-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.
+ * Function type for query logging callbacks
+ * @param entry - The query log entry to process
  */
-declare const registerExpressionDispatcher: (type: string, dispatcher: ExpressionDispatch) => void;
+type QueryLogger = (entry: QueryLogEntry) => void;
 /**
- * Registers a dispatcher for a custom operand node type.
- * Allows new node kinds without modifying the core switch.
+ * Creates a wrapped database executor that logs all SQL queries
+ * @param executor - Original database executor to wrap
+ * @param logger - Optional logger function to receive query log entries
+ * @returns Wrapped executor that logs queries before execution
  */
-declare const registerOperandDispatcher: (type: string, dispatcher: OperandDispatch) => void;
+declare const createQueryLoggingExecutor: (executor: DbExecutor, logger?: QueryLogger) => DbExecutor;
+
 /**
- * Clears all registered dispatchers. Primarily for tests.
+ * Context for SQL query execution
  */
-declare const clearExpressionDispatchers: () => void;
-declare const clearOperandDispatchers: () => void;
+interface ExecutionContext {
+    /** Database dialect to use for SQL generation */
+    dialect: Dialect;
+    /** Database executor for running SQL queries */
+    executor: DbExecutor;
+    /** Interceptor pipeline for query processing */
+    interceptors: InterceptorPipeline;
+}
+
+interface EntityContext {
+    dialect: Dialect;
+    executor: DbExecutor;
+    getEntity(table: TableDef, pk: any): any;
+    setEntity(table: TableDef, pk: any, entity: any): void;
+    trackNew(table: TableDef, entity: any, pk?: any): void;
+    trackManaged(table: TableDef, pk: any, entity: any): void;
+    markDirty(entity: any): void;
+    markRemoved(entity: any): void;
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+    registerRelationChange(root: any, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<any>): void;
+}
+
+interface HydrationContext<E extends DomainEvent = AnyDomainEvent> {
+    identityMap: IdentityMap;
+    unitOfWork: UnitOfWork;
+    domainEvents: DomainEventBus<E, OrmSession<E>>;
+    relationChanges: RelationChangeProcessor;
+    entityContext: EntityContext;
+}
+
+interface OrmInterceptor {
+    beforeFlush?(ctx: EntityContext): Promise<void> | void;
+    afterFlush?(ctx: EntityContext): Promise<void> | void;
+}
+interface OrmSessionOptions<E extends DomainEvent = OrmDomainEvent> {
+    orm: Orm<E>;
+    executor: DbExecutor;
+    queryLogger?: QueryLogger;
+    interceptors?: OrmInterceptor[];
+    domainEventHandlers?: InitialHandlers<E, OrmSession<E>>;
+}
+declare class OrmSession<E extends DomainEvent = OrmDomainEvent> implements EntityContext {
+    readonly orm: Orm<E>;
+    readonly executor: DbExecutor;
+    readonly identityMap: IdentityMap;
+    readonly unitOfWork: UnitOfWork;
+    readonly domainEvents: DomainEventBus<E, OrmSession<E>>;
+    readonly relationChanges: RelationChangeProcessor;
+    private readonly interceptors;
+    constructor(opts: OrmSessionOptions<E>);
+    get dialect(): Dialect;
+    get identityBuckets(): Map<string, Map<string, TrackedEntity>>;
+    get tracked(): TrackedEntity[];
+    getEntity(table: TableDef, pk: any): any | undefined;
+    setEntity(table: TableDef, pk: any, entity: any): void;
+    trackNew(table: TableDef, entity: any, pk?: any): void;
+    trackManaged(table: TableDef, pk: any, entity: any): void;
+    markDirty(entity: any): void;
+    markRemoved(entity: any): void;
+    registerRelationChange: (root: any, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<any>) => void;
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+    registerInterceptor(interceptor: OrmInterceptor): void;
+    registerDomainEventHandler<TType extends E['type']>(type: TType, handler: DomainEventHandler<Extract<E, {
+        type: TType;
+    }>, OrmSession<E>>): void;
+    find<TTable extends TableDef>(entityClass: EntityConstructor, id: any): Promise<EntityInstance<TTable> | null>;
+    findOne<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<EntityInstance<TTable> | null>;
+    findMany<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<EntityInstance<TTable>[]>;
+    persist(entity: object): Promise<void>;
+    remove(entity: object): Promise<void>;
+    flush(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    getExecutionContext(): ExecutionContext;
+    getHydrationContext(): HydrationContext<E>;
+}
+
+type SelectDialectInput = Dialect | DialectKey;
+
+type ColumnSelectionValue = ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode;
+type DeepSelectConfig<TTable extends TableDef> = {
+    root?: (keyof TTable['columns'] & string)[];
+} & {
+    [K in keyof TTable['relations'] & string]?: (keyof RelationTargetTable<TTable['relations'][K]>['columns'] & string)[];
+};
+type WhereHasOptions = {
+    correlate?: ExpressionNode;
+};
+type RelationCallback = <TChildTable extends TableDef>(qb: SelectQueryBuilder<any, TChildTable>) => SelectQueryBuilder<any, TChildTable>;
 /**
- * Dispatches an expression node to the visitor
- * @param node - Expression node to visit
- * @param visitor - Visitor implementation
+
+ * Main query builder class for constructing SQL SELECT queries
+
+ * @typeParam T - Result type for projections (unused)
+
+ * @typeParam TTable - Table definition being queried
+
  */
-declare const visitExpression: <R>(node: ExpressionNode, visitor: ExpressionVisitor<R>) => R;
+declare class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
+    private readonly env;
+    private readonly context;
+    private readonly columnSelector;
+    private readonly relationManager;
+    private readonly lazyRelations;
+    /**
+  
+     * Creates a new SelectQueryBuilder instance
+  
+     * @param table - Table definition to query
+  
+     * @param state - Optional initial query state
+  
+     * @param hydration - Optional hydration manager
+  
+     * @param dependencies - Optional query builder dependencies
+  
+     */
+    constructor(table: TTable, state?: SelectQueryState, hydration?: HydrationManager, dependencies?: Partial<SelectQueryBuilderDependencies>, lazyRelations?: Set<string>);
+    private clone;
+    /**
+     * Applies an alias to the root FROM table.
+     * @param alias - Alias to apply
+     */
+    as(alias: string): SelectQueryBuilder<T, TTable>;
+    private resolveQueryNode;
+    private applyCorrelation;
+    private createChildBuilder;
+    private applyAst;
+    private applyJoin;
+    private applySetOperation;
+    /**
+  
+     * Selects specific columns for the query
+  
+     * @param columns - Record of column definitions, function nodes, case expressions, or window functions
+  
+     * @returns New query builder instance with selected columns
+  
+     */
+    select(columns: Record<string, ColumnSelectionValue>): SelectQueryBuilder<T, TTable>;
+    /**
+     * Selects columns from the root table by name (typed).
+     * @param cols - Column names on the root table
+     */
+    selectColumns<K extends keyof TTable['columns'] & string>(...cols: K[]): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Selects raw column expressions
+  
+     * @param cols - Column expressions as strings
+  
+     * @returns New query builder instance with raw column selections
+  
+     */
+    selectRaw(...cols: string[]): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds a Common Table Expression (CTE) to the query
+  
+     * @param name - Name of the CTE
+  
+     * @param query - Query builder or query node for the CTE
+  
+     * @param columns - Optional column names for the CTE
+  
+     * @returns New query builder instance with the CTE
+  
+     */
+    with(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds a recursive Common Table Expression (CTE) to the query
+  
+     * @param name - Name of the CTE
+  
+     * @param query - Query builder or query node for the CTE
+  
+     * @param columns - Optional column names for the CTE
+  
+     * @returns New query builder instance with the recursive CTE
+  
+     */
+    withRecursive(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable>;
+    /**
+     * Replaces the FROM clause with a derived table (subquery with alias)
+     * @param subquery - Subquery to use as the FROM source
+     * @param alias - Alias for the derived table
+     * @param columnAliases - Optional column alias list
+     * @returns New query builder instance with updated FROM
+     */
+    fromSubquery(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, alias: string, columnAliases?: string[]): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Selects a subquery as a column
+  
+     * @param alias - Alias for the subquery column
+  
+     * @param sub - Query builder or query node for the subquery
+  
+     * @returns New query builder instance with the subquery selection
+  
+     */
+    selectSubquery(alias: string, sub: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
+    /**
+     * Adds a JOIN against a derived table (subquery with alias)
+     * @param subquery - Subquery to join
+     * @param alias - Alias for the derived table
+     * @param condition - Join condition expression
+     * @param joinKind - Join kind (defaults to INNER)
+     * @param columnAliases - Optional column alias list for the derived table
+     * @returns New query builder instance with the derived-table join
+     */
+    joinSubquery(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, alias: string, condition: BinaryExpressionNode, joinKind?: JoinKind, columnAliases?: string[]): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds an INNER JOIN to the query
+  
+     * @param table - Table to join
+  
+     * @param condition - Join condition expression
+  
+     * @returns New query builder instance with the INNER JOIN
+  
+     */
+    innerJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds a LEFT JOIN to the query
+  
+     * @param table - Table to join
+  
+     * @param condition - Join condition expression
+  
+     * @returns New query builder instance with the LEFT JOIN
+  
+     */
+    leftJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds a RIGHT JOIN to the query
+  
+     * @param table - Table to join
+  
+     * @param condition - Join condition expression
+  
+     * @returns New query builder instance with the RIGHT JOIN
+  
+     */
+    rightJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Matches records based on a relationship
+  
+     * @param relationName - Name of the relationship to match
+  
+     * @param predicate - Optional predicate expression
+  
+     * @returns New query builder instance with the relationship match
+  
+     */
+    match(relationName: string, predicate?: ExpressionNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Joins a related table
+  
+     * @param relationName - Name of the relationship to join
+  
+     * @param joinKind - Type of join (defaults to INNER)
+  
+     * @param extraCondition - Optional additional join condition
+  
+     * @returns New query builder instance with the relationship join
+  
+     */
+    joinRelation(relationName: string, joinKind?: JoinKind, extraCondition?: ExpressionNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Includes related data in the query results
+  
+     * @param relationName - Name of the relationship to include
+  
+     * @param options - Optional include options
+  
+     * @returns New query builder instance with the relationship inclusion
+  
+     */
+    include(relationName: string, options?: RelationIncludeOptions): SelectQueryBuilder<T, TTable>;
+    includeLazy<K extends keyof RelationMap<TTable>>(relationName: K): SelectQueryBuilder<T, TTable>;
+    /**
+     * Selects columns for a related table in a single hop.
+     */
+    selectRelationColumns<K extends keyof TTable['relations'] & string, TRel extends RelationDef = TTable['relations'][K], TTarget extends TableDef = RelationTargetTable<TRel>, C extends keyof TTarget['columns'] & string = keyof TTarget['columns'] & string>(relationName: K, ...cols: C[]): SelectQueryBuilder<T, TTable>;
+    /**
+     * Convenience alias for selecting specific columns from a relation.
+     */
+    includePick<K extends keyof TTable['relations'] & string, TRel extends RelationDef = TTable['relations'][K], TTarget extends TableDef = RelationTargetTable<TRel>, C extends keyof TTarget['columns'] & string = keyof TTarget['columns'] & string>(relationName: K, cols: C[]): SelectQueryBuilder<T, TTable>;
+    /**
+     * Selects columns for the root table and relations from a single config object.
+     */
+    selectColumnsDeep(config: DeepSelectConfig<TTable>): SelectQueryBuilder<T, TTable>;
+    getLazyRelations(): (keyof RelationMap<TTable>)[];
+    getTable(): TTable;
+    execute(ctx: OrmSession): Promise<EntityInstance<TTable>[]>;
+    executeWithContexts(execCtx: ExecutionContext, hydCtx: HydrationContext): Promise<EntityInstance<TTable>[]>;
+    /**
+  
+     * Adds a WHERE condition to the query
+  
+     * @param expr - Expression for the WHERE clause
+  
+     * @returns New query builder instance with the WHERE condition
+  
+     */
+    where(expr: ExpressionNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds a GROUP BY clause to the query
+  
+     * @param col - Column definition or column node to group by
+  
+     * @returns New query builder instance with the GROUP BY clause
+  
+     */
+    groupBy(col: ColumnDef | ColumnNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds a HAVING condition to the query
+  
+     * @param expr - Expression for the HAVING clause
+  
+     * @returns New query builder instance with the HAVING condition
+  
+     */
+    having(expr: ExpressionNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds an ORDER BY clause to the query
+  
+     * @param col - Column definition or column node to order by
+  
+     * @param direction - Order direction (defaults to ASC)
+  
+     * @returns New query builder instance with the ORDER BY clause
+  
+     */
+    orderBy(col: ColumnDef | ColumnNode, direction?: OrderDirection): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds a DISTINCT clause to the query
+  
+     * @param cols - Columns to make distinct
+  
+     * @returns New query builder instance with the DISTINCT clause
+  
+     */
+    distinct(...cols: (ColumnDef | ColumnNode)[]): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds a LIMIT clause to the query
+  
+     * @param n - Maximum number of rows to return
+  
+     * @returns New query builder instance with the LIMIT clause
+  
+     */
+    limit(n: number): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds an OFFSET clause to the query
+  
+     * @param n - Number of rows to skip
+  
+     * @returns New query builder instance with the OFFSET clause
+  
+     */
+    offset(n: number): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Combines this query with another using UNION
+  
+     * @param query - Query to union with
+  
+     * @returns New query builder instance with the set operation
+  
+     */
+    union(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Combines this query with another using UNION ALL
+  
+     * @param query - Query to union with
+  
+     * @returns New query builder instance with the set operation
+  
+     */
+    unionAll(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Combines this query with another using INTERSECT
+  
+     * @param query - Query to intersect with
+  
+     * @returns New query builder instance with the set operation
+  
+     */
+    intersect(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Combines this query with another using EXCEPT
+  
+     * @param query - Query to subtract
+  
+     * @returns New query builder instance with the set operation
+  
+     */
+    except(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds a WHERE EXISTS condition to the query
+  
+     * @param subquery - Subquery to check for existence
+  
+     * @returns New query builder instance with the WHERE EXISTS condition
+  
+     */
+    whereExists(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, correlate?: ExpressionNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds a WHERE NOT EXISTS condition to the query
+  
+     * @param subquery - Subquery to check for non-existence
+  
+     * @returns New query builder instance with the WHERE NOT EXISTS condition
+  
+     */
+    whereNotExists(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, correlate?: ExpressionNode): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds a WHERE EXISTS condition based on a relationship
+  
+     * @param relationName - Name of the relationship to check
+  
+     * @param callback - Optional callback to modify the relationship query
+  
+     * @returns New query builder instance with the relationship existence check
+  
+     */
+    whereHas(relationName: string, callbackOrOptions?: RelationCallback | WhereHasOptions, maybeOptions?: WhereHasOptions): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Adds a WHERE NOT EXISTS condition based on a relationship
+  
+     * @param relationName - Name of the relationship to check
+  
+     * @param callback - Optional callback to modify the relationship query
+  
+     * @returns New query builder instance with the relationship non-existence check
+  
+     */
+    whereHasNot(relationName: string, callbackOrOptions?: RelationCallback | WhereHasOptions, maybeOptions?: WhereHasOptions): SelectQueryBuilder<T, TTable>;
+    /**
+  
+     * Compiles the query to SQL for a specific dialect
+  
+     * @param dialect - Database dialect to compile for
+  
+     * @returns Compiled query with SQL and parameters
+  
+     */
+    compile(dialect: SelectDialectInput): CompiledQuery;
+    /**
+  
+     * Converts the query to SQL string for a specific dialect
+  
+     * @param dialect - Database dialect to generate SQL for
+  
+     * @returns SQL string representation of the query
+  
+     */
+    toSql(dialect: SelectDialectInput): string;
+    /**
+  
+     * Gets the hydration plan for the query
+  
+     * @returns Hydration plan or undefined if none exists
+  
+     */
+    getHydrationPlan(): HydrationPlan | undefined;
+    /**
+  
+     * Gets the Abstract Syntax Tree (AST) representation of the query
+  
+     * @returns Query AST with hydration applied
+  
+     */
+    getAST(): SelectQueryNode;
+}
 /**
- * Dispatches an operand node to the visitor
- * @param node - Operand node to visit
- * @param visitor - Visitor implementation
- */
-declare const visitOperand: <R>(node: OperandNode, visitor: OperandVisitor<R>) => R;
 
-/**
- * Adapts a schema ColumnDef to an AST-friendly ColumnRef.
+ * Creates a column node for use in expressions
+
+ * @param table - Table name
+
+ * @param name - Column name
+
+ * @returns ColumnNode with the specified table and name
+
  */
-declare const toColumnRef: (col: ColumnRef | ColumnDef) => ColumnRef;
+declare const createColumn: (table: string, name: string) => ColumnNode;
 /**
- * Adapts a schema TableDef to an AST-friendly TableRef.
+
+ * Creates a literal value node for use in expressions
+
+ * @param val - Literal value (string or number)
+
+ * @returns LiteralNode with the specified value
+
  */
-declare const toTableRef: (table: TableRef | TableDef) => TableRef;
+declare const createLiteral: (val: string | number) => LiteralNode;
 
 /**
  * Build a typed selection map from a TableDef.
@@ -1198,8 +3618,8 @@ declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandV
     private mapOp;
 }
 
-declare const createEntityProxy: <TTable extends TableDef, TLazy extends keyof RelationMap<TTable> = keyof RelationMap<TTable>>(ctx: EntityContext, table: TTable, row: Record<string, any>, lazyRelations?: TLazy[]) => Entity<TTable>;
-declare const createEntityFromRow: <TTable extends TableDef>(ctx: EntityContext, table: TTable, row: Record<string, any>, lazyRelations?: (keyof RelationMap<TTable>)[]) => Entity<TTable>;
+declare const createEntityProxy: <TTable extends TableDef, TLazy extends keyof RelationMap<TTable> = keyof RelationMap<TTable>>(ctx: EntityContext, table: TTable, row: Record<string, any>, lazyRelations?: TLazy[]) => EntityInstance<TTable>;
+declare const createEntityFromRow: <TTable extends TableDef>(ctx: EntityContext, table: TTable, row: Record<string, any>, lazyRelations?: (keyof RelationMap<TTable>)[]) => EntityInstance<TTable>;
 
 type Rows$3 = Record<string, any>[];
 declare const loadHasManyRelation: (ctx: EntityContext, rootTable: TableDef, _relationName: string, relation: HasManyRelation) => Promise<Map<string, Rows$3>>;
@@ -1302,8 +3722,75 @@ declare class DefaultManyToManyCollection<TTarget> implements ManyToManyCollecti
     toJSON(): TTarget[];
 }
 
-declare function executeHydrated<TTable extends TableDef>(session: OrmSession, qb: SelectQueryBuilder<any, TTable>): Promise<Entity<TTable>[]>;
-declare function executeHydratedWithContexts<TTable extends TableDef>(_execCtx: ExecutionContext, hydCtx: HydrationContext, qb: SelectQueryBuilder<any, TTable>): Promise<Entity<TTable>[]>;
+declare function executeHydrated<TTable extends TableDef>(session: OrmSession, qb: SelectQueryBuilder<any, TTable>): Promise<EntityInstance<TTable>[]>;
+declare function executeHydratedWithContexts<TTable extends TableDef>(_execCtx: ExecutionContext, hydCtx: HydrationContext, qb: SelectQueryBuilder<any, TTable>): Promise<EntityInstance<TTable>[]>;
+
+interface StandardDecoratorContext {
+    kind: string;
+    name?: string | symbol;
+    metadata?: Record<PropertyKey, unknown>;
+    addInitializer?(initializer: (this: unknown) => void): void;
+    static?: boolean;
+    private?: boolean;
+}
+interface DualModePropertyDecorator {
+    (target: object, propertyKey: string | symbol): void;
+    (value: unknown, context: StandardDecoratorContext): void;
+}
+interface DualModeClassDecorator {
+    <TFunction extends Function>(value: TFunction): void | TFunction;
+    <TFunction extends Function>(value: TFunction, context: StandardDecoratorContext): void | TFunction;
+}
+
+interface EntityOptions {
+    tableName?: string;
+    hooks?: TableHooks;
+}
+declare function Entity(options?: EntityOptions): DualModeClassDecorator;
+
+interface ColumnOptions {
+    type: ColumnType;
+    args?: ColumnDef['args'];
+    notNull?: boolean;
+    primary?: boolean;
+}
+type ColumnInput = ColumnOptions | ColumnDef;
+declare function Column(definition: ColumnInput): DualModePropertyDecorator;
+declare function PrimaryKey(definition: ColumnInput): DualModePropertyDecorator;
+
+interface BaseRelationOptions {
+    target: EntityOrTableTargetResolver;
+    cascade?: CascadeMode;
+    localKey?: string;
+}
+interface HasManyOptions extends BaseRelationOptions {
+    foreignKey: string;
+}
+interface HasOneOptions extends BaseRelationOptions {
+    foreignKey: string;
+}
+interface BelongsToOptions extends BaseRelationOptions {
+    foreignKey: string;
+}
+interface BelongsToManyOptions {
+    target: EntityOrTableTargetResolver;
+    pivotTable: EntityOrTableTargetResolver;
+    pivotForeignKeyToRoot: string;
+    pivotForeignKeyToTarget: string;
+    localKey?: string;
+    targetKey?: string;
+    pivotPrimaryKey?: string;
+    defaultPivotColumns?: string[];
+    cascade?: CascadeMode;
+}
+declare function HasMany(options: HasManyOptions): DualModePropertyDecorator;
+declare function HasOne(options: HasOneOptions): DualModePropertyDecorator;
+declare function BelongsTo(options: BelongsToOptions): DualModePropertyDecorator;
+declare function BelongsToMany(options: BelongsToManyOptions): DualModePropertyDecorator;
+
+declare const bootstrapEntities: () => TableDef[];
+declare const getTableDefFromEntity: (ctor: EntityConstructor) => TableDef | undefined;
+declare const selectFromEntity: <TTable extends TableDef>(ctor: EntityConstructor) => SelectQueryBuilder<any, TTable>;
 
 interface PostgresClientLike {
     query(text: string, params?: unknown[]): Promise<{
@@ -1376,4 +3863,4 @@ interface CreateTediousClientOptions {
 declare function createTediousMssqlClient(connection: TediousConnectionLike, { Request, TYPES }: TediousModule, options?: CreateTediousClientOptions): MssqlClientLike;
 declare function createTediousExecutor(connection: TediousConnectionLike, module: TediousModule, options?: CreateTediousClientOptions): DbExecutor;
 
-export { AsyncLocalStorage, BelongsToManyRelation, BelongsToReference, BelongsToRelation, BetweenExpressionNode, BinaryExpressionNode, CaseExpressionNode, ColumnDef, type ColumnDiff, ColumnNode, ColumnRef, type CreateTediousClientOptions, type DatabaseCheck, type DatabaseColumn, type DatabaseIndex, type DatabaseSchema, type DatabaseTable, DbExecutor, DefaultBelongsToReference, DefaultHasManyCollection, DefaultManyToManyCollection, DeleteQueryBuilder, type DialectName, Entity, EntityContext, ExecutionContext, ExistsExpressionNode, ExpressionNode, type ExpressionVisitor, ForeignKeyReference, FunctionNode, type GroupConcatOptions, HasManyCollection, HasManyRelation, HasOneRelation, HydrationContext, HydrationPlan, InExpressionNode, IndexColumn, IndexDef, InsertQueryBuilder, type IntrospectOptions, JsonPathNode, LiteralNode, type LiteralValue, LogicalExpressionNode, ManyToManyCollection, type MssqlClientLike, MySqlDialect, type MysqlClientLike, NullExpressionNode, OperandNode, type OperandVisitor, OrmSession, 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, type TediousColumn, type TediousConnectionLike, type TediousModule, type TediousRequest, type TediousRequestCtor, type TediousTypes, TypeScriptGenerator, UpdateQueryBuilder, type ValueOperandInput, WindowFunctionNode, abs, acos, and, ascii, asin, atan, atan2, avg, between, caseWhen, ceil, ceiling, char, charLength, clearExpressionDispatchers, clearOperandDispatchers, columnOperand, concat, concatWs, correlateBy, cos, cot, count, createEntityFromRow, createEntityProxy, createMssqlExecutor, createMysqlExecutor, createPostgresExecutor, createSqliteExecutor, createTediousExecutor, createTediousMssqlClient, currentDate, currentTime, dateAdd, dateDiff, dateFormat, dateSub, dateTrunc, day, dayOfWeek, degrees, denseRank, diffSchema, endOfMonth, eq, esel, executeHydrated, executeHydratedWithContexts, exists, exp, extract, firstValue, floor, fromUnixTime, generateCreateTableSql, generateSchemaSql, getSchemaIntrospector, groupConcat, gt, gte, hydrateRows, inList, instr, introspectSchema, isNotNull, isNull, isValueOperandInput, jsonPath, lag, lastValue, lead, left, length, like, ln, loadBelongsToManyRelation, loadBelongsToRelation, loadHasManyRelation, loadHasOneRelation, locate, log, log10, logBase, lower, lpad, lt, lte, ltrim, max, min, mod, month, neq, notBetween, notExists, notInList, notLike, now, ntile, or, outerRef, pi, position, pow, power, radians, rand, random, rank, registerExpressionDispatcher, registerOperandDispatcher, registerSchemaIntrospector, renderColumnDefinition, repeat, replace, right, round, rowNumber, rpad, rtrim, sel, sign, sin, space, sqrt, substr, sum, synchronizeSchema, tan, toColumnRef, toTableRef, trim, trunc, truncate, unixTimestamp, upper, utcNow, valueToOperand, visitExpression, visitOperand, weekOfYear, windowFunction, year };
+export { type AnyDomainEvent, AsyncLocalStorage, BelongsTo, BelongsToMany, type BelongsToManyOptions, type BelongsToManyRelation, type BelongsToOptions, type BelongsToReference, type BelongsToRelation, type BetweenExpressionNode, type BinaryExpressionNode, type CascadeMode, type CaseExpressionNode, type CheckConstraint, Column, type ColumnDef, type ColumnDiff, type ColumnInput, type ColumnNode, type ColumnOptions, type ColumnRef, type ColumnToTs, type ColumnType, type CreateTediousClientOptions, type DatabaseCheck, type DatabaseColumn, type DatabaseIndex, type DatabaseSchema, type DatabaseTable, type DbExecutor, type DbExecutorFactory, DefaultBelongsToReference, DefaultHasManyCollection, DefaultManyToManyCollection, type DefaultValue, DeleteQueryBuilder, type DialectName, type DomainEvent, DomainEventBus, type DomainEventHandler, Entity, type EntityContext, type EntityInstance, type EntityOptions, EntityStatus, type ExecutionContext, type ExistsExpressionNode, type ExpressionNode, type ExpressionVisitor, type ExternalTransaction, type ForeignKeyReference, type FunctionNode, type GroupConcatOptions, type HasDomainEvents, HasMany, type HasManyCollection, type HasManyOptions, type HasManyRelation, HasOne, type HasOneOptions, type HasOneReference, type HasOneRelation, type HydrationContext, type HydrationMetadata, type HydrationPivotPlan, type HydrationPlan, type HydrationRelationPlan, type InExpressionNode, type IndexColumn, type IndexDef, type InferRow, type InitialHandlers, InsertQueryBuilder, type IntrospectOptions, type JsonPathNode, type LiteralNode, type LiteralValue, type LogicalExpressionNode, type ManyToManyCollection, type MssqlClientLike, MySqlDialect, type MysqlClientLike, type NullExpressionNode, type OperandNode, type OperandVisitor, Orm, type OrmDomainEvent, type OrmInterceptor, type OrmOptions, OrmSession, type OrmSessionOptions, type PostgresClientLike, PostgresDialect, PrimaryKey, type QueryLogEntry, type QueryLogger, type QueryResult, type RawDefaultValue, type ReferentialAction, type RelationChange, type RelationChangeEntry, type RelationDef, type RelationKey, RelationKinds, type RelationMap, type RelationTargetTable, type RelationType, type RenderColumnOptions, type ScalarSubqueryNode, type SchemaChange, type SchemaChangeKind, type SchemaDiffOptions, type SchemaGenerateResult, type SchemaIntrospector, type SchemaPlan, SelectQueryBuilder, type SimpleQueryRunner, SqlServerDialect, type SqliteClientLike, SqliteDialect, type SynchronizeOptions, type TableDef, type TableHooks, type TableOptions, type TableRef, type TediousColumn, type TediousConnectionLike, type TediousModule, type TediousRequest, type TediousRequestCtor, type TediousTypes, type TrackedEntity, TypeScriptGenerator, UpdateQueryBuilder, type ValueOperandInput, type WindowFunctionNode, abs, acos, addDomainEvent, and, ascii, asin, atan, atan2, avg, belongsTo, belongsToMany, between, bootstrapEntities, caseWhen, ceil, ceiling, char, charLength, clearExpressionDispatchers, clearOperandDispatchers, col, columnOperand, concat, concatWs, correlateBy, cos, cot, count, createColumn, createEntityFromRow, createEntityProxy, createExecutorFromQueryRunner, createLiteral, createMssqlExecutor, createMysqlExecutor, createPostgresExecutor, createQueryLoggingExecutor, createSqliteExecutor, createTediousExecutor, createTediousMssqlClient, currentDate, currentTime, dateAdd, dateDiff, dateFormat, dateSub, dateTrunc, day, dayOfWeek, defineTable, degrees, denseRank, diffSchema, endOfMonth, eq, esel, executeHydrated, executeHydratedWithContexts, exists, exp, extract, firstValue, floor, fromUnixTime, generateCreateTableSql, generateSchemaSql, getSchemaIntrospector, getTableDefFromEntity, groupConcat, gt, gte, hasMany, hasOne, hydrateRows, inList, instr, introspectSchema, isCaseExpressionNode, isExpressionSelectionNode, isFunctionNode, isNotNull, isNull, isOperandNode, isValueOperandInput, isWindowFunctionNode, jsonPath, lag, lastValue, lead, left, length, like, ln, loadBelongsToManyRelation, loadBelongsToRelation, loadHasManyRelation, loadHasOneRelation, locate, log, log10, logBase, lower, lpad, lt, lte, ltrim, max, min, mod, month, neq, notBetween, notExists, notInList, notLike, now, ntile, or, outerRef, pi, position, pow, power, radians, rand, random, rank, registerExpressionDispatcher, registerOperandDispatcher, registerSchemaIntrospector, renderColumnDefinition, repeat, replace, right, round, rowNumber, rowsToQueryResult, rpad, rtrim, sel, selectFromEntity, sign, sin, space, sqrt, substr, sum, synchronizeSchema, tan, toColumnRef, toTableRef, trim, trunc, truncate, unixTimestamp, upper, utcNow, valueToOperand, visitExpression, visitOperand, weekOfYear, windowFunction, year };