metal-orm 1.0.42 → 1.0.44

package/dist/index.d.cts

@@ -50,7 +50,7 @@ interface ColumnDef<T extends ColumnType = ColumnType, TRuntime = unknown> {
     /** Column comment/description */
     comment?: string;
     /** Additional arguments for the column type (e.g., VARCHAR length) */
-    args?: any[];
+    args?: unknown[];
     /** Table name this column belongs to (filled at runtime by defineTable) */
     table?: string;
 }
@@ -312,12 +312,12 @@ interface TableOptions {
     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;
+    beforeInsert?(ctx: unknown, entity: unknown): Promise<void> | void;
+    afterInsert?(ctx: unknown, entity: unknown): Promise<void> | void;
+    beforeUpdate?(ctx: unknown, entity: unknown): Promise<void> | void;
+    afterUpdate?(ctx: unknown, entity: unknown): Promise<void> | void;
+    beforeDelete?(ctx: unknown, entity: unknown): Promise<void> | void;
+    afterDelete?(ctx: unknown, entity: unknown): Promise<void> | void;
 }
 /**
  * Definition of a database table with its columns and relationships
@@ -386,6 +386,22 @@ type TableRef$1<T extends TableDef> = T & {
  *   t.$.name is the "name" column (escape hatch)
  */
 declare const tableRef: <T extends TableDef>(table: T) => TableRef$1<T>;
+/**
+ * Public API: dynamic column lookup by string key.
+ *
+ * Useful when the column name is only known at runtime, or when a column name
+ * collides with a real table field (e.g. "name").
+ *
+ * @example
+ * ```ts
+ * const t = tableRef(todos);
+ * const key = runtimeKey();
+ * where(eq(getColumn(t, key), 123));
+ * // or: t.$.name (escape hatch)
+ * ```
+ */
+declare function getColumn<T extends TableDef, K extends keyof T['columns'] & string>(table: T, key: K): T['columns'][K];
+declare function getColumn<T extends TableDef>(table: T, key: string): ColumnDef;
 
 /**
  * Resolves a relation definition to its target table type.
@@ -404,7 +420,7 @@ 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;
+    _pivot?: unknown;
 })[] : never;
 /**
  * Maps relation names to the expected row results
@@ -673,10 +689,10 @@ interface ArithmeticExpressionNode {
  * Union type representing any operand that can be used in expressions
  */
 type OperandNode = AliasRefNode | 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 isOperandNode: (node: unknown) => node is OperandNode;
+declare const isFunctionNode: (node: unknown) => node is FunctionNode;
+declare const isCaseExpressionNode: (node: unknown) => node is CaseExpressionNode;
+declare const isWindowFunctionNode: (node: unknown) => 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)
@@ -765,6 +781,12 @@ declare const isValueOperandInput: (value: unknown) => value is ValueOperandInpu
 type SelectQueryInput = SelectQueryNode | {
     getAST(): SelectQueryNode;
 };
+/**
+ * Converts a ColumnRef or ColumnNode to a ColumnNode
+ * @param col - Column reference or node
+ * @returns ColumnNode
+ * @throws Error if ColumnRef doesn't have a table specified
+ */
 declare const columnOperand: (col: ColumnRef | ColumnNode) => ColumnNode;
 /**
  * Marks a column reference as an outer-scope reference for correlated subqueries.
@@ -946,7 +968,7 @@ declare const ntile: (n: number) => WindowFunctionNode;
  * @param defaultValue - Default value if no row exists
  * @returns Window function node for LAG
  */
-declare const lag: (col: ColumnRef | ColumnNode, offset?: number, defaultValue?: any) => WindowFunctionNode;
+declare const lag: (col: ColumnRef | ColumnNode, offset?: number, defaultValue?: LiteralNode["value"]) => WindowFunctionNode;
 /**
  * Creates a LEAD window function
  * @param col - Column to lead
@@ -954,7 +976,7 @@ declare const lag: (col: ColumnRef | ColumnNode, offset?: number, defaultValue?:
  * @param defaultValue - Default value if no row exists
  * @returns Window function node for LEAD
  */
-declare const lead: (col: ColumnRef | ColumnNode, offset?: number, defaultValue?: any) => WindowFunctionNode;
+declare const lead: (col: ColumnRef | ColumnNode, offset?: number, defaultValue?: LiteralNode["value"]) => WindowFunctionNode;
 /**
  * Creates a FIRST_VALUE window function
  * @param col - Column to get first value from
@@ -1050,8 +1072,8 @@ interface OperandVisitor<R> {
     visitAliasRef?(node: AliasRefNode): R;
     otherwise?(node: OperandNode): R;
 }
-type ExpressionDispatch = <R>(node: any, visitor: ExpressionVisitor<R>) => R;
-type OperandDispatch = <R>(node: any, visitor: OperandVisitor<R>) => R;
+type ExpressionDispatch = <R>(node: ExpressionNode, visitor: ExpressionVisitor<R>) => R;
+type OperandDispatch = <R>(node: OperandNode, visitor: OperandVisitor<R>) => R;
 /**
  * Registers a dispatcher for a custom expression node type.
  * Allows new node kinds without modifying the core switch.
@@ -1126,7 +1148,7 @@ interface FunctionTableNode {
     /** Optional schema for the function (some dialects) */
     schema?: string;
     /** Function arguments as operand nodes */
-    args?: any[];
+    args?: OperandNode[];
     /** Optional alias for the function table */
     alias?: string;
     /** LATERAL flag */
@@ -1337,17 +1359,32 @@ interface HydrationMetadata {
     [key: string]: unknown;
 }
 
+/**
+ * Context provided to function renderers.
+ */
 interface FunctionRenderContext {
+    /** The function node being rendered. */
     node: FunctionNode;
+    /** The compiled arguments for the function. */
     compiledArgs: string[];
-    /** Helper to compile additional operands (e.g., separators or ORDER BY columns) */
+    /** Helper to compile additional operands (e.g., separators or ORDER BY columns). */
     compileOperand: (operand: OperandNode) => string;
 }
+/**
+ * A function that renders a SQL function call.
+ * @param ctx - The rendering context.
+ * @returns The rendered SQL string.
+ */
 type FunctionRenderer = (ctx: FunctionRenderContext) => string;
+/**
+ * Strategy for rendering SQL functions in a specific dialect.
+ */
 interface FunctionStrategy {
     /**
      * Returns a renderer for a specific function name (e.g. "DATE_ADD").
      * Returns undefined if this dialect doesn't support the function.
+     * @param functionName - The name of the function.
+     * @returns The renderer function or undefined.
      */
     getRenderer(functionName: string): FunctionRenderer | undefined;
 }
@@ -1421,7 +1458,7 @@ declare abstract class Dialect implements SelectCompiler, InsertCompiler, Update
      * @returns SQL WHERE clause or empty string
      */
     protected compileWhere(where: ExpressionNode | undefined, ctx: CompilerContext): string;
-    protected compileReturning(returning: ColumnNode[] | 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
@@ -1442,12 +1479,12 @@ declare abstract class Dialect implements SelectCompiler, InsertCompiler, Update
      * @param index - Parameter index
      * @returns Formatted placeholder string
      */
-    protected formatPlaceholder(index: number): 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;
+    protected supportsSetOperation(_kind: SetOperationKind): boolean;
     /**
      * Validates set-operation semantics:
      * - Ensures the dialect supports requested operators.
@@ -1510,7 +1547,7 @@ declare abstract class Dialect implements SelectCompiler, InsertCompiler, Update
     protected compileOrderingTerm(term: OrderingTerm, ctx: CompilerContext): string;
     private registerDefaultExpressionCompilers;
     private registerDefaultOperandCompilers;
-    protected compileJsonPath(node: JsonPathNode): string;
+    protected compileJsonPath(_node: JsonPathNode): string;
     /**
      * Compiles a function operand, using the dialect's function strategy.
      */
@@ -1730,6 +1767,11 @@ declare class HydrationManager {
      * applied to parent rows when eager-loading multiplicative relations.
      */
     private requiresParentPagination;
+    /**
+     * Checks if the hydration plan contains relations that multiply rows
+     * @param plan - Hydration plan to check
+     * @returns True if plan has HasMany or BelongsToMany relations
+     */
     private hasMultiplyingRelations;
     /**
      * Rewrites the query using CTEs so LIMIT/OFFSET target distinct parent rows
@@ -1741,11 +1783,52 @@ declare class HydrationManager {
      * - Join the base CTE against the paged ids to retrieve the joined rows for just that page.
      */
     private wrapForParentPagination;
+    /**
+     * Generates a unique CTE name by appending a suffix if needed
+     * @param existing - Existing CTE nodes
+     * @param baseName - Base name for the CTE
+     * @returns Unique CTE name
+     */
     private nextCteName;
+    /**
+     * Extracts projection names from column nodes
+     * @param columns - Projection nodes
+     * @returns Array of names or undefined if any column lacks name/alias
+     */
     private getProjectionNames;
+    /**
+     * Builds a map of column keys to their aliases from projection nodes
+     * @param columns - Projection nodes
+     * @returns Map of 'table.name' to alias
+     */
     private buildProjectionAliasMap;
+    /**
+     * Maps order by nodes to use base CTE alias
+     * @param orderBy - Original order by nodes
+     * @param plan - Hydration plan
+     * @param projectionAliases - Map of column aliases
+     * @param baseAlias - Base CTE alias
+     * @param availableColumns - Set of available column names
+     * @returns Mapped order by nodes, null if cannot map
+     */
     private mapOrderBy;
+    /**
+     * Maps a single ordering term to use base CTE alias
+     * @param term - Ordering term to map
+     * @param plan - Hydration plan
+     * @param projectionAliases - Map of column aliases
+     * @param baseAlias - Base CTE alias
+     * @param availableColumns - Set of available column names
+     * @returns Mapped term or null if cannot map
+     */
     private mapOrderingTerm;
+    /**
+     * Builds column nodes for paging CTE
+     * @param primaryKey - Primary key name
+     * @param orderBy - Order by nodes
+     * @param tableAlias - Table alias for columns
+     * @returns Array of column nodes for paging
+     */
     private buildPagingColumns;
 }
 
@@ -1871,6 +1954,11 @@ declare class QueryAstService {
      * @returns Combined expression
      */
     private combineExpressions;
+    /**
+     * Normalizes an ordering term to a standard OrderingTerm
+     * @param term - Column definition or ordering term to normalize
+     * @returns Normalized ordering term
+     */
     private normalizeOrderingTerm;
 }
 
@@ -1984,6 +2072,115 @@ declare class RelationService {
     private rootTableName;
 }
 
+/**
+ * Type for column selection input
+ */
+type ColumnSelectionInput = Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>;
+/**
+ * Handles column selection operations for the query builder
+ */
+declare class ColumnSelector {
+    private readonly env;
+    /**
+     * Creates a new ColumnSelector instance
+     * @param env - Query builder environment
+     */
+    constructor(env: SelectQueryBuilderEnvironment);
+    /**
+     * Selects columns for the query
+     * @param context - Current query context
+     * @param columns - Columns to select
+     * @returns Updated query context with selected columns
+     */
+    select(context: SelectQueryBuilderContext, columns: ColumnSelectionInput): SelectQueryBuilderContext;
+    /**
+     * Selects raw column expressions
+     * @param context - Current query context
+     * @param columns - Raw column expressions
+     * @returns Updated query context with raw column selections
+     */
+    selectRaw(context: SelectQueryBuilderContext, columns: string[]): SelectQueryBuilderContext;
+    /**
+     * Selects a subquery as a column
+     * @param context - Current query context
+     * @param alias - Alias for the subquery
+     * @param query - Subquery to select
+     * @returns Updated query context with subquery selection
+     */
+    selectSubquery(context: SelectQueryBuilderContext, alias: string, query: SelectQueryNode): SelectQueryBuilderContext;
+    /**
+     * Adds DISTINCT clause to the query
+     * @param context - Current query context
+     * @param columns - Columns to make distinct
+     * @returns Updated query context with DISTINCT clause
+     */
+    distinct(context: SelectQueryBuilderContext, columns: (ColumnDef | ColumnNode)[]): SelectQueryBuilderContext;
+}
+
+/**
+ * Manages relation operations (joins, includes, etc.) for query building
+ */
+declare class RelationManager {
+    private readonly env;
+    /**
+     * Creates a new RelationManager instance
+     * @param env - Query builder environment
+     */
+    constructor(env: SelectQueryBuilderEnvironment);
+    /**
+     * Matches records based on a relation with an optional predicate
+     * @param context - Current query context
+     * @param relationName - Name of the relation to match
+     * @param predicate - Optional predicate expression
+     * @returns Updated query context with relation match
+     */
+    match(context: SelectQueryBuilderContext, relationName: string, predicate?: ExpressionNode): SelectQueryBuilderContext;
+    /**
+     * Joins a relation to the query
+     * @param context - Current query context
+     * @param relationName - Name of the relation to join
+     * @param joinKind - Type of join to use
+     * @param extraCondition - Additional join condition
+     * @returns Updated query context with relation join
+     */
+    joinRelation(context: SelectQueryBuilderContext, relationName: string, joinKind: JoinKind, extraCondition?: ExpressionNode): SelectQueryBuilderContext;
+    /**
+     * Includes a relation in the query result
+     * @param context - Current query context
+     * @param relationName - Name of the relation to include
+     * @param options - Options for relation inclusion
+     * @returns Updated query context with included relation
+     */
+    include(context: SelectQueryBuilderContext, relationName: string, options?: RelationIncludeOptions): SelectQueryBuilderContext;
+    /**
+     * Applies relation correlation to a query AST
+     * @param context - Current query context
+     * @param relationName - Name of the relation
+     * @param ast - Query AST to modify
+     * @returns Modified query AST with relation correlation
+     */
+    applyRelationCorrelation(context: SelectQueryBuilderContext, relationName: string, ast: SelectQueryNode, additionalCorrelation?: ExpressionNode): SelectQueryNode;
+    /**
+     * Creates a relation service instance
+     * @param context - Current query context
+     * @returns Relation service instance
+     */
+    private createService;
+}
+
+/**
+ * Context for query building operations
+ */
+interface SelectQueryBuilderContext {
+    /**
+     * Current query state
+     */
+    readonly state: SelectQueryState;
+    /**
+     * Hydration manager for the query
+     */
+    readonly hydration: HydrationManager;
+}
 /**
  * Dependencies for query builder operations
  */
@@ -2021,6 +2218,31 @@ interface SelectQueryBuilderDependencies {
      * @returns New relation service
      */
     createRelationService: (table: TableDef, state: SelectQueryState, hydration: HydrationManager) => RelationService;
+    /**
+     * Creates a new column selector
+     * @param env - Query builder environment
+     * @returns New column selector
+     */
+    createColumnSelector: (env: SelectQueryBuilderEnvironment) => ColumnSelector;
+    /**
+     * Creates a new relation manager
+     * @param env - Query builder environment
+     * @returns New relation manager
+     */
+    createRelationManager: (env: SelectQueryBuilderEnvironment) => RelationManager;
+}
+/**
+ * Environment for query builder operations
+ */
+interface SelectQueryBuilderEnvironment {
+    /**
+     * Table definition
+     */
+    readonly table: TableDef;
+    /**
+     * Query builder dependencies
+     */
+    readonly deps: SelectQueryBuilderDependencies;
 }
 
 type QueryResult = {
@@ -2061,8 +2283,19 @@ interface SimpleQueryRunner {
  */
 declare function createExecutorFromQueryRunner(runner: SimpleQueryRunner): DbExecutor;
 
-type EntityConstructor<T = object> = new (...args: any[]) => T;
-type EntityOrTableTarget = EntityConstructor<any> | TableDef;
+/**
+ * Constructor type for entities.
+ * Supports any constructor signature for maximum flexibility with decorator-based entities.
+ * @template T - The entity type
+ */
+type EntityConstructor<T = object> = new (...args: never[]) => T;
+/**
+ * Target that can be an entity constructor or table definition.
+ */
+type EntityOrTableTarget = EntityConstructor | TableDef;
+/**
+ * Resolver for entity or table target, can be direct or function.
+ */
 type EntityOrTableTargetResolver = EntityOrTableTarget | (() => EntityOrTableTarget);
 
 /**
@@ -2087,13 +2320,13 @@ interface TrackedEntity {
     /** The table definition this entity belongs to */
     table: TableDef;
     /** The actual entity instance */
-    entity: any;
+    entity: unknown;
     /** 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;
+    original: Record<string, unknown> | null;
 }
 /**
  * Type representing a key for relation navigation
@@ -2121,7 +2354,7 @@ type RelationChange<T> = {
  */
 interface RelationChangeEntry {
     /** Root entity that owns the relation */
-    root: any;
+    root: unknown;
     /** Key of the relation being changed */
     relationKey: RelationKey;
     /** Table definition of the root entity */
@@ -2131,7 +2364,7 @@ interface RelationChangeEntry {
     /** Relation definition */
     relation: RelationDef;
     /** The change being applied */
-    change: RelationChange<any>;
+    change: RelationChange<unknown>;
 }
 /**
  * Represents a domain event that can be emitted by entities
@@ -2191,9 +2424,8 @@ declare class InterceptorPipeline {
 
 /**
  * Options for creating an ORM instance.
- * @template E - The domain event type
  */
-interface OrmOptions<E extends DomainEvent = OrmDomainEvent> {
+interface OrmOptions {
     /** The database dialect */
     dialect: Dialect;
     /** The database executor factory */
@@ -2238,7 +2470,7 @@ declare class Orm<E extends DomainEvent = OrmDomainEvent> {
      * Creates a new ORM instance.
      * @param opts - ORM options
      */
-    constructor(opts: OrmOptions<E>);
+    constructor(opts: OrmOptions);
     /**
      * Creates a new ORM session.
      * @param options - Optional session options
@@ -2262,7 +2494,7 @@ declare class Orm<E extends DomainEvent = OrmDomainEvent> {
 declare class IdentityMap {
     private readonly buckets;
     get bucketsMap(): Map<string, Map<string, TrackedEntity>>;
-    getEntity(table: TableDef, pk: string | number): any | undefined;
+    getEntity(table: TableDef, pk: string | number): unknown | undefined;
     register(tracked: TrackedEntity): void;
     remove(tracked: TrackedEntity): void;
     getEntitiesForTable(table: TableDef): TrackedEntity[];
@@ -2302,7 +2534,7 @@ declare class UnitOfWork {
      * @param pk - The primary key value
      * @returns The entity or undefined if not found
      */
-    getEntity(table: TableDef, pk: string | number): any | undefined;
+    getEntity(table: TableDef, pk: string | number): unknown | undefined;
     /**
      * Gets all tracked entities for a specific table.
      * @param table - The table definition
@@ -2314,38 +2546,38 @@ declare class UnitOfWork {
      * @param entity - The entity to find
      * @returns The tracked entity or undefined if not found
      */
-    findTracked(entity: any): TrackedEntity | undefined;
+    findTracked(entity: unknown): TrackedEntity | undefined;
     /**
      * Sets an entity in the identity map.
      * @param table - The table definition
      * @param pk - The primary key value
      * @param entity - The entity instance
      */
-    setEntity(table: TableDef, pk: string | number, entity: any): void;
+    setEntity(table: TableDef, pk: string | number, entity: unknown): void;
     /**
      * Tracks a new entity.
      * @param table - The table definition
      * @param entity - The entity instance
      * @param pk - Optional primary key value
      */
-    trackNew(table: TableDef, entity: any, pk?: string | number): void;
+    trackNew(table: TableDef, entity: unknown, pk?: string | number): void;
     /**
      * Tracks a managed entity.
      * @param table - The table definition
      * @param pk - The primary key value
      * @param entity - The entity instance
      */
-    trackManaged(table: TableDef, pk: string | number, entity: any): void;
+    trackManaged(table: TableDef, pk: string | number, entity: unknown): void;
     /**
      * Marks an entity as dirty (modified).
      * @param entity - The entity to mark as dirty
      */
-    markDirty(entity: any): void;
+    markDirty(entity: unknown): void;
     /**
      * Marks an entity as removed.
      * @param entity - The entity to mark as removed
      */
-    markRemoved(entity: any): void;
+    markRemoved(entity: unknown): void;
     /**
      * Flushes pending changes to the database.
      */
@@ -2628,17 +2860,68 @@ interface ExecutionContext {
     interceptors: InterceptorPipeline;
 }
 
+/**
+ * Interface for entity context providing entity tracking and management.
+ */
 interface EntityContext {
+    /** The database dialect */
     dialect: Dialect;
+    /** The database executor */
     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;
+    /**
+     * Gets an entity by table and primary key.
+     * @param table - The table definition
+     * @param pk - The primary key value
+     * @returns The entity or undefined
+     */
+    getEntity(table: TableDef, pk: unknown): unknown;
+    /**
+     * Sets an entity in the context.
+     * @param table - The table definition
+     * @param pk - The primary key value
+     * @param entity - The entity to set
+     */
+    setEntity(table: TableDef, pk: unknown, entity: unknown): void;
+    /**
+     * Tracks a new entity.
+     * @param table - The table definition
+     * @param entity - The new entity
+     * @param pk - Optional primary key
+     */
+    trackNew(table: TableDef, entity: unknown, pk?: unknown): void;
+    /**
+     * Tracks a managed entity.
+     * @param table - The table definition
+     * @param pk - The primary key
+     * @param entity - The managed entity
+     */
+    trackManaged(table: TableDef, pk: unknown, entity: unknown): void;
+    /**
+     * Marks an entity as dirty.
+     * @param entity - The entity to mark
+     */
+    markDirty(entity: unknown): void;
+    /**
+     * Marks an entity as removed.
+     * @param entity - The entity to mark
+     */
+    markRemoved(entity: unknown): void;
+    /**
+     * Gets all tracked entities for a table.
+     * @param table - The table definition
+     * @returns Array of tracked entities
+     */
     getEntitiesForTable(table: TableDef): TrackedEntity[];
-    registerRelationChange(root: any, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<any>): void;
+    /**
+     * Registers a relation change.
+     * @param root - The root entity
+     * @param relationKey - The relation key
+     * @param rootTable - The root table definition
+     * @param relationName - The relation name
+     * @param relation - The relation definition
+     * @param change - The relation change
+     */
+    registerRelationChange(root: unknown, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<unknown>): void;
 }
 
 interface HydrationContext<E extends DomainEvent = AnyDomainEvent> {
@@ -2731,38 +3014,38 @@ declare class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Enti
      * @param pk - The primary key value
      * @returns The entity or undefined if not found
      */
-    getEntity(table: TableDef, pk: any): any | undefined;
+    getEntity(table: TableDef, pk: unknown): unknown | undefined;
     /**
      * Sets an entity in the identity map.
      * @param table - The table definition
      * @param pk - The primary key value
      * @param entity - The entity instance
      */
-    setEntity(table: TableDef, pk: any, entity: any): void;
+    setEntity(table: TableDef, pk: unknown, entity: unknown): void;
     /**
      * Tracks a new entity.
      * @param table - The table definition
      * @param entity - The entity instance
      * @param pk - Optional primary key value
      */
-    trackNew(table: TableDef, entity: any, pk?: any): void;
+    trackNew(table: TableDef, entity: unknown, pk?: unknown): void;
     /**
      * Tracks a managed entity.
      * @param table - The table definition
      * @param pk - The primary key value
      * @param entity - The entity instance
      */
-    trackManaged(table: TableDef, pk: any, entity: any): void;
+    trackManaged(table: TableDef, pk: unknown, entity: unknown): void;
     /**
      * Marks an entity as dirty (modified).
      * @param entity - The entity to mark as dirty
      */
-    markDirty(entity: any): void;
+    markDirty(entity: unknown): void;
     /**
      * Marks an entity as removed.
      * @param entity - The entity to mark as removed
      */
-    markRemoved(entity: any): void;
+    markRemoved(entity: unknown): void;
     /**
      * Registers a relation change.
      * @param root - The root entity
@@ -2772,7 +3055,7 @@ declare class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Enti
      * @param relation - The relation definition
      * @param change - The relation change
      */
-    registerRelationChange: (root: any, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<any>) => void;
+    registerRelationChange: (root: unknown, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<unknown>) => void;
     /**
      * Gets all tracked entities for a specific table.
      * @param table - The table definition
@@ -2800,21 +3083,21 @@ declare class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Enti
      * @returns The entity instance or null if not found
      * @throws If entity metadata is not bootstrapped or table has no primary key
      */
-    find<TCtor extends EntityConstructor<any>>(entityClass: TCtor, id: any): Promise<InstanceType<TCtor> | null>;
+    find<TCtor extends EntityConstructor<object>>(entityClass: TCtor, id: unknown): Promise<InstanceType<TCtor> | null>;
     /**
      * Finds a single entity using a query builder.
      * @template TTable - The table type
      * @param qb - The query builder
      * @returns The first entity instance or null if not found
      */
-    findOne<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<EntityInstance<TTable> | null>;
+    findOne<TTable extends TableDef>(qb: SelectQueryBuilder<unknown, TTable>): Promise<EntityInstance<TTable> | null>;
     /**
      * Finds multiple entities using a query builder.
      * @template TTable - The table type
      * @param qb - The query builder
      * @returns Array of entity instances
      */
-    findMany<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<EntityInstance<TTable>[]>;
+    findMany<TTable extends TableDef>(qb: SelectQueryBuilder<unknown, TTable>): Promise<EntityInstance<TTable>[]>;
     /**
      * Saves an entity graph (root + nested relations) based on a DTO-like payload.
      * @param entityClass - Root entity constructor
@@ -2822,7 +3105,7 @@ declare class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Enti
      * @param options - Graph save options
      * @returns The root entity instance
      */
-    saveGraph<TCtor extends EntityConstructor<any>>(entityClass: TCtor, payload: Record<string, any>, options?: SaveGraphOptions & {
+    saveGraph<TCtor extends EntityConstructor<object>>(entityClass: TCtor, payload: Record<string, unknown>, options?: SaveGraphOptions & {
         transactional?: boolean;
     }): Promise<InstanceType<TCtor>>;
     /**
@@ -2875,109 +3158,116 @@ declare class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Enti
 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 DeepSelectEntry<TTable extends TableDef> = {
+    type: 'root';
+    columns: (keyof TTable['columns'] & string)[];
+} | {
+    type: 'relation';
+    relationName: keyof TTable['relations'] & string;
+    columns: string[];
 };
+type DeepSelectConfig<TTable extends TableDef> = DeepSelectEntry<TTable>[];
 type WhereHasOptions = {
     correlate?: ExpressionNode;
 };
-type RelationCallback = <TChildTable extends TableDef>(qb: SelectQueryBuilder<any, TChildTable>) => SelectQueryBuilder<any, TChildTable>;
+type RelationCallback = <TChildTable extends TableDef>(qb: SelectQueryBuilder<unknown, TChildTable>) => SelectQueryBuilder<unknown, TChildTable>;
 /**
-
  * Main query builder class for constructing SQL SELECT queries
-
  * @typeParam T - Result type for projections (unused)
-
  * @typeParam TTable - Table definition being queried
-
  */
-declare class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
+declare class SelectQueryBuilder<T = unknown, 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>);
+    /**
+     * Creates a new SelectQueryBuilder instance with updated context and lazy relations
+     * @param context - Updated query context
+     * @param lazyRelations - Updated lazy relations set
+     * @returns New SelectQueryBuilder instance
+     */
     private clone;
     /**
      * Applies an alias to the root FROM table.
      * @param alias - Alias to apply
      */
     as(alias: string): SelectQueryBuilder<T, TTable>;
-    private resolveQueryNode;
+    /**
+     * Applies correlation expression to the query AST
+     * @param ast - Query AST to modify
+     * @param correlation - Correlation expression
+     * @returns Modified AST with correlation applied
+     */
     private applyCorrelation;
+    /**
+     * Creates a new child query builder for a related table
+     * @param table - Table definition for the child builder
+     * @returns New SelectQueryBuilder instance for the child table
+     */
     private createChildBuilder;
+    /**
+     * Applies an AST mutation using the query AST service
+     * @param context - Current query context
+     * @param mutator - Function that mutates the AST
+     * @returns Updated query context
+     */
     private applyAst;
+    /**
+     * Applies a join to the query context
+     * @param context - Current query context
+     * @param table - Table to join
+     * @param condition - Join condition
+     * @param kind - Join kind
+     * @returns Updated query context with join applied
+     */
     private applyJoin;
+    /**
+     * Applies a set operation to the query
+     * @param operator - Set operation kind
+     * @param query - Query to combine with
+     * @returns Updated query context with set operation
+     */
     private applySetOperation;
     /**
-  
-     * Selects specific columns for the query
-  
-     * @param columns - Record of column definitions, function nodes, case expressions, or window functions
-  
+     * Selects columns for the query (unified overloaded method).
+     * Can be called with column names or a projection object.
+     * @param args - Column names or projection object
      * @returns New query builder instance with selected columns
-  
      */
+    select<K extends keyof TTable['columns'] & string>(...args: K[]): SelectQueryBuilder<T, TTable>;
     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>;
+    with<TSub extends TableDef>(name: string, query: SelectQueryBuilder<unknown, TSub> | 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>;
+    withRecursive<TSub extends TableDef>(name: string, query: SelectQueryBuilder<unknown, TSub> | 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
@@ -2985,19 +3275,27 @@ declare class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
      * @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>;
+    fromSubquery<TSub extends TableDef>(subquery: SelectQueryBuilder<unknown, TSub> | SelectQueryNode, alias: string, columnAliases?: string[]): SelectQueryBuilder<T, TTable>;
+    /**
+     * Replaces the FROM clause with a function table expression.
+     * @param name - Function name
+     * @param args - Optional function arguments
+     * @param alias - Optional alias for the function table
+     * @param options - Optional function-table metadata (lateral, ordinality, column aliases, schema)
+     */
+    fromFunctionTable(name: string, args?: OperandNode[], alias?: string, options?: {
+        lateral?: boolean;
+        withOrdinality?: boolean;
+        columnAliases?: string[];
+        schema?: 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>;
+    selectSubquery<TSub extends TableDef>(alias: string, sub: SelectQueryBuilder<unknown, TSub> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
      * Adds a JOIN against a derived table (subquery with alias)
      * @param subquery - Subquery to join
@@ -3007,81 +3305,70 @@ declare class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
      * @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>;
+    joinSubquery<TSub extends TableDef>(subquery: SelectQueryBuilder<unknown, TSub> | SelectQueryNode, alias: string, condition: BinaryExpressionNode, joinKind?: JoinKind, columnAliases?: string[]): SelectQueryBuilder<T, TTable>;
+    /**
+     * Adds a join against a function table (e.g., `generate_series`) using `fnTable` internally.
+     * @param name - Function name
+     * @param args - Optional arguments passed to the function
+     * @param alias - Alias for the function table so columns can be referenced
+     * @param condition - Join condition expression
+     * @param joinKind - Kind of join (defaults to INNER)
+     * @param options - Optional metadata (lateral, ordinality, column aliases, schema)
+     */
+    joinFunctionTable(name: string, args: OperandNode[], alias: string, condition: BinaryExpressionNode, joinKind?: JoinKind, options?: {
+        lateral?: boolean;
+        withOrdinality?: boolean;
+        columnAliases?: string[];
+        schema?: 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>;
+    match<K extends keyof TTable['relations'] & string>(relationName: K, 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>;
+    joinRelation<K extends keyof TTable['relations'] & string>(relationName: K, 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>;
+    include<K extends keyof TTable['relations'] & string>(relationName: K, options?: RelationIncludeOptions): SelectQueryBuilder<T, TTable>;
+    /**
+     * Includes a relation lazily in the query results
+     * @param relationName - Name of the relation to include lazily
+     * @returns New query builder instance with lazy relation inclusion
+     */
     includeLazy<K extends keyof RelationMap<TTable>>(relationName: K): SelectQueryBuilder<T, TTable>;
     /**
      * Selects columns for a related table in a single hop.
@@ -3092,21 +3379,38 @@ declare class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
      */
     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.
+     * Selects columns for the root table and relations from an array of entries
+     * @param config - Configuration array for deep column selection
+     * @returns New query builder instance with deep column selections
      */
     selectColumnsDeep(config: DeepSelectConfig<TTable>): SelectQueryBuilder<T, TTable>;
+    /**
+     * Gets the list of lazy relations
+     * @returns Array of lazy relation names
+     */
     getLazyRelations(): (keyof RelationMap<TTable>)[];
+    /**
+     * Gets the table definition for this query builder
+     * @returns Table definition
+     */
     getTable(): TTable;
+    /**
+     * Executes the query and returns hydrated results
+     * @param ctx - ORM session context
+     * @returns Promise of entity instances
+     */
     execute(ctx: OrmSession): Promise<EntityInstance<TTable>[]>;
+    /**
+     * Executes the query with provided execution and hydration contexts
+     * @param execCtx - Execution context
+     * @param hydCtx - Hydration context
+     * @returns Promise of entity instances
+     */
     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>;
     /**
@@ -3116,13 +3420,9 @@ declare class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
      */
     groupBy(term: ColumnDef | OrderingTerm): 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>;
     /**
@@ -3137,190 +3437,121 @@ declare class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
         collation?: string;
     }): 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>;
+    union<TSub extends TableDef>(query: SelectQueryBuilder<unknown, TSub> | 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>;
+    unionAll<TSub extends TableDef>(query: SelectQueryBuilder<unknown, TSub> | 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>;
+    intersect<TSub extends TableDef>(query: SelectQueryBuilder<unknown, TSub> | 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>;
+    except<TSub extends TableDef>(query: SelectQueryBuilder<unknown, TSub> | 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>;
+    whereExists<TSub extends TableDef>(subquery: SelectQueryBuilder<unknown, TSub> | 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>;
+    whereNotExists<TSub extends TableDef>(subquery: SelectQueryBuilder<unknown, TSub> | 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>;
+    whereHas<K extends keyof TTable['relations'] & string>(relationName: K, 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>;
+    whereHasNot<K extends keyof TTable['relations'] & string>(relationName: K, 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;
 }
-/**
-
- * 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 createColumn: (table: string, name: string) => ColumnNode;
-/**
-
- * Creates a literal value node for use in expressions
-
- * @param val - Literal value (string or number)
-
- * @returns LiteralNode with the specified value
-
- */
-declare const createLiteral: (val: string | number) => LiteralNode;
 
 /**
  * Build a typed selection map from a TableDef.
+ * @template TTable - The table definition type
+ * @template K - The column name keys
+ * @param table - The table definition to select columns from
+ * @param cols - Column names to include in the selection
+ * @returns A typed record mapping column names to their definitions
+ * @throws Error if a specified column is not found on the table
  */
 declare function sel<TTable extends TableDef, K extends keyof TTable['columns'] & string>(table: TTable, ...cols: K[]): Record<K, TTable['columns'][K]>;
 type Ctor<T> = {
-    new (...args: any[]): T;
+    new (...args: unknown[]): T;
 };
 /**
  * Build a typed selection map from an entity constructor.
- */
-declare function esel<TEntity, K extends keyof TEntity & string>(entity: Ctor<TEntity>, ...props: K[]): Record<K, ColumnDef>;
+ * @template TEntity - The entity type
+ * @template K - The property name keys
+ * @param entity - The entity constructor to get table definition from
+ * @param props - Property names to include in the selection
+ * @returns A record mapping property names to their column definitions
+ * @throws Error if no table definition is registered for the entity
+ * @throws Error if a specified property is not found as a column
+ */
+declare function esel<TEntity extends object, K extends keyof TEntity & string>(entity: Ctor<TEntity>, ...props: K[]): Record<K, ColumnDef>;
 
 /**
  * Maintains immutable state for building INSERT queries
@@ -3328,14 +3559,44 @@ declare function esel<TEntity, K extends keyof TEntity & string>(entity: Ctor<TE
 declare class InsertQueryState {
     readonly table: TableDef;
     readonly ast: InsertQueryNode;
+    /**
+     * Creates a new InsertQueryState instance
+     * @param table - The table definition for the INSERT query
+     * @param ast - Optional initial AST node, defaults to a basic INSERT query
+     */
     constructor(table: TableDef, ast?: InsertQueryNode);
     private clone;
     private ensureColumnsFromRow;
     private appendValues;
     private getTableColumns;
+    /**
+     * Adds VALUES clause to the INSERT query
+     * @param rows - Array of row objects to insert
+     * @returns A new InsertQueryState with the VALUES clause added
+     * @throws Error if mixing VALUES with SELECT source
+     * @throws Error if invalid values are provided
+     */
     withValues(rows: Record<string, unknown>[]): InsertQueryState;
+    /**
+     * Sets the columns for the INSERT query
+     * @param columns - Column nodes to insert into
+     * @returns A new InsertQueryState with the specified columns
+     */
     withColumns(columns: ColumnNode[]): InsertQueryState;
+    /**
+     * Adds SELECT source to the INSERT query
+     * @param query - The SELECT query to use as source
+     * @param columns - Target columns for the INSERT
+     * @returns A new InsertQueryState with the SELECT source
+     * @throws Error if mixing SELECT with VALUES source
+     * @throws Error if no destination columns specified
+     */
     withSelect(query: SelectQueryNode, columns: ColumnNode[]): InsertQueryState;
+    /**
+     * Adds a RETURNING clause to the INSERT query
+     * @param columns - Columns to return after insertion
+     * @returns A new InsertQueryState with the RETURNING clause added
+     */
     withReturning(columns: ColumnNode[]): InsertQueryState;
 }
 
@@ -3346,17 +3607,63 @@ type InsertDialectInput = Dialect | DialectKey;
 declare class InsertQueryBuilder<T> {
     private readonly table;
     private readonly state;
+    /**
+     * Creates a new InsertQueryBuilder instance
+     * @param table - The table definition for the INSERT query
+     * @param state - Optional initial query state, defaults to a new InsertQueryState
+     */
     constructor(table: TableDef, state?: InsertQueryState);
     private clone;
+    /**
+     * Adds VALUES to the INSERT query
+     * @param rowOrRows - Single row object or array of row objects to insert
+     * @returns A new InsertQueryBuilder with the VALUES clause added
+     */
     values(rowOrRows: Record<string, unknown> | Record<string, unknown>[]): InsertQueryBuilder<T>;
+    /**
+     * Specifies the columns for the INSERT query
+     * @param columns - Column definitions or nodes to insert into
+     * @returns A new InsertQueryBuilder with the specified columns
+     */
     columns(...columns: (ColumnDef | ColumnNode)[]): InsertQueryBuilder<T>;
-    fromSelect(query: SelectQueryNode | SelectQueryBuilder<any, TableDef<any>>, columns?: (ColumnDef | ColumnNode)[]): InsertQueryBuilder<T>;
+    /**
+     * Sets the source of the INSERT query to a SELECT query
+     * @template TSource - The source table type
+     * @param query - The SELECT query or query builder to use as source
+     * @param columns - Optional target columns for the INSERT
+     * @returns A new InsertQueryBuilder with the SELECT source
+     */
+    fromSelect<TSource extends TableDef>(query: SelectQueryNode | SelectQueryBuilder<unknown, TSource>, columns?: (ColumnDef | ColumnNode)[]): InsertQueryBuilder<T>;
+    /**
+     * Adds a RETURNING clause to the INSERT query
+     * @param columns - Columns to return after insertion
+     * @returns A new InsertQueryBuilder with the RETURNING clause added
+     */
     returning(...columns: (ColumnDef | ColumnNode)[]): InsertQueryBuilder<T>;
     private resolveColumnNodes;
     private resolveSelectQuery;
+    /**
+     * Compiles the INSERT query
+     * @param compiler - The INSERT compiler to use
+     * @returns The compiled query with SQL and parameters
+     */
     compile(compiler: InsertCompiler): CompiledQuery;
+    /**
+     * Compiles the INSERT query for the specified dialect
+     * @param dialect - The SQL dialect to compile for
+     * @returns The compiled query with SQL and parameters
+     */
     compile(dialect: InsertDialectInput): CompiledQuery;
+    /**
+     * Returns the SQL string for the INSERT query
+     * @param arg - The compiler or dialect to generate SQL for
+     * @returns The SQL string representation of the query
+     */
     toSql(arg: InsertCompiler | InsertDialectInput): string;
+    /**
+     * Returns the Abstract Syntax Tree (AST) representation of the query
+     * @returns The AST node for the INSERT query
+     */
     getAST(): InsertQueryNode;
 }
 
@@ -3366,13 +3673,53 @@ declare class InsertQueryBuilder<T> {
 declare class UpdateQueryState {
     readonly table: TableDef;
     readonly ast: UpdateQueryNode;
+    /**
+     * Creates a new UpdateQueryState instance
+     * @param table - Table definition for the update
+     * @param ast - Optional existing AST
+     */
     constructor(table: TableDef, ast?: UpdateQueryNode);
+    /**
+     * Creates a new UpdateQueryState with updated AST
+     * @param nextAst - Updated AST
+     * @returns New UpdateQueryState instance
+     */
     private clone;
+    /**
+     * Sets the columns to update with their new values
+     * @param values - Record of column names to values
+     * @returns New UpdateQueryState with SET clause
+     */
     withSet(values: Record<string, unknown>): UpdateQueryState;
+    /**
+     * Adds a WHERE condition to the update query
+     * @param expr - WHERE expression
+     * @returns New UpdateQueryState with WHERE clause
+     */
     withWhere(expr: ExpressionNode): UpdateQueryState;
+    /**
+     * Adds a RETURNING clause to the update query
+     * @param columns - Columns to return
+     * @returns New UpdateQueryState with RETURNING clause
+     */
     withReturning(columns: ColumnNode[]): UpdateQueryState;
+    /**
+     * Sets the FROM clause for the update query
+     * @param from - Table source for FROM
+     * @returns New UpdateQueryState with FROM clause
+     */
     withFrom(from: TableSourceNode): UpdateQueryState;
+    /**
+     * Adds a JOIN to the update query
+     * @param join - Join node to add
+     * @returns New UpdateQueryState with JOIN
+     */
     withJoin(join: JoinNode): UpdateQueryState;
+    /**
+     * Applies an alias to the table being updated
+     * @param alias - Alias for the table
+     * @returns New UpdateQueryState with table alias
+     */
     withTableAlias(alias: string): UpdateQueryState;
 }
 
@@ -3383,19 +3730,76 @@ type UpdateDialectInput = Dialect | DialectKey;
 declare class UpdateQueryBuilder<T> {
     private readonly table;
     private readonly state;
+    /**
+     * Creates a new UpdateQueryBuilder instance
+     * @param table - The table definition for the UPDATE query
+     * @param state - Optional initial query state, defaults to a new UpdateQueryState
+     */
     constructor(table: TableDef, state?: UpdateQueryState);
     private clone;
+    /**
+     * Sets an alias for the table in the UPDATE query
+     * @param alias - The alias to assign to the table
+     * @returns A new UpdateQueryBuilder with the table alias set
+     */
     as(alias: string): UpdateQueryBuilder<T>;
+    /**
+     * Adds a FROM clause to the UPDATE query
+     * @param source - The table source to use in the FROM clause
+     * @returns A new UpdateQueryBuilder with the FROM clause added
+     */
     from(source: TableDef | TableSourceNode): UpdateQueryBuilder<T>;
+    /**
+     * Adds a JOIN clause to the UPDATE query
+     * @param table - The table to join with
+     * @param condition - The join condition expression
+     * @param kind - The type of join (defaults to INNER)
+     * @param relationName - Optional name for the relation
+     * @returns A new UpdateQueryBuilder with the JOIN clause added
+     */
     join(table: TableDef | TableSourceNode | string, condition: ExpressionNode, kind?: JoinKind, relationName?: string): UpdateQueryBuilder<T>;
+    /**
+     * Adds a SET clause to the UPDATE query
+     * @param values - The column-value pairs to update
+     * @returns A new UpdateQueryBuilder with the SET clause added
+     */
     set(values: Record<string, unknown>): UpdateQueryBuilder<T>;
+    /**
+     * Adds a WHERE clause to the UPDATE query
+     * @param expr - The expression to use as the WHERE condition
+     * @returns A new UpdateQueryBuilder with the WHERE clause added
+     */
     where(expr: ExpressionNode): UpdateQueryBuilder<T>;
+    /**
+     * Adds a RETURNING clause to the UPDATE query
+     * @param columns - Columns to return after update
+     * @returns A new UpdateQueryBuilder with the RETURNING clause added
+     */
     returning(...columns: (ColumnDef | ColumnNode)[]): UpdateQueryBuilder<T>;
     private resolveTableSource;
     private resolveJoinTarget;
-    compile(compiler: UpdateCompiler): CompiledQuery;
+    /**
+     * Compiles the UPDATE query for the specified dialect
+     * @param dialect - The SQL dialect to compile for
+     * @returns The compiled query with SQL and parameters
+     */
     compile(dialect: UpdateDialectInput): CompiledQuery;
-    toSql(arg: UpdateCompiler | UpdateDialectInput): string;
+    /**
+     * Returns the SQL string for the UPDATE query
+     * @param dialect - The SQL dialect to generate SQL for
+     * @returns The SQL string representation of the query
+     */
+    toSql(dialect: UpdateDialectInput): string;
+    /**
+     * Executes the UPDATE query using the provided session
+     * @param session - The ORM session to execute the query with
+     * @returns A promise that resolves to the query results
+     */
+    execute(session: OrmSession): Promise<QueryResult[]>;
+    /**
+     * Returns the Abstract Syntax Tree (AST) representation of the query
+     * @returns The AST node for the UPDATE query
+     */
     getAST(): UpdateQueryNode;
 }
 
@@ -3405,12 +3809,42 @@ declare class UpdateQueryBuilder<T> {
 declare class DeleteQueryState {
     readonly table: TableDef;
     readonly ast: DeleteQueryNode;
+    /**
+     * Creates a new DeleteQueryState instance
+     * @param table - The table definition for the DELETE query
+     * @param ast - Optional initial AST node, defaults to a basic DELETE query
+     */
     constructor(table: TableDef, ast?: DeleteQueryNode);
     private clone;
+    /**
+     * Adds a WHERE clause to the DELETE query
+     * @param expr - The expression to use as the WHERE condition
+     * @returns A new DeleteQueryState with the WHERE clause added
+     */
     withWhere(expr: ExpressionNode): DeleteQueryState;
+    /**
+     * Adds a RETURNING clause to the DELETE query
+     * @param columns - The columns to return after deletion
+     * @returns A new DeleteQueryState with the RETURNING clause added
+     */
     withReturning(columns: ColumnNode[]): DeleteQueryState;
+    /**
+     * Adds a USING clause to the DELETE query
+     * @param source - The table source to use in the USING clause
+     * @returns A new DeleteQueryState with the USING clause added
+     */
     withUsing(source: TableSourceNode): DeleteQueryState;
+    /**
+     * Adds a JOIN clause to the DELETE query
+     * @param join - The join node to add
+     * @returns A new DeleteQueryState with the JOIN clause added
+     */
     withJoin(join: JoinNode): DeleteQueryState;
+    /**
+     * Sets an alias for the table in the DELETE query
+     * @param alias - The alias to assign to the table
+     * @returns A new DeleteQueryState with the table alias set
+     */
     withTableAlias(alias: string): DeleteQueryState;
 }
 
@@ -3421,18 +3855,70 @@ type DeleteDialectInput = Dialect | DialectKey;
 declare class DeleteQueryBuilder<T> {
     private readonly table;
     private readonly state;
+    /**
+     * Creates a new DeleteQueryBuilder instance
+     * @param table - The table definition for the DELETE query
+     * @param state - Optional initial query state, defaults to a new DeleteQueryState
+     */
     constructor(table: TableDef, state?: DeleteQueryState);
     private clone;
+    /**
+     * Adds a WHERE clause to the DELETE query
+     * @param expr - The expression to use as the WHERE condition
+     * @returns A new DeleteQueryBuilder with the WHERE clause added
+     */
     where(expr: ExpressionNode): DeleteQueryBuilder<T>;
+    /**
+     * Sets an alias for the table in the DELETE query
+     * @param alias - The alias to assign to the table
+     * @returns A new DeleteQueryBuilder with the table alias set
+     */
     as(alias: string): DeleteQueryBuilder<T>;
+    /**
+     * Adds a USING clause to the DELETE query
+     * @param source - The table source to use in the USING clause
+     * @returns A new DeleteQueryBuilder with the USING clause added
+     */
     using(source: TableDef | TableSourceNode): DeleteQueryBuilder<T>;
+    /**
+     * Adds a JOIN clause to the DELETE query
+     * @param table - The table to join with
+     * @param condition - The join condition expression
+     * @param kind - The type of join (defaults to INNER)
+     * @param relationName - Optional name for the relation
+     * @returns A new DeleteQueryBuilder with the JOIN clause added
+     */
     join(table: TableDef | TableSourceNode | string, condition: ExpressionNode, kind?: JoinKind, relationName?: string): DeleteQueryBuilder<T>;
+    /**
+     * Adds a RETURNING clause to the DELETE query
+     * @param columns - The columns to return after deletion
+     * @returns A new DeleteQueryBuilder with the RETURNING clause added
+     */
     returning(...columns: (ColumnDef | ColumnNode)[]): DeleteQueryBuilder<T>;
     private resolveTableSource;
     private resolveJoinTarget;
-    compile(compiler: DeleteCompiler): CompiledQuery;
+    /**
+     * Compiles the DELETE query for the specified dialect
+     * @param dialect - The SQL dialect to compile for
+     * @returns The compiled query with SQL and parameters
+     */
     compile(dialect: DeleteDialectInput): CompiledQuery;
-    toSql(arg: DeleteCompiler | DeleteDialectInput): string;
+    /**
+     * Returns the SQL string for the DELETE query
+     * @param dialect - The SQL dialect to generate SQL for
+     * @returns The SQL string representation of the query
+     */
+    toSql(dialect: DeleteDialectInput): string;
+    /**
+     * Executes the DELETE query using the provided session
+     * @param session - The ORM session to execute the query with
+     * @returns A promise that resolves to the query results
+     */
+    execute(session: OrmSession): Promise<QueryResult[]>;
+    /**
+     * Returns the Abstract Syntax Tree (AST) representation of the query
+     * @returns The AST node for the DELETE query
+     */
     getAST(): DeleteQueryNode;
 }
 
@@ -3629,12 +4115,14 @@ declare class PostgresDialect extends SqlDialectBase {
     supportsReturning(): boolean;
 }
 
+/** Represents the differences detected in a database column's properties. */
 interface ColumnDiff {
     typeChanged?: boolean;
     nullabilityChanged?: boolean;
     defaultChanged?: boolean;
     autoIncrementChanged?: boolean;
 }
+/** Represents a column in the database schema. */
 interface DatabaseColumn {
     name: string;
     type: string;
@@ -3646,16 +4134,19 @@ interface DatabaseColumn {
     references?: ForeignKeyReference;
     check?: string;
 }
+/** Represents an index in the database schema. */
 interface DatabaseIndex {
     name: string;
     columns: IndexColumn[];
     unique?: boolean;
     where?: string;
 }
+/** Represents a check constraint in the database schema. */
 interface DatabaseCheck {
     name?: string;
     expression: string;
 }
+/** Represents a table in the database schema. */
 interface DatabaseTable {
     name: string;
     schema?: string;
@@ -3664,45 +4155,90 @@ interface DatabaseTable {
     indexes?: DatabaseIndex[];
     checks?: DatabaseCheck[];
 }
+/** Represents the overall database schema. */
 interface DatabaseSchema {
     tables: DatabaseTable[];
 }
 
+/** The name of a database dialect. */
 type DialectName = 'postgres' | 'mysql' | 'sqlite' | 'mssql' | (string & {});
+/** Interface for schema dialect implementations that handle database-specific DDL operations. */
 interface SchemaDialect {
+    /** The name of the dialect. */
     readonly name: DialectName;
+    /** Quotes an identifier for use in SQL. */
     quoteIdentifier(id: string): string;
+    /** Formats the table name for SQL. */
     formatTableName(table: TableDef | DatabaseTable): string;
+    /** Renders the column type for SQL. */
     renderColumnType(column: ColumnDef): string;
+    /** Renders the default value for SQL. */
     renderDefault(value: unknown, column: ColumnDef): string;
+    /** Renders the auto-increment clause for SQL. */
     renderAutoIncrement(column: ColumnDef, table: TableDef): string | undefined;
+    /** Renders a foreign key reference for SQL. */
     renderReference(ref: ForeignKeyReference, table: TableDef): string;
+    /** Renders an index for SQL. */
     renderIndex(table: TableDef, index: IndexDef): string;
+    /** Renders table options for SQL. */
     renderTableOptions(table: TableDef): string | undefined;
+    /** Checks if the dialect supports partial indexes. */
     supportsPartialIndexes(): boolean;
+    /** Checks if the dialect prefers inline primary key auto-increment. */
+    preferInlinePkAutoincrement(column: ColumnDef, table: TableDef, pk: string[]): boolean;
+    /** Generates SQL to drop a column. */
     dropColumnSql?(table: DatabaseTable, column: string): string[];
+    /** Generates SQL to drop an index. */
     dropIndexSql?(table: DatabaseTable, index: string): string[];
+    /** Generates SQL to drop a table. */
     dropTableSql?(table: DatabaseTable): string[];
+    /** Returns a warning message for dropping a column. */
     warnDropColumn?(table: DatabaseTable, column: string): string | undefined;
+    /** Generates SQL to alter a column. */
     alterColumnSql?(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string[];
+    /** Returns a warning message for altering a column. */
     warnAlterColumn?(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string | undefined;
 }
 
+/** Result of generating schema SQL. */
 interface SchemaGenerateResult {
     tableSql: string;
     indexSql: string[];
 }
+/** Options for rendering column definitions. */
 interface RenderColumnOptions {
     includePrimary?: boolean;
 }
+/**
+ * Renders a column definition for SQL.
+ * @param table - The table definition.
+ * @param col - The column definition.
+ * @param dialect - The schema dialect.
+ * @param options - Options for rendering.
+ * @returns The rendered SQL and whether primary key is inline.
+ */
 declare const renderColumnDefinition: (table: TableDef, col: ColumnDef, dialect: SchemaDialect, options?: RenderColumnOptions) => {
     sql: string;
     inlinePrimary: boolean;
 };
+/**
+ * Generates SQL to create a table.
+ * @param table - The table definition.
+ * @param dialect - The schema dialect.
+ * @returns The table SQL and index SQL.
+ */
 declare const generateCreateTableSql: (table: TableDef, dialect: SchemaDialect) => SchemaGenerateResult;
+/**
+ * Generates SQL for creating multiple tables.
+ * @param tables - The table definitions.
+ * @param dialect - The schema dialect.
+ * @returns The SQL statements.
+ */
 declare const generateSchemaSql: (tables: TableDef[], dialect: SchemaDialect) => string[];
 
+/** The kind of schema change. */
 type SchemaChangeKind = 'createTable' | 'dropTable' | 'addColumn' | 'dropColumn' | 'alterColumn' | 'addIndex' | 'dropIndex';
+/** Represents a single schema change. */
 interface SchemaChange {
     kind: SchemaChangeKind;
     table: string;
@@ -3710,22 +4246,48 @@ interface SchemaChange {
     statements: string[];
     safe: boolean;
 }
+/** Represents a plan of schema changes. */
 interface SchemaPlan {
     changes: SchemaChange[];
     warnings: string[];
 }
+/** Options for schema diffing. */
 interface SchemaDiffOptions {
     /** Allow destructive operations (drops) */
     allowDestructive?: boolean;
 }
+/**
+ * Computes the differences between expected and actual database schemas.
+ * @param expectedTables - The expected table definitions.
+ * @param actualSchema - The actual database schema.
+ * @param dialect - The schema dialect.
+ * @param options - Options for the diff.
+ * @returns The schema plan with changes and warnings.
+ */
 declare const diffSchema: (expectedTables: TableDef[], actualSchema: DatabaseSchema, dialect: SchemaDialect, options?: SchemaDiffOptions) => SchemaPlan;
+/** Options for schema synchronization. */
 interface SynchronizeOptions extends SchemaDiffOptions {
     dryRun?: boolean;
 }
+/**
+ * Synchronizes the database schema with the expected tables.
+ * @param expectedTables - The expected table definitions.
+ * @param actualSchema - The actual database schema.
+ * @param dialect - The schema dialect.
+ * @param executor - The database executor.
+ * @param options - Options for synchronization.
+ * @returns The schema plan with changes and warnings.
+ */
 declare const synchronizeSchema: (expectedTables: TableDef[], actualSchema: DatabaseSchema, dialect: SchemaDialect, executor: DbExecutor, options?: SynchronizeOptions) => Promise<SchemaPlan>;
 
+/**
+ * Context for schema introspection operations.
+ * Provides the necessary components to perform database schema introspection.
+ */
 interface IntrospectContext {
+    /** The database dialect used for introspection. */
     dialect: Dialect;
+    /** The database executor for running introspection queries. */
     executor: DbExecutor;
 }
 
@@ -3750,342 +4312,528 @@ interface SchemaIntrospector {
  */
 declare const introspectSchema: (executor: DbExecutor, dialect: DialectName, options?: IntrospectOptions) => Promise<DatabaseSchema>;
 
+/**
+ * Registers a schema introspector for a dialect.
+ * @param dialect - The dialect name.
+ * @param introspector - The schema introspector.
+ */
 declare const registerSchemaIntrospector: (dialect: DialectName, introspector: SchemaIntrospector) => void;
+/**
+ * Gets the schema introspector for a dialect.
+ * @param dialect - The dialect name.
+ * @returns The schema introspector or undefined if not found.
+ */
 declare const getSchemaIntrospector: (dialect: DialectName) => SchemaIntrospector | undefined;
 
 type OperandInput$2 = OperandNode | ColumnDef | string | number | boolean | null;
 /**
- * Helper: LOWER(str)
+ * Converts a string to lowercase.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the LOWER SQL function.
  */
 declare const lower: (value: OperandInput$2) => FunctionNode;
 /**
- * Helper: UPPER(str)
+ * Converts a string to uppercase.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the UPPER SQL function.
  */
 declare const upper: (value: OperandInput$2) => FunctionNode;
 /**
- * Helper: ASCII(str)
+ * Returns the ASCII code of the first character of a string.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the ASCII SQL function.
  */
 declare const ascii: (value: OperandInput$2) => FunctionNode;
 /**
- * Helper: CHAR(code[, code...])
+ * Returns a string from one or more ASCII codes.
+ * @param codes - The ASCII codes.
+ * @returns A FunctionNode representing the CHAR SQL function.
  */
 declare const char: (...codes: OperandInput$2[]) => FunctionNode;
 /**
- * Helper: CHAR_LENGTH(str)
+ * Returns the number of characters in a string.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the CHAR_LENGTH SQL function.
  */
 declare const charLength: (value: OperandInput$2) => FunctionNode;
 /**
- * Helper: LENGTH(str)
+ * Returns the length of a string in bytes or characters.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the LENGTH SQL function.
  */
 declare const length: (value: OperandInput$2) => FunctionNode;
 /**
- * Helper: TRIM([chars FROM] str)
+ * Removes leading and trailing whitespace or specified characters from a string.
+ * @param value - The string value.
+ * @param chars - The characters to trim (optional).
+ * @returns A FunctionNode representing the TRIM SQL function.
  */
 declare const trim: (value: OperandInput$2, chars?: OperandInput$2) => FunctionNode;
 /**
- * Helper: LTRIM(str)
+ * Removes leading whitespace from a string.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the LTRIM SQL function.
  */
 declare const ltrim: (value: OperandInput$2) => FunctionNode;
 /**
- * Helper: RTRIM(str)
+ * Removes trailing whitespace from a string.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the RTRIM SQL function.
  */
 declare const rtrim: (value: OperandInput$2) => FunctionNode;
 /**
- * Helper: CONCAT(arg1, arg2, ...)
+ * Concatenates two or more strings.
+ * @param args - The strings to concatenate.
+ * @returns A FunctionNode representing the CONCAT SQL function.
  */
 declare const concat: (...args: OperandInput$2[]) => FunctionNode;
 /**
- * Helper: CONCAT_WS(separator, arg1, arg2, ...)
+ * Concatenates strings with a separator.
+ * @param separator - The separator string.
+ * @param args - The strings to concatenate.
+ * @returns A FunctionNode representing the CONCAT_WS SQL function.
  */
 declare const concatWs: (separator: OperandInput$2, ...args: OperandInput$2[]) => FunctionNode;
 /**
- * Helper: SUBSTR(str, start[, length])
+ * Extracts a substring from a string.
+ * @param value - The string value.
+ * @param start - The starting position.
+ * @param length - The length of the substring (optional).
+ * @returns A FunctionNode representing the SUBSTR SQL function.
  */
 declare const substr: (value: OperandInput$2, start: OperandInput$2, length?: OperandInput$2) => FunctionNode;
 /**
- * Helper: LEFT(str, length)
+ * Returns the leftmost characters of a string.
+ * @param value - The string value.
+ * @param len - The number of characters to return.
+ * @returns A FunctionNode representing the LEFT SQL function.
  */
 declare const left: (value: OperandInput$2, len: OperandInput$2) => FunctionNode;
 /**
- * Helper: RIGHT(str, length)
+ * Returns the rightmost characters of a string.
+ * @param value - The string value.
+ * @param len - The number of characters to return.
+ * @returns A FunctionNode representing the RIGHT SQL function.
  */
 declare const right: (value: OperandInput$2, len: OperandInput$2) => FunctionNode;
 /**
- * Helper: POSITION(substring IN string)
+ * Returns the position of a substring in a string.
+ * @param substring - The substring to search for.
+ * @param value - The string to search in.
+ * @returns A FunctionNode representing the POSITION SQL function.
  */
 declare const position: (substring: OperandInput$2, value: OperandInput$2) => FunctionNode;
 /**
- * Helper: INSTR(string, substring)
+ * Returns the position of a substring in a string.
+ * @param value - The string to search in.
+ * @param substring - The substring to search for.
+ * @returns A FunctionNode representing the INSTR SQL function.
  */
 declare const instr: (value: OperandInput$2, substring: OperandInput$2) => FunctionNode;
 /**
- * Helper: LOCATE(substring, string[, start])
+ * Returns the position of a substring in a string, optionally starting from a position.
+ * @param substring - The substring to search for.
+ * @param value - The string to search in.
+ * @param start - The starting position (optional).
+ * @returns A FunctionNode representing the LOCATE SQL function.
  */
 declare const locate: (substring: OperandInput$2, value: OperandInput$2, start?: OperandInput$2) => FunctionNode;
 /**
- * Helper: REPLACE(string, search, replace)
+ * Replaces occurrences of a substring in a string.
+ * @param value - The string to search in.
+ * @param search - The substring to replace.
+ * @param replacement - The replacement string.
+ * @returns A FunctionNode representing the REPLACE SQL function.
  */
 declare const replace: (value: OperandInput$2, search: OperandInput$2, replacement: OperandInput$2) => FunctionNode;
 /**
- * Helper: REPEAT(string, count)
+ * Repeats a string a specified number of times.
+ * @param value - The string to repeat.
+ * @param count - The number of times to repeat.
+ * @returns A FunctionNode representing the REPEAT SQL function.
  */
 declare const repeat: (value: OperandInput$2, count: OperandInput$2) => FunctionNode;
 /**
- * Helper: LPAD(string, length, padstr)
+ * Left-pads a string to a certain length with another string.
+ * @param value - The string to pad.
+ * @param len - The length to pad to.
+ * @param pad - The padding string.
+ * @returns A FunctionNode representing the LPAD SQL function.
  */
 declare const lpad: (value: OperandInput$2, len: OperandInput$2, pad: OperandInput$2) => FunctionNode;
 /**
- * Helper: RPAD(string, length, padstr)
+ * Right-pads a string to a certain length with another string.
+ * @param value - The string to pad.
+ * @param len - The length to pad to.
+ * @param pad - The padding string.
+ * @returns A FunctionNode representing the RPAD SQL function.
  */
 declare const rpad: (value: OperandInput$2, len: OperandInput$2, pad: OperandInput$2) => FunctionNode;
 /**
- * Helper: SPACE(count)
+ * Returns a string consisting of a specified number of spaces.
+ * @param count - The number of spaces.
+ * @returns A FunctionNode representing the SPACE SQL function.
  */
 declare const space: (count: OperandInput$2) => FunctionNode;
 
 type OperandInput$1 = OperandNode | ColumnDef | string | number | boolean | null;
 /**
- * Helper: ABS(x) - Returns the absolute value of a number
+ * Returns the absolute value of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the ABS SQL function.
  */
 declare const abs: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: ACOS(x) - Returns the arccosine (inverse cosine)
+ * Returns the arccosine (inverse cosine) of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the ACOS SQL function.
  */
 declare const acos: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: ASIN(x) - Returns the arcsine (inverse sine)
+ * Returns the arcsine (inverse sine) of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the ASIN SQL function.
  */
 declare const asin: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: ATAN(x) - Returns the arctangent (inverse tangent)
+ * Returns the arctangent (inverse tangent) of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the ATAN SQL function.
  */
 declare const atan: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: ATAN2(y, x) - Returns the arctangent of the two arguments
+ * Returns the arctangent of the two arguments.
+ * @param y - The y-coordinate.
+ * @param x - The x-coordinate.
+ * @returns A FunctionNode representing the ATAN2 SQL function.
  */
 declare const atan2: (y: OperandInput$1, x: OperandInput$1) => FunctionNode;
 /**
- * Helper: CEIL(x) / CEILING(x) - Returns the smallest integer >= x
+ * Returns the smallest integer greater than or equal to a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the CEIL SQL function.
  */
 declare const ceil: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: CEILING(x) - Alias for CEIL
+ * Alias for ceil. Returns the smallest integer greater than or equal to a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the CEILING SQL function.
  */
 declare const ceiling: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: COS(x) - Returns the cosine of a number (in radians)
+ * Returns the cosine of a number (in radians).
+ * @param value - The numeric value in radians.
+ * @returns A FunctionNode representing the COS SQL function.
  */
 declare const cos: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: COT(x) - Returns the cotangent of a number
+ * Returns the cotangent of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the COT SQL function.
  */
 declare const cot: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: DEGREES(x) - Converts radians to degrees
+ * Converts radians to degrees.
+ * @param value - The angle in radians.
+ * @returns A FunctionNode representing the DEGREES SQL function.
  */
 declare const degrees: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: EXP(x) - Returns e raised to the power of the argument
+ * Returns e raised to the power of the argument.
+ * @param value - The exponent.
+ * @returns A FunctionNode representing the EXP SQL function.
  */
 declare const exp: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: FLOOR(x) - Returns the largest integer <= x
+ * Returns the largest integer less than or equal to a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the FLOOR SQL function.
  */
 declare const floor: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: LN(x) - Returns the natural logarithm (base e)
+ * Returns the natural logarithm (base e) of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the LN SQL function.
  */
 declare const ln: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: LOG(x) - Returns the base-10 logarithm
+ * Returns the base-10 logarithm of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the LOG SQL function.
  */
 declare const log: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: LOG10(x) - Returns the base-10 logarithm
+ * Returns the base-10 logarithm of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the LOG10 SQL function.
  */
 declare const log10: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: LOG(base, x) - Returns the logarithm of x for a specific base
+ * Returns the logarithm of a number for a specific base.
+ * @param base - The base of the logarithm.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the LOG_BASE SQL function.
  */
 declare const logBase: (base: OperandInput$1, value: OperandInput$1) => FunctionNode;
 /**
- * Helper: MOD(x, y) - Returns the remainder of x/y
+ * Returns the remainder of dividing x by y.
+ * @param x - The dividend.
+ * @param y - The divisor.
+ * @returns A FunctionNode representing the MOD SQL function.
  */
 declare const mod: (x: OperandInput$1, y: OperandInput$1) => FunctionNode;
 /**
- * Helper: PI() - Returns the value of PI (approx. 3.14159...)
+ * Returns the value of PI (approximately 3.14159...).
+ * @returns A FunctionNode representing the PI SQL function.
  */
 declare const pi: () => FunctionNode;
 /**
- * Helper: POWER(x, y) - Returns x raised to the power of y
+ * Returns x raised to the power of y.
+ * @param x - The base.
+ * @param y - The exponent.
+ * @returns A FunctionNode representing the POWER SQL function.
  */
 declare const power: (x: OperandInput$1, y: OperandInput$1) => FunctionNode;
 /**
- * Helper: POW(x, y) - Alias for POWER
+ * Alias for power. Returns x raised to the power of y.
+ * @param x - The base.
+ * @param y - The exponent.
+ * @returns A FunctionNode representing the POW SQL function.
  */
 declare const pow: (x: OperandInput$1, y: OperandInput$1) => FunctionNode;
 /**
- * Helper: RADIANS(x) - Converts degrees to radians
+ * Converts degrees to radians.
+ * @param value - The angle in degrees.
+ * @returns A FunctionNode representing the RADIANS SQL function.
  */
 declare const radians: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: RAND() / RANDOM() - Returns a random number
+ * Returns a random number between 0 and 1.
+ * @returns A FunctionNode representing the RANDOM SQL function.
  */
 declare const random: () => FunctionNode;
 /**
- * Helper: RAND() - Alias for RANDOM (returns float 0-1)
+ * Alias for random. Returns a random number between 0 and 1.
+ * @returns A FunctionNode representing the RAND SQL function.
  */
 declare const rand: () => FunctionNode;
 /**
- * Helper: ROUND(x[, decimals]) - Rounds a number to specified decimal places
+ * Rounds a number to a specified number of decimal places.
+ * @param value - The numeric value to round.
+ * @param decimals - The number of decimal places (optional).
+ * @returns A FunctionNode representing the ROUND SQL function.
  */
 declare const round: (value: OperandInput$1, decimals?: OperandInput$1) => FunctionNode;
 /**
- * Helper: SIGN(x) - Returns the sign of a number (-1, 0, 1)
+ * Returns the sign of a number (-1 for negative, 0 for zero, 1 for positive).
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the SIGN SQL function.
  */
 declare const sign: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: SIN(x) - Returns the sine of a number (in radians)
+ * Returns the sine of a number (in radians).
+ * @param value - The numeric value in radians.
+ * @returns A FunctionNode representing the SIN SQL function.
  */
 declare const sin: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: SQRT(x) - Returns the square root of a number
+ * Returns the square root of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the SQRT SQL function.
  */
 declare const sqrt: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: TAN(x) - Returns the tangent of a number (in radians)
+ * Returns the tangent of a number (in radians).
+ * @param value - The numeric value in radians.
+ * @returns A FunctionNode representing the TAN SQL function.
  */
 declare const tan: (value: OperandInput$1) => FunctionNode;
 /**
- * Helper: TRUNC(x[, decimals]) / TRUNCATE(x, decimals) - Truncates a number without rounding
+ * Truncates a number to a specified number of decimal places without rounding.
+ * @param value - The numeric value to truncate.
+ * @param decimals - The number of decimal places (optional).
+ * @returns A FunctionNode representing the TRUNC SQL function.
  */
 declare const trunc: (value: OperandInput$1, decimals?: OperandInput$1) => FunctionNode;
 /**
- * Helper: TRUNCATE(x, decimals) - Alias for TRUNC
+ * Alias for trunc. Truncates a number to a specified number of decimal places without rounding.
+ * @param value - The numeric value to truncate.
+ * @param decimals - The number of decimal places.
+ * @returns A FunctionNode representing the TRUNCATE SQL function.
  */
 declare const truncate: (value: OperandInput$1, decimals: OperandInput$1) => FunctionNode;
 
 type OperandInput = OperandNode | ColumnDef | string | number | boolean | null;
 /**
- * Helper: NOW() - Returns the current local date and time
+ * Returns the current local date and time.
+ * @returns A FunctionNode representing the NOW() SQL function.
  */
 declare const now: () => FunctionNode;
 /**
- * Helper: CURRENT_DATE - Returns only the current date (no time)
+ * Returns the current date without time.
+ * @returns A FunctionNode representing the CURRENT_DATE SQL function.
  */
 declare const currentDate: () => FunctionNode;
 /**
- * Helper: CURRENT_TIME - Returns only the current time
+ * Returns the current time without date.
+ * @returns A FunctionNode representing the CURRENT_TIME SQL function.
  */
 declare const currentTime: () => FunctionNode;
 /**
- * Helper: UTC_NOW() - Returns current UTC/GMT date and time
+ * Returns the current UTC date and time.
+ * @returns A FunctionNode representing the UTC_NOW() SQL function.
  */
 declare const utcNow: () => FunctionNode;
 /**
- * Helper: EXTRACT(part FROM date) - Extracts a part (year, month, day, hour, etc.) from a date
- * @param part - The date part to extract (e.g., 'YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'SECOND')
- * @param date - The date/datetime value
+ * Extracts a specified part from a date or datetime value.
+ * @param part - The date part to extract (e.g., 'YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'SECOND').
+ * @param date - The date or datetime value to extract from.
+ * @returns A FunctionNode representing the EXTRACT SQL function.
  */
 declare const extract: (part: OperandInput, date: OperandInput) => FunctionNode;
 /**
- * Helper: YEAR(date) - Extracts the year from a date
+ * Extracts the year from a date or datetime value.
+ * @param date - The date or datetime value.
+ * @returns A FunctionNode representing the YEAR SQL function.
  */
 declare const year: (date: OperandInput) => FunctionNode;
 /**
- * Helper: MONTH(date) - Extracts the month from a date
+ * Extracts the month from a date or datetime value.
+ * @param date - The date or datetime value.
+ * @returns A FunctionNode representing the MONTH SQL function.
  */
 declare const month: (date: OperandInput) => FunctionNode;
 /**
- * Helper: DAY(date) - Extracts the day from a date
+ * Extracts the day of the month from a date or datetime value.
+ * @param date - The date or datetime value.
+ * @returns A FunctionNode representing the DAY SQL function.
  */
 declare const day: (date: OperandInput) => FunctionNode;
 /**
- * Helper: DATE_ADD(date, interval, unit) - Adds a specific time interval to a date
- * @param date - The date/datetime value
- * @param interval - The number of units to add
- * @param unit - The unit type (e.g., 'DAY', 'MONTH', 'YEAR', 'HOUR', 'MINUTE', 'SECOND')
+ * Adds a specified time interval to a date or datetime value.
+ * @param date - The date or datetime value to add to.
+ * @param interval - The number of units to add.
+ * @param unit - The unit type (e.g., 'DAY', 'MONTH', 'YEAR', 'HOUR', 'MINUTE', 'SECOND').
+ * @returns A FunctionNode representing the DATE_ADD SQL function.
  */
 declare const dateAdd: (date: OperandInput, interval: OperandInput, unit: OperandInput) => FunctionNode;
 /**
- * Helper: DATE_SUB(date, interval, unit) - Subtracts a specific time interval from a date
- * @param date - The date/datetime value
- * @param interval - The number of units to subtract
- * @param unit - The unit type (e.g., 'DAY', 'MONTH', 'YEAR', 'HOUR', 'MINUTE', 'SECOND')
+ * Subtracts a specified time interval from a date or datetime value.
+ * @param date - The date or datetime value to subtract from.
+ * @param interval - The number of units to subtract.
+ * @param unit - The unit type (e.g., 'DAY', 'MONTH', 'YEAR', 'HOUR', 'MINUTE', 'SECOND').
+ * @returns A FunctionNode representing the DATE_SUB SQL function.
  */
 declare const dateSub: (date: OperandInput, interval: OperandInput, unit: OperandInput) => FunctionNode;
 /**
- * Helper: DATE_DIFF(date1, date2) - Returns the difference between two dates in days
- * @param date1 - The end date
- * @param date2 - The start date
+ * Returns the difference between two dates in days.
+ * @param date1 - The end date.
+ * @param date2 - The start date.
+ * @returns A FunctionNode representing the DATE_DIFF SQL function.
  */
 declare const dateDiff: (date1: OperandInput, date2: OperandInput) => FunctionNode;
 /**
- * Helper: DATE_FORMAT(date, format) - Converts a date to a formatted string
- * @param date - The date/datetime value
- * @param format - The format string (dialect-specific)
+ * Converts a date or datetime value to a formatted string.
+ * @param date - The date or datetime value to format.
+ * @param format - The format string (dialect-specific).
+ * @returns A FunctionNode representing the DATE_FORMAT SQL function.
  */
 declare const dateFormat: (date: OperandInput, format: OperandInput) => FunctionNode;
 /**
- * Helper: UNIX_TIMESTAMP() - Returns the current Unix epoch (seconds since 1970)
+ * Returns the current Unix timestamp (seconds since 1970-01-01 00:00:00 UTC).
+ * @returns A FunctionNode representing the UNIX_TIMESTAMP SQL function.
  */
 declare const unixTimestamp: () => FunctionNode;
 /**
- * Helper: FROM_UNIXTIME(timestamp) - Converts Unix epoch seconds to a date
- * @param timestamp - Unix timestamp in seconds
+ * Converts a Unix timestamp (seconds since 1970-01-01 00:00:00 UTC) to a date.
+ * @param timestamp - Unix timestamp in seconds.
+ * @returns A FunctionNode representing the FROM_UNIXTIME SQL function.
  */
 declare const fromUnixTime: (timestamp: OperandInput) => FunctionNode;
 /**
- * Helper: END_OF_MONTH(date) - Returns the last day of the month for a given date
+ * Returns the last day of the month for a given date.
+ * @param date - The date value.
+ * @returns A FunctionNode representing the END_OF_MONTH SQL function.
  */
 declare const endOfMonth: (date: OperandInput) => FunctionNode;
 /**
- * Helper: DAY_OF_WEEK(date) - Returns the index of the weekday
+ * Returns the index of the weekday for a given date (1 = Sunday, 2 = Monday, etc.).
+ * @param date - The date value.
+ * @returns A FunctionNode representing the DAY_OF_WEEK SQL function.
  */
 declare const dayOfWeek: (date: OperandInput) => FunctionNode;
 /**
- * Helper: WEEK_OF_YEAR(date) - Returns the week number of the year
+ * Returns the week number of the year for a given date.
+ * @param date - The date value.
+ * @returns A FunctionNode representing the WEEK_OF_YEAR SQL function.
  */
 declare const weekOfYear: (date: OperandInput) => FunctionNode;
 /**
- * Helper: DATE_TRUNC(part, date) - Resets date precision (e.g., first day of the month/year)
- * @param part - The truncation precision (e.g., 'YEAR', 'MONTH', 'DAY')
- * @param date - The date/datetime value
+ * Truncates a date or datetime value to a specified precision (e.g., first day of the month/year).
+ * @param part - The truncation precision (e.g., 'YEAR', 'MONTH', 'DAY').
+ * @param date - The date or datetime value to truncate.
+ * @returns A FunctionNode representing the DATE_TRUNC SQL function.
  */
 declare const dateTrunc: (part: OperandInput, date: OperandInput) => FunctionNode;
 
 /**
- * Browser-compatible implementation of AsyncLocalStorage
- * Provides a simple in-memory store for browser environments
- * @typeParam T - Type of the stored data
+ * Browser-compatible implementation of AsyncLocalStorage.
+ * Provides a simple in-memory store for browser environments while maintaining
+ * Node.js AsyncLocalStorage API compatibility.
+ *
+ * @template T Type of the data stored in the async context
  */
 declare class AsyncLocalStorage<T> {
     private store;
     /**
-     * Executes a callback with the specified store value
-     * @param store - Value to store during callback execution
-     * @param callback - Function to execute with the store value
-     * @returns Result of the callback function
+     * Executes a callback function within a context containing the specified store value.
+     * The store value is only available during the callback's execution and is automatically
+     * cleared afterward.
+     *
+     * @param store - The context value to make available during callback execution
+     * @param callback - Function to execute with the store value available
+     * @returns Result of the callback function execution
+     *
+     * @example
+     * ```
+     * const als = new AsyncLocalStorage<number>();
+     * als.run(42, () => {
+     *   console.log(als.getStore()); // Outputs: 42
+     * });
+     * ```
      */
     run<R>(store: T, callback: () => R): R;
     /**
-     * Gets the currently stored value
-     * @returns Current store value or undefined if none exists
+     * Retrieves the current store value from the async context.
+     * Returns undefined if called outside of a `run()` callback execution.
+     *
+     * @returns Current store value or undefined if no context exists
+     *
+     * @example
+     * ```
+     * const als = new AsyncLocalStorage<string>();
+     * console.log(als.getStore()); // Outputs: undefined
+     *
+     * als.run('hello', () => {
+     *   console.log(als.getStore()); // Outputs: 'hello'
+     * });
+     * ```
      */
     getStore(): T | undefined;
 }
 
+/**
+ * Hydrates query results according to a hydration plan
+ * @param rows - Raw database rows
+
 /**
  * Hydrates query results according to a hydration plan
  * @param rows - Raw database rows
  * @param plan - Hydration plan
  * @returns Hydrated result objects with nested relations
  */
-declare const hydrateRows: (rows: Record<string, any>[], plan?: HydrationPlan) => Record<string, any>[];
+declare const hydrateRows: (rows: Record<string, unknown>[], plan?: HydrationPlan) => Record<string, unknown>[];
 
-/**
- * Generates TypeScript code from query AST nodes
- */
 declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVisitor<string> {
     private namingStrategy;
     constructor(namingStrategy?: NamingStrategy);
@@ -4117,6 +4865,8 @@ declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandV
      * Prints an ordering term (operand/expression/alias) to TypeScript code.
      */
     private printOrderingTerm;
+    private getSelectionKey;
+    private isNamedSelection;
     visitBinaryExpression(binary: BinaryExpressionNode): string;
     visitLogicalExpression(logical: LogicalExpressionNode): string;
     visitNullExpression(nullExpr: NullExpressionNode): string;
@@ -4235,7 +4985,7 @@ declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandV
  * @param lazyRelations - Optional lazy relations
  * @returns The entity instance
  */
-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 createEntityProxy: <TTable extends TableDef, TLazy extends keyof RelationMap<TTable> = keyof RelationMap<TTable>>(ctx: EntityContext, table: TTable, row: Record<string, unknown>, lazyRelations?: TLazy[]) => EntityInstance<TTable>;
 /**
  * Creates an entity instance from a database row.
  * @template TTable - The table type
@@ -4246,12 +4996,12 @@ declare const createEntityProxy: <TTable extends TableDef, TLazy extends keyof R
  * @param lazyRelations - Optional lazy relations
  * @returns The entity instance
  */
-declare const createEntityFromRow: <TTable extends TableDef, TResult extends EntityInstance<TTable> = EntityInstance<TTable>>(ctx: EntityContext, table: TTable, row: Record<string, any>, lazyRelations?: (keyof RelationMap<TTable>)[]) => TResult;
+declare const createEntityFromRow: <TTable extends TableDef, TResult extends EntityInstance<TTable> = EntityInstance<TTable>>(ctx: EntityContext, table: TTable, row: Record<string, unknown>, lazyRelations?: (keyof RelationMap<TTable>)[]) => TResult;
 
-type Rows$3 = Record<string, any>[];
+type Rows$3 = Record<string, unknown>[];
 declare const loadHasManyRelation: (ctx: EntityContext, rootTable: TableDef, _relationName: string, relation: HasManyRelation) => Promise<Map<string, Rows$3>>;
-declare const loadHasOneRelation: (ctx: EntityContext, rootTable: TableDef, _relationName: string, relation: HasOneRelation) => Promise<Map<string, Record<string, any>>>;
-declare const loadBelongsToRelation: (ctx: EntityContext, rootTable: TableDef, _relationName: string, relation: BelongsToRelation) => Promise<Map<string, Record<string, any>>>;
+declare const loadHasOneRelation: (ctx: EntityContext, rootTable: TableDef, _relationName: string, relation: HasOneRelation) => Promise<Map<string, Record<string, unknown>>>;
+declare const loadBelongsToRelation: (ctx: EntityContext, rootTable: TableDef, _relationName: string, relation: BelongsToRelation) => Promise<Map<string, Record<string, unknown>>>;
 declare const loadBelongsToManyRelation: (ctx: EntityContext, rootTable: TableDef, _relationName: string, relation: BelongsToManyRelation) => Promise<Map<string, Rows$3>>;
 
 /**
@@ -4266,14 +5016,18 @@ interface EntityMeta<TTable extends TableDef> {
     /** Relations that should be loaded lazily */
     lazyRelations: (keyof RelationMap<TTable>)[];
     /** Cache for relation promises */
-    relationCache: Map<string, Promise<any>>;
+    relationCache: Map<string, Promise<unknown>>;
     /** Hydration data for relations */
-    relationHydration: Map<string, Map<string, any>>;
+    relationHydration: Map<string, Map<string, unknown>>;
     /** Relation wrapper instances */
     relationWrappers: Map<string, unknown>;
 }
 
-type Rows$2 = Record<string, any>[];
+type Rows$2 = Record<string, unknown>[];
+/**
+ * Default implementation of HasManyCollection for managing one-to-many relationships.
+ * @template TChild - The type of child entities in the collection
+ */
 declare class DefaultHasManyCollection<TChild> implements HasManyCollection<TChild> {
     private readonly ctx;
     private readonly meta;
@@ -4288,19 +5042,59 @@ declare class DefaultHasManyCollection<TChild> implements HasManyCollection<TChi
     private items;
     private readonly added;
     private readonly removed;
-    constructor(ctx: EntityContext, meta: EntityMeta<any>, root: any, relationName: string, relation: HasManyRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows$2>>, createEntity: (row: Record<string, any>) => TChild, localKey: string);
+    /**
+     * Creates a new DefaultHasManyCollection instance.
+     * @param ctx - The entity context
+     * @param meta - The entity metadata
+     * @param root - The root entity
+     * @param relationName - The relation name
+     * @param relation - The relation definition
+     * @param rootTable - The root table definition
+     * @param loader - The loader function for lazy loading
+     * @param createEntity - Function to create entities from rows
+     * @param localKey - The local key for the relation
+     */
+    constructor(ctx: EntityContext, meta: EntityMeta<TableDef>, root: unknown, relationName: string, relation: HasManyRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows$2>>, createEntity: (row: Record<string, unknown>) => TChild, localKey: string);
+    /**
+     * Loads the related entities if not already loaded.
+     * @returns Promise resolving to the array of child entities
+     */
     load(): Promise<TChild[]>;
+    /**
+     * Gets the current items in the collection.
+     * @returns Array of child entities
+     */
     getItems(): TChild[];
+    /**
+     * Adds a new child entity to the collection.
+     * @param data - Partial data for the new entity
+     * @returns The created entity
+     */
     add(data: Partial<TChild>): TChild;
+    /**
+     * Attaches an existing entity to the collection.
+     * @param entity - The entity to attach
+     */
     attach(entity: TChild): void;
+    /**
+     * Removes an entity from the collection.
+     * @param entity - The entity to remove
+     */
     remove(entity: TChild): void;
+    /**
+     * Clears all entities from the collection.
+     */
     clear(): void;
     private get relationKey();
     private hydrateFromCache;
+    /**
+     * Returns the items for JSON serialization.
+     * @returns Array of child entities
+     */
     toJSON(): TChild[];
 }
 
-type Rows$1 = Record<string, any>;
+type Rows$1 = Record<string, unknown>;
 declare class DefaultBelongsToReference<TParent> implements BelongsToReference<TParent> {
     private readonly ctx;
     private readonly meta;
@@ -4313,7 +5107,7 @@ declare class DefaultBelongsToReference<TParent> implements BelongsToReference<T
     private readonly targetKey;
     private loaded;
     private current;
-    constructor(ctx: EntityContext, meta: EntityMeta<any>, root: any, relationName: string, relation: BelongsToRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows$1>>, createEntity: (row: Record<string, any>) => TParent, targetKey: string);
+    constructor(ctx: EntityContext, meta: EntityMeta<TableDef>, root: unknown, relationName: string, relation: BelongsToRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows$1>>, createEntity: (row: Record<string, unknown>) => TParent, targetKey: string);
     load(): Promise<TParent | null>;
     get(): TParent | null;
     set(data: Partial<TParent> | TParent | null): TParent | null;
@@ -4322,7 +5116,7 @@ declare class DefaultBelongsToReference<TParent> implements BelongsToReference<T
     toJSON(): TParent | null;
 }
 
-type Rows = Record<string, any>[];
+type Rows = Record<string, unknown>[];
 declare class DefaultManyToManyCollection<TTarget> implements ManyToManyCollection<TTarget> {
     private readonly ctx;
     private readonly meta;
@@ -4335,7 +5129,7 @@ declare class DefaultManyToManyCollection<TTarget> implements ManyToManyCollecti
     private readonly localKey;
     private loaded;
     private items;
-    constructor(ctx: EntityContext, meta: EntityMeta<any>, root: any, relationName: string, relation: BelongsToManyRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows>>, createEntity: (row: Record<string, any>) => TTarget, localKey: string);
+    constructor(ctx: EntityContext, meta: EntityMeta<TableDef>, root: unknown, relationName: string, relation: BelongsToManyRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows>>, createEntity: (row: Record<string, unknown>) => TTarget, localKey: string);
     load(): Promise<TTarget[]>;
     getItems(): TTarget[];
     attach(target: TTarget | number | string): void;
@@ -4349,32 +5143,66 @@ declare class DefaultManyToManyCollection<TTarget> implements ManyToManyCollecti
     toJSON(): TTarget[];
 }
 
-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>[]>;
+/**
+ * Executes a hydrated query using the ORM session.
+ * @template TTable - The table type
+ * @param session - The ORM session
+ * @param qb - The select query builder
+ * @returns Promise resolving to array of entity instances
+ */
+declare function executeHydrated<TTable extends TableDef>(session: OrmSession, qb: SelectQueryBuilder<unknown, TTable>): Promise<EntityInstance<TTable>[]>;
+/**
+ * Executes a hydrated query using execution and hydration contexts.
+ * @template TTable - The table type
+ * @param _execCtx - The execution context (unused)
+ * @param hydCtx - The hydration context
+ * @param qb - The select query builder
+ * @returns Promise resolving to array of entity instances
+ */
+declare function executeHydratedWithContexts<TTable extends TableDef>(_execCtx: ExecutionContext, hydCtx: HydrationContext, qb: SelectQueryBuilder<unknown, TTable>): Promise<EntityInstance<TTable>[]>;
 
+/**
+ * Context object provided by standard decorators in newer TypeScript versions.
+ */
 interface StandardDecoratorContext {
     kind: string;
     name?: string | symbol;
     metadata?: Record<PropertyKey, unknown>;
-    addInitializer?(initializer: (this: unknown) => void): void;
     static?: boolean;
     private?: boolean;
 }
+/**
+ * Dual-mode property decorator that supports both legacy and standard decorator syntax.
+ */
 interface DualModePropertyDecorator {
     (target: object, propertyKey: string | symbol): void;
     (value: unknown, context: StandardDecoratorContext): void;
 }
+/**
+ * Dual-mode class decorator that supports both legacy and standard decorator syntax.
+ */
 interface DualModeClassDecorator {
     <TFunction extends Function>(value: TFunction): void | TFunction;
     <TFunction extends Function>(value: TFunction, context: StandardDecoratorContext): void | TFunction;
 }
 
+/**
+ * Options for defining an entity.
+ */
 interface EntityOptions {
     tableName?: string;
     hooks?: TableHooks;
 }
+/**
+ * Class decorator to mark a class as an entity and configure its table mapping.
+ * @param options - Configuration options for the entity.
+ * @returns A class decorator that registers the entity metadata.
+ */
 declare function Entity(options?: EntityOptions): DualModeClassDecorator;
 
+/**
+ * Options for defining a column in an entity.
+ */
 interface ColumnOptions {
     type: ColumnType;
     args?: ColumnDef['args'];
@@ -4382,8 +5210,22 @@ interface ColumnOptions {
     primary?: boolean;
     tsType?: ColumnDef['tsType'];
 }
-type ColumnInput = ColumnOptions | ColumnDef<any, any>;
+/**
+ * Input type for column definitions, either as options object or direct ColumnDef.
+ */
+type ColumnInput = ColumnOptions | ColumnDef;
+/**
+ * Decorator to define a column on an entity property.
+ * @param definition - The column definition or options.
+ * @returns A property decorator that registers the column metadata.
+ */
 declare function Column(definition: ColumnInput): DualModePropertyDecorator;
+/**
+ * Decorator to define a primary key column on an entity property.
+ * Sets the primary flag to true and delegates to Column decorator.
+ * @param definition - The column definition or options.
+ * @returns A property decorator that registers the primary key column metadata.
+ */
 declare function PrimaryKey(definition: ColumnInput): DualModePropertyDecorator;
 
 interface BaseRelationOptions {
@@ -4391,15 +5233,27 @@ interface BaseRelationOptions {
     cascade?: CascadeMode;
     localKey?: string;
 }
+/**
+ * Options for HasMany relation.
+ */
 interface HasManyOptions extends BaseRelationOptions {
     foreignKey: string;
 }
+/**
+ * Options for HasOne relation.
+ */
 interface HasOneOptions extends BaseRelationOptions {
     foreignKey: string;
 }
+/**
+ * Options for BelongsTo relation.
+ */
 interface BelongsToOptions extends BaseRelationOptions {
     foreignKey: string;
 }
+/**
+ * Options for BelongsToMany relation.
+ */
 interface BelongsToManyOptions {
     target: EntityOrTableTargetResolver;
     pivotTable: EntityOrTableTargetResolver;
@@ -4411,14 +5265,56 @@ interface BelongsToManyOptions {
     defaultPivotColumns?: string[];
     cascade?: CascadeMode;
 }
+/**
+ * Decorator to define a HasMany relation on an entity property.
+ * @param options - The relation options.
+ * @returns A property decorator that registers the relation metadata.
+ */
 declare function HasMany(options: HasManyOptions): DualModePropertyDecorator;
+/**
+ * Decorator to define a HasOne relation on an entity property.
+ * @param options - The relation options.
+ * @returns A property decorator that registers the relation metadata.
+ */
 declare function HasOne(options: HasOneOptions): DualModePropertyDecorator;
+/**
+ * Decorator to define a BelongsTo relation on an entity property.
+ * @param options - The relation options.
+ * @returns A property decorator that registers the relation metadata.
+ */
 declare function BelongsTo(options: BelongsToOptions): DualModePropertyDecorator;
+/**
+ * Decorator to define a BelongsToMany relation on an entity property.
+ * @param options - The relation options.
+ * @returns A property decorator that registers the relation metadata.
+ */
 declare function BelongsToMany(options: BelongsToManyOptions): DualModePropertyDecorator;
 
+/**
+ * Bootstraps all entities by building their table definitions and relations.
+ * @returns An array of table definitions for all bootstrapped entities.
+ */
 declare const bootstrapEntities: () => TableDef[];
-declare const getTableDefFromEntity: <TTable extends TableDef = TableDef>(ctor: EntityConstructor<any>) => TTable | undefined;
-declare const selectFromEntity: <TTable extends TableDef = TableDef>(ctor: EntityConstructor<any>) => SelectQueryBuilder<any, TTable>;
+/**
+ * Gets the table definition for a given entity constructor.
+ * Bootstraps entities if necessary.
+ * @param ctor - The entity constructor.
+ * @returns The table definition or undefined if not found.
+ */
+declare const getTableDefFromEntity: <TTable extends TableDef = TableDef>(ctor: EntityConstructor) => TTable | undefined;
+/**
+ * Creates a select query builder for the given entity.
+ * @param ctor - The entity constructor.
+ * @returns A select query builder for the entity.
+ */
+declare const selectFromEntity: <TTable extends TableDef = TableDef>(ctor: EntityConstructor) => SelectQueryBuilder<unknown, TTable>;
+/**
+ * Public API: opt-in ergonomic entity reference (decorator-level).
+ *
+ * Lazily bootstraps entity metadata (via getTableDefFromEntity) and returns a
+ * `tableRef(...)`-style proxy so users can write `u.id` instead of `u.columns.id`.
+ */
+declare const entityRef: <TTable extends TableDef = TableDef>(ctor: EntityConstructor) => TableRef$1<TTable>;
 
 type PoolOptions = {
     /** Maximum number of live resources (idle + leased). */
@@ -4480,7 +5376,7 @@ interface PostgresClientLike {
 declare function createPostgresExecutor(client: PostgresClientLike): DbExecutor;
 
 interface MysqlClientLike {
-    query(sql: string, params?: unknown[]): Promise<[any, any?]>;
+    query(sql: string, params?: unknown[]): Promise<[unknown, unknown?]>;
     beginTransaction?(): Promise<void>;
     commit?(): Promise<void>;
     rollback?(): Promise<void>;
@@ -4563,4 +5459,4 @@ type PooledExecutorFactoryOptions<TConn> = {
  */
 declare function createPooledExecutorFactory<TConn>(opts: PooledExecutorFactoryOptions<TConn>): DbExecutorFactory;
 
-export { type AliasRefNode, type AnyDomainEvent, type ArithmeticExpressionNode, type TableRef as AstTableRef, 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 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 InExpressionRight, 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, Pool, type PoolAdapter, type PoolLease, type PoolOptions, type PooledConnectionAdapter, 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 SelectQueryInput, type SimpleQueryRunner, SqlServerDialect, type SqliteClientLike, SqliteDialect, type SynchronizeOptions, type TableDef, type TableHooks, type TableOptions, type TableRef$1 as TableRef, type TediousColumn, type TediousConnectionLike, type TediousModule, type TediousRequest, type TediousRequestCtor, type TediousTypes, type TrackedEntity, TypeScriptGenerator, UpdateQueryBuilder, type ValueOperandInput, type WindowFunctionNode, abs, acos, add, addDomainEvent, aliasRef, 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, createPooledExecutorFactory, createPostgresExecutor, createQueryLoggingExecutor, createSqliteExecutor, createTediousExecutor, createTediousMssqlClient, currentDate, currentTime, dateAdd, dateDiff, dateFormat, dateSub, dateTrunc, day, dayOfWeek, defineTable, degrees, denseRank, diffSchema, div, endOfMonth, eq, esel, executeHydrated, executeHydratedWithContexts, exists, exp, extract, firstValue, floor, fromUnixTime, generateCreateTableSql, generateSchemaSql, getSchemaIntrospector, getTableDefFromEntity, groupConcat, gt, gte, hasMany, hasOne, hydrateRows, inList, inSubquery, 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, mul, neq, notBetween, notExists, notInList, notInSubquery, 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, sub, substr, sum, synchronizeSchema, tableRef, tan, toColumnRef, toTableRef, trim, trunc, truncate, unixTimestamp, upper, utcNow, valueToOperand, visitExpression, visitOperand, weekOfYear, windowFunction, year };
+export { type AliasRefNode, type AnyDomainEvent, type ArithmeticExpressionNode, type TableRef as AstTableRef, 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 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 InExpressionRight, 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, Pool, type PoolAdapter, type PoolLease, type PoolOptions, type PooledConnectionAdapter, 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 SelectQueryInput, type SimpleQueryRunner, SqlServerDialect, type SqliteClientLike, SqliteDialect, type SynchronizeOptions, type TableDef, type TableHooks, type TableOptions, type TableRef$1 as TableRef, type TediousColumn, type TediousConnectionLike, type TediousModule, type TediousRequest, type TediousRequestCtor, type TediousTypes, type TrackedEntity, TypeScriptGenerator, UpdateQueryBuilder, type ValueOperandInput, type WindowFunctionNode, abs, acos, add, addDomainEvent, aliasRef, 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, createEntityFromRow, createEntityProxy, createExecutorFromQueryRunner, createMssqlExecutor, createMysqlExecutor, createPooledExecutorFactory, createPostgresExecutor, createQueryLoggingExecutor, createSqliteExecutor, createTediousExecutor, createTediousMssqlClient, currentDate, currentTime, dateAdd, dateDiff, dateFormat, dateSub, dateTrunc, day, dayOfWeek, defineTable, degrees, denseRank, diffSchema, div, endOfMonth, entityRef, eq, esel, executeHydrated, executeHydratedWithContexts, exists, exp, extract, firstValue, floor, fromUnixTime, generateCreateTableSql, generateSchemaSql, getColumn, getSchemaIntrospector, getTableDefFromEntity, groupConcat, gt, gte, hasMany, hasOne, hydrateRows, inList, inSubquery, 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, mul, neq, notBetween, notExists, notInList, notInSubquery, 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, sub, substr, sum, synchronizeSchema, tableRef, tan, toColumnRef, toTableRef, trim, trunc, truncate, unixTimestamp, upper, utcNow, valueToOperand, visitExpression, visitOperand, weekOfYear, windowFunction, year };