metal-orm 1.0.15 → 1.0.17

package/dist/{select-Bkv8g8u_.d.cts → select-BPCn6MOH.d.cts}

@@ -348,6 +348,10 @@ interface TableDef<T extends Record<string, ColumnDef> = Record<string, ColumnDe
  */
 declare const defineTable: <T extends Record<string, ColumnDef>>(name: string, columns: T, relations?: Record<string, RelationDef>, hooks?: TableHooks, options?: TableOptions) => TableDef<T>;
 
+/**
+ * Resolves a relation definition to its target table type.
+ */
+type RelationTargetTable<TRel extends RelationDef> = TRel extends HasManyRelation<infer TTarget> ? TTarget : TRel extends HasOneRelation<infer TTarget> ? TTarget : TRel extends BelongsToRelation<infer TTarget> ? TTarget : TRel extends BelongsToManyRelation<infer TTarget> ? TTarget : never;
 /**
  * Maps a ColumnDef to its TypeScript type representation
  */
@@ -544,6 +548,12 @@ interface FunctionNode {
     args: OperandNode[];
     /** Optional alias for the function result */
     alias?: string;
+    /** Optional ORDER BY clause used by aggregations like GROUP_CONCAT */
+    orderBy?: OrderByNode[];
+    /** Optional separator argument used by GROUP_CONCAT-like functions */
+    separator?: OperandNode;
+    /** Optional DISTINCT modifier */
+    distinct?: boolean;
 }
 /**
  * AST node representing a JSON path expression
@@ -893,6 +903,8 @@ interface HydrationMetadata {
 interface FunctionRenderContext {
     node: FunctionNode;
     compiledArgs: string[];
+    /** Helper to compile additional operands (e.g., separators or ORDER BY columns) */
+    compileOperand: (operand: OperandNode) => string;
 }
 type FunctionRenderer = (ctx: FunctionRenderContext) => string;
 interface FunctionStrategy {
@@ -1023,6 +1035,12 @@ declare abstract class Dialect implements SelectCompiler, InsertCompiler, Update
     private readonly operandCompilers;
     protected readonly functionStrategy: FunctionStrategy;
     protected constructor(functionStrategy?: FunctionStrategy);
+    /**
+     * Creates a new Dialect instance (for testing purposes)
+     * @param functionStrategy - Optional function strategy
+     * @returns New Dialect instance
+     */
+    static create(functionStrategy?: FunctionStrategy): Dialect;
     /**
      * Registers an expression compiler for a specific node type
      * @param type - Expression node type
@@ -1577,21 +1595,48 @@ interface SimpleQueryRunner {
  */
 declare function createExecutorFromQueryRunner(runner: SimpleQueryRunner): DbExecutor;
 
+type EntityConstructor = new (...args: any[]) => any;
+type EntityOrTableTarget = EntityConstructor | TableDef;
+type EntityOrTableTargetResolver = EntityOrTableTarget | (() => EntityOrTableTarget);
+
+/**
+ * Entity status enum representing the lifecycle state of an entity
+ */
 declare enum EntityStatus {
+    /** Entity is newly created and not yet persisted */
     New = "new",
+    /** Entity is managed by the ORM and synchronized with the database */
     Managed = "managed",
+    /** Entity has been modified but not yet persisted */
     Dirty = "dirty",
+    /** Entity has been marked for removal */
     Removed = "removed",
+    /** Entity is detached from the ORM context */
     Detached = "detached"
 }
+/**
+ * Represents an entity being tracked by the ORM
+ */
 interface TrackedEntity {
+    /** The table definition this entity belongs to */
     table: TableDef;
+    /** The actual entity instance */
     entity: any;
+    /** Primary key value of the entity */
     pk: string | number | null;
+    /** Current status of the entity */
     status: EntityStatus;
+    /** Original values of the entity when it was loaded */
     original: Record<string, any> | null;
 }
+/**
+ * Type representing a key for relation navigation
+ */
 type RelationKey = string;
+/**
+ * Represents a change operation on a relation
+ * @typeParam T - Type of the related entity
+ */
 type RelationChange<T> = {
     kind: 'add';
     entity: T;
@@ -1605,63 +1650,306 @@ type RelationChange<T> = {
     kind: 'detach';
     entity: T;
 };
-interface HasDomainEvents {
-    domainEvents?: any[];
+/**
+ * Represents a relation change entry in the unit of work
+ */
+interface RelationChangeEntry {
+    /** Root entity that owns the relation */
+    root: any;
+    /** Key of the relation being changed */
+    relationKey: RelationKey;
+    /** Table definition of the root entity */
+    rootTable: TableDef;
+    /** Name of the relation */
+    relationName: string;
+    /** Relation definition */
+    relation: RelationDef;
+    /** The change being applied */
+    change: RelationChange<any>;
+}
+/**
+ * Represents a domain event that can be emitted by entities
+ * @typeParam TType - Type of the event (string literal)
+ */
+interface DomainEvent<TType extends string = string> {
+    /** Type identifier for the event */
+    readonly type: TType;
+    /** Timestamp when the event occurred */
+    readonly occurredAt?: Date;
+}
+/**
+ * Type representing any domain event
+ */
+type AnyDomainEvent = DomainEvent<string>;
+/**
+ * Type representing ORM-specific domain events
+ */
+type OrmDomainEvent = AnyDomainEvent;
+/**
+ * Interface for entities that can emit domain events
+ * @typeParam E - Type of domain events this entity can emit
+ */
+interface HasDomainEvents<E extends DomainEvent = AnyDomainEvent> {
+    /** Array of domain events emitted by this entity */
+    domainEvents?: E[];
 }
 
-type DomainEventHandler$1<Context> = (event: any, ctx: Context) => Promise<void> | void;
-declare const addDomainEvent: (entity: HasDomainEvents, event: any) => void;
+/**
+ * Strategy interface for converting database names to TypeScript identifiers
+ */
+interface NamingStrategy {
+    /**
+     * Converts a table name to a TypeScript symbol name
+     * @param table - Table node, function table node, or name
+     * @returns Valid TypeScript identifier
+     */
+    tableToSymbol(table: TableNode | FunctionTableNode | string): string;
+    /**
+     * Converts a column reference to a property name
+     * @param column - Column node
+     * @returns Valid TypeScript property name
+     */
+    columnToProperty(column: ColumnNode): string;
+}
+
+interface QueryContext {
+    sql: string;
+    params: unknown[];
+}
+type QueryInterceptor = (ctx: QueryContext, next: () => Promise<QueryResult[]>) => Promise<QueryResult[]>;
+declare class InterceptorPipeline {
+    private interceptors;
+    use(interceptor: QueryInterceptor): void;
+    run(ctx: QueryContext, executor: DbExecutor): Promise<QueryResult[]>;
+}
+
+interface OrmOptions<E extends DomainEvent = OrmDomainEvent> {
+    dialect: Dialect;
+    executorFactory: DbExecutorFactory;
+    interceptors?: InterceptorPipeline;
+    namingStrategy?: NamingStrategy;
+}
+interface DbExecutorFactory {
+    createExecutor(options?: {
+        tx?: ExternalTransaction;
+    }): DbExecutor;
+    createTransactionalExecutor(): DbExecutor;
+}
+interface ExternalTransaction {
+}
+declare class Orm<E extends DomainEvent = OrmDomainEvent> {
+    readonly dialect: Dialect;
+    readonly interceptors: InterceptorPipeline;
+    readonly namingStrategy: NamingStrategy;
+    private readonly executorFactory;
+    constructor(opts: OrmOptions<E>);
+    createSession(options?: {
+        tx?: ExternalTransaction;
+    }): OrmSession<E>;
+    transaction<T>(fn: (session: OrmSession<E>) => Promise<T>): Promise<T>;
+}
+
+declare class IdentityMap {
+    private readonly buckets;
+    get bucketsMap(): Map<string, Map<string, TrackedEntity>>;
+    getEntity(table: TableDef, pk: string | number): any | undefined;
+    register(tracked: TrackedEntity): void;
+    remove(tracked: TrackedEntity): void;
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+    clear(): void;
+    private toIdentityKey;
+}
+
+declare class UnitOfWork {
+    private readonly dialect;
+    private readonly executor;
+    private readonly identityMap;
+    private readonly hookContext;
+    private readonly trackedEntities;
+    constructor(dialect: Dialect, executor: DbExecutor, identityMap: IdentityMap, hookContext: () => unknown);
+    get identityBuckets(): Map<string, Map<string, TrackedEntity>>;
+    getTracked(): TrackedEntity[];
+    getEntity(table: TableDef, pk: string | number): any | undefined;
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+    findTracked(entity: any): TrackedEntity | undefined;
+    setEntity(table: TableDef, pk: string | number, entity: any): void;
+    trackNew(table: TableDef, entity: any, pk?: string | number): void;
+    trackManaged(table: TableDef, pk: string | number, entity: any): void;
+    markDirty(entity: any): void;
+    markRemoved(entity: any): void;
+    flush(): Promise<void>;
+    reset(): void;
+    private flushInsert;
+    private flushUpdate;
+    private flushDelete;
+    private runHook;
+    private computeChanges;
+    private extractColumns;
+    private executeCompiled;
+    private getReturningColumns;
+    private applyReturningResults;
+    private normalizeColumnName;
+    private registerIdentity;
+    private createSnapshot;
+    private getPrimaryKeyValue;
+}
+
+type EventOfType<E extends DomainEvent, TType extends E['type']> = Extract<E, {
+    type: TType;
+}>;
+type DomainEventHandler<E extends DomainEvent, Context> = (event: E, ctx: Context) => Promise<void> | void;
+type InitialHandlers<E extends DomainEvent, Context> = {
+    [K in E['type']]?: DomainEventHandler<EventOfType<E, K>, Context>[];
+};
+declare class DomainEventBus<E extends DomainEvent, Context> {
+    private readonly handlers;
+    constructor(initialHandlers?: InitialHandlers<E, Context>);
+    on<TType extends E['type']>(type: TType, handler: DomainEventHandler<EventOfType<E, TType>, Context>): void;
+    register<TType extends E['type']>(type: TType, handler: DomainEventHandler<EventOfType<E, TType>, Context>): void;
+    dispatch(trackedEntities: Iterable<TrackedEntity>, ctx: Context): Promise<void>;
+}
+declare const addDomainEvent: <E extends DomainEvent>(entity: HasDomainEvents<E>, event: E) => void;
+
+declare class RelationChangeProcessor {
+    private readonly unitOfWork;
+    private readonly dialect;
+    private readonly executor;
+    private readonly relationChanges;
+    constructor(unitOfWork: UnitOfWork, dialect: Dialect, executor: DbExecutor);
+    registerChange(entry: RelationChangeEntry): void;
+    reset(): void;
+    process(): Promise<void>;
+    private handleHasManyChange;
+    private handleHasOneChange;
+    private handleBelongsToChange;
+    private handleBelongsToManyChange;
+    private assignHasManyForeignKey;
+    private detachHasManyChild;
+    private assignHasOneForeignKey;
+    private detachHasOneChild;
+    private insertPivotRow;
+    private deletePivotRow;
+    private resolvePrimaryKeyValue;
+}
 
+/**
+ * Represents a single SQL query log entry
+ */
 interface QueryLogEntry {
+    /** The SQL query that was executed */
     sql: string;
+    /** Parameters used in the query */
     params?: unknown[];
 }
+/**
+ * Function type for query logging callbacks
+ * @param entry - The query log entry to process
+ */
 type QueryLogger = (entry: QueryLogEntry) => void;
+/**
+ * Creates a wrapped database executor that logs all SQL queries
+ * @param executor - Original database executor to wrap
+ * @param logger - Optional logger function to receive query log entries
+ * @returns Wrapped executor that logs queries before execution
+ */
+declare const createQueryLoggingExecutor: (executor: DbExecutor, logger?: QueryLogger) => DbExecutor;
 
-interface OrmInterceptor {
-    beforeFlush?(ctx: OrmContext): Promise<void> | void;
-    afterFlush?(ctx: OrmContext): Promise<void> | void;
+/**
+ * Context for SQL query execution
+ */
+interface ExecutionContext {
+    /** Database dialect to use for SQL generation */
+    dialect: Dialect;
+    /** Database executor for running SQL queries */
+    executor: DbExecutor;
+    /** Interceptor pipeline for query processing */
+    interceptors: InterceptorPipeline;
 }
-type DomainEventHandler = DomainEventHandler$1<OrmContext>;
-interface OrmContextOptions {
+
+interface EntityContext {
     dialect: Dialect;
     executor: DbExecutor;
-    interceptors?: OrmInterceptor[];
-    domainEventHandlers?: Record<string, DomainEventHandler[]>;
-    queryLogger?: QueryLogger;
+    getEntity(table: TableDef, pk: any): any;
+    setEntity(table: TableDef, pk: any, entity: any): void;
+    trackNew(table: TableDef, entity: any, pk?: any): void;
+    trackManaged(table: TableDef, pk: any, entity: any): void;
+    markDirty(entity: any): void;
+    markRemoved(entity: any): void;
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+    registerRelationChange(root: any, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<any>): void;
 }
-declare class OrmContext {
-    private readonly options;
-    private readonly identityMap;
-    private readonly executorWithLogging;
-    private readonly unitOfWork;
-    private readonly relationChanges;
+
+interface HydrationContext<E extends DomainEvent = AnyDomainEvent> {
+    identityMap: IdentityMap;
+    unitOfWork: UnitOfWork;
+    domainEvents: DomainEventBus<E, OrmSession<E>>;
+    relationChanges: RelationChangeProcessor;
+    entityContext: EntityContext;
+}
+
+interface OrmInterceptor {
+    beforeFlush?(ctx: EntityContext): Promise<void> | void;
+    afterFlush?(ctx: EntityContext): Promise<void> | void;
+}
+interface OrmSessionOptions<E extends DomainEvent = OrmDomainEvent> {
+    orm: Orm<E>;
+    executor: DbExecutor;
+    queryLogger?: QueryLogger;
+    interceptors?: OrmInterceptor[];
+    domainEventHandlers?: InitialHandlers<E, OrmSession<E>>;
+}
+declare class OrmSession<E extends DomainEvent = OrmDomainEvent> implements EntityContext {
+    readonly orm: Orm<E>;
+    readonly executor: DbExecutor;
+    readonly identityMap: IdentityMap;
+    readonly unitOfWork: UnitOfWork;
+    readonly domainEvents: DomainEventBus<E, OrmSession<E>>;
+    readonly relationChanges: RelationChangeProcessor;
     private readonly interceptors;
-    private readonly domainEvents;
-    constructor(options: OrmContextOptions);
+    constructor(opts: OrmSessionOptions<E>);
     get dialect(): Dialect;
-    get executor(): DbExecutor;
     get identityBuckets(): Map<string, Map<string, TrackedEntity>>;
     get tracked(): TrackedEntity[];
-    getEntity(table: TableDef, pk: string | number): any | undefined;
-    setEntity(table: TableDef, pk: string | number, entity: any): void;
-    trackNew(table: TableDef, entity: any, pk?: string | number): void;
-    trackManaged(table: TableDef, pk: string | number, entity: any): void;
+    getEntity(table: TableDef, pk: any): any | undefined;
+    setEntity(table: TableDef, pk: any, entity: any): void;
+    trackNew(table: TableDef, entity: any, pk?: any): void;
+    trackManaged(table: TableDef, pk: any, entity: any): void;
     markDirty(entity: any): void;
     markRemoved(entity: any): void;
-    registerRelationChange(root: any, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<any>): void;
-    registerInterceptor(interceptor: OrmInterceptor): void;
-    registerDomainEventHandler(name: string, handler: DomainEventHandler): void;
-    saveChanges(): Promise<void>;
+    registerRelationChange: (root: any, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<any>) => void;
     getEntitiesForTable(table: TableDef): TrackedEntity[];
+    registerInterceptor(interceptor: OrmInterceptor): void;
+    registerDomainEventHandler<TType extends E['type']>(type: TType, handler: DomainEventHandler<Extract<E, {
+        type: TType;
+    }>, OrmSession<E>>): void;
+    find<TTable extends TableDef>(entityClass: EntityConstructor, id: any): Promise<Entity<TTable> | null>;
+    findOne<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<Entity<TTable> | null>;
+    findMany<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<Entity<TTable>[]>;
+    persist(entity: object): Promise<void>;
+    remove(entity: object): Promise<void>;
+    flush(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    getExecutionContext(): ExecutionContext;
+    getHydrationContext(): HydrationContext<E>;
 }
 
 type SelectDialectInput = Dialect | DialectKey;
 
+type ColumnSelectionValue = ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode;
+type DeepSelectConfig<TTable extends TableDef> = {
+    root?: (keyof TTable['columns'] & string)[];
+} & {
+    [K in keyof TTable['relations'] & string]?: (keyof RelationTargetTable<TTable['relations'][K]>['columns'] & string)[];
+};
 /**
+
  * 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> {
     private readonly env;
@@ -1670,11 +1958,17 @@ declare class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
     private readonly relationManager;
     private readonly lazyRelations;
     /**
+  
      * Creates a new SelectQueryBuilder instance
+  
      * @param table - Table definition to query
+  
      * @param state - Optional initial query state
+  
      * @param hydration - Optional hydration manager
+  
      * @param dependencies - Optional query builder dependencies
+  
      */
     constructor(table: TTable, state?: SelectQueryState, hydration?: HydrationManager, dependencies?: Partial<SelectQueryBuilderDependencies>, lazyRelations?: Set<string>);
     private clone;
@@ -1684,215 +1978,375 @@ declare class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
     private applyJoin;
     private applySetOperation;
     /**
+  
      * Selects specific columns for the query
+  
      * @param columns - Record of column definitions, function nodes, case expressions, or window functions
+  
      * @returns New query builder instance with selected columns
+  
+     */
+    select(columns: Record<string, ColumnSelectionValue>): SelectQueryBuilder<T, TTable>;
+    /**
+     * Selects columns from the root table by name (typed).
+     * @param cols - Column names on the root table
      */
-    select(columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>): SelectQueryBuilder<T, TTable>;
+    selectColumns<K extends keyof TTable['columns'] & string>(...cols: K[]): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Selects raw column expressions
+  
      * @param cols - Column expressions as strings
+  
      * @returns New query builder instance with raw column selections
+  
      */
     selectRaw(...cols: string[]): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a Common Table Expression (CTE) to the query
+  
      * @param name - Name of the CTE
+  
      * @param query - Query builder or query node for the CTE
+  
      * @param columns - Optional column names for the CTE
+  
      * @returns New query builder instance with the CTE
+  
      */
     with(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a recursive Common Table Expression (CTE) to the query
+  
      * @param name - Name of the CTE
+  
      * @param query - Query builder or query node for the CTE
+  
      * @param columns - Optional column names for the CTE
+  
      * @returns New query builder instance with the recursive CTE
+  
      */
     withRecursive(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Selects a subquery as a column
+  
      * @param alias - Alias for the subquery column
+  
      * @param sub - Query builder or query node for the subquery
+  
      * @returns New query builder instance with the subquery selection
+  
      */
     selectSubquery(alias: string, sub: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds an INNER JOIN to the query
+  
      * @param table - Table to join
+  
      * @param condition - Join condition expression
+  
      * @returns New query builder instance with the INNER JOIN
+  
      */
     innerJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a LEFT JOIN to the query
+  
      * @param table - Table to join
+  
      * @param condition - Join condition expression
+  
      * @returns New query builder instance with the LEFT JOIN
+  
      */
     leftJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a RIGHT JOIN to the query
+  
      * @param table - Table to join
+  
      * @param condition - Join condition expression
+  
      * @returns New query builder instance with the RIGHT JOIN
+  
      */
     rightJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Matches records based on a relationship
+  
      * @param relationName - Name of the relationship to match
+  
      * @param predicate - Optional predicate expression
+  
      * @returns New query builder instance with the relationship match
+  
      */
     match(relationName: string, predicate?: ExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Joins a related table
+  
      * @param relationName - Name of the relationship to join
+  
      * @param joinKind - Type of join (defaults to INNER)
+  
      * @param extraCondition - Optional additional join condition
+  
      * @returns New query builder instance with the relationship join
+  
      */
     joinRelation(relationName: string, joinKind?: JoinKind, extraCondition?: ExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Includes related data in the query results
+  
      * @param relationName - Name of the relationship to include
+  
      * @param options - Optional include options
+  
      * @returns New query builder instance with the relationship inclusion
+  
      */
     include(relationName: string, options?: RelationIncludeOptions): SelectQueryBuilder<T, TTable>;
     includeLazy<K extends keyof RelationMap<TTable>>(relationName: K): SelectQueryBuilder<T, TTable>;
+    /**
+     * Selects columns for a related table in a single hop.
+     */
+    selectRelationColumns<K extends keyof TTable['relations'] & string, TRel extends RelationDef = TTable['relations'][K], TTarget extends TableDef = RelationTargetTable<TRel>, C extends keyof TTarget['columns'] & string = keyof TTarget['columns'] & string>(relationName: K, ...cols: C[]): SelectQueryBuilder<T, TTable>;
+    /**
+     * Convenience alias for selecting specific columns from a relation.
+     */
+    includePick<K extends keyof TTable['relations'] & string, TRel extends RelationDef = TTable['relations'][K], TTarget extends TableDef = RelationTargetTable<TRel>, C extends keyof TTarget['columns'] & string = keyof TTarget['columns'] & string>(relationName: K, cols: C[]): SelectQueryBuilder<T, TTable>;
+    /**
+     * Selects columns for the root table and relations from a single config object.
+     */
+    selectColumnsDeep(config: DeepSelectConfig<TTable>): SelectQueryBuilder<T, TTable>;
     getLazyRelations(): (keyof RelationMap<TTable>)[];
     getTable(): TTable;
-    execute(ctx: OrmContext): Promise<Entity<TTable>[]>;
+    execute(ctx: OrmSession): Promise<Entity<TTable>[]>;
+    executeWithContexts(execCtx: ExecutionContext, hydCtx: HydrationContext): Promise<Entity<TTable>[]>;
     /**
+  
      * Adds a WHERE condition to the query
+  
      * @param expr - Expression for the WHERE clause
+  
      * @returns New query builder instance with the WHERE condition
+  
      */
     where(expr: ExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a GROUP BY clause to the query
+  
      * @param col - Column definition or column node to group by
+  
      * @returns New query builder instance with the GROUP BY clause
+  
      */
     groupBy(col: ColumnDef | ColumnNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a HAVING condition to the query
+  
      * @param expr - Expression for the HAVING clause
+  
      * @returns New query builder instance with the HAVING condition
+  
      */
     having(expr: ExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds an ORDER BY clause to the query
+  
      * @param col - Column definition or column node to order by
+  
      * @param direction - Order direction (defaults to ASC)
+  
      * @returns New query builder instance with the ORDER BY clause
+  
      */
     orderBy(col: ColumnDef | ColumnNode, direction?: OrderDirection): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a DISTINCT clause to the query
+  
      * @param cols - Columns to make distinct
+  
      * @returns New query builder instance with the DISTINCT clause
+  
      */
     distinct(...cols: (ColumnDef | ColumnNode)[]): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a LIMIT clause to the query
+  
      * @param n - Maximum number of rows to return
+  
      * @returns New query builder instance with the LIMIT clause
+  
      */
     limit(n: number): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds an OFFSET clause to the query
+  
      * @param n - Number of rows to skip
+  
      * @returns New query builder instance with the OFFSET clause
+  
      */
     offset(n: number): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Combines this query with another using UNION
+  
      * @param query - Query to union with
+  
      * @returns New query builder instance with the set operation
+  
      */
     union(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Combines this query with another using UNION ALL
+  
      * @param query - Query to union with
+  
      * @returns New query builder instance with the set operation
+  
      */
     unionAll(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Combines this query with another using INTERSECT
+  
      * @param query - Query to intersect with
+  
      * @returns New query builder instance with the set operation
+  
      */
     intersect(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Combines this query with another using EXCEPT
+  
      * @param query - Query to subtract
+  
      * @returns New query builder instance with the set operation
+  
      */
     except(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a WHERE EXISTS condition to the query
+  
      * @param subquery - Subquery to check for existence
+  
      * @returns New query builder instance with the WHERE EXISTS condition
+  
      */
     whereExists(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): 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): 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, callback?: <TChildTable extends TableDef>(qb: SelectQueryBuilder<any, TChildTable>) => SelectQueryBuilder<any, TChildTable>): 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, callback?: <TChildTable extends TableDef>(qb: SelectQueryBuilder<any, TChildTable>) => SelectQueryBuilder<any, TChildTable>): 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;
 
-export { type RawDefaultValue as $, type BelongsToManyRelation as A, type BinaryExpressionNode as B, type ColumnRef as C, Dialect as D, type ExpressionNode as E, type FunctionNode as F, type HasManyCollection as G, type HydrationPlan as H, type InExpressionNode as I, type JsonPathNode as J, type BelongsToReference as K, type LogicalExpressionNode as L, type ManyToManyCollection as M, type NullExpressionNode as N, type OperandNode as O, SelectQueryBuilder as P, type CheckConstraint as Q, type RelationMap as R, type SelectQueryNode as S, type TableRef as T, type UpdateQueryNode as U, type TableOptions as V, type WindowFunctionNode as W, type TableHooks as X, defineTable as Y, type ColumnType as Z, type ReferentialAction as _, type ColumnNode as a, type DefaultValue as a0, col as a1, RelationKinds as a2, type RelationType as a3, type CascadeMode as a4, type RelationDef as a5, hasMany as a6, hasOne as a7, belongsTo as a8, belongsToMany as a9, createExecutorFromQueryRunner as aA, type ColumnToTs as aa, type InferRow as ab, type HasOneReference as ac, createColumn as ad, createLiteral as ae, isOperandNode as af, isFunctionNode as ag, isCaseExpressionNode as ah, isWindowFunctionNode as ai, isExpressionSelectionNode as aj, type HydrationPivotPlan as ak, type HydrationRelationPlan as al, type HydrationMetadata as am, addDomainEvent as an, EntityStatus as ao, type QueryResult as ap, type RelationKey as aq, type RelationChange as ar, type HasDomainEvents as as, type OrmInterceptor as at, type DomainEventHandler as au, type OrmContextOptions as av, type QueryLogEntry as aw, type QueryLogger as ax, rowsToQueryResult as ay, type SimpleQueryRunner as az, type LiteralNode as b, type BetweenExpressionNode as c, type CaseExpressionNode as d, type ExistsExpressionNode as e, type OrderDirection as f, type ScalarSubqueryNode as g, type ColumnDef as h, type TableDef as i, type InsertQueryNode as j, type InsertCompiler as k, type CompiledQuery as l, type DialectKey as m, type UpdateCompiler as n, type DeleteQueryNode as o, type DeleteCompiler as p, type CompilerContext as q, type ForeignKeyReference as r, type IndexColumn as s, type IndexDef as t, type DbExecutor as u, OrmContext as v, type Entity as w, type HasManyRelation as x, type HasOneRelation as y, type BelongsToRelation as z };
+export { type TableHooks as $, type BelongsToRelation as A, type BinaryExpressionNode as B, type ColumnRef as C, Dialect as D, type ExpressionNode as E, type FunctionNode as F, type BelongsToManyRelation as G, type HydrationPlan as H, type InExpressionNode as I, type JsonPathNode as J, type HasManyCollection as K, type LiteralNode as L, type BelongsToReference as M, type NullExpressionNode as N, type OperandNode as O, type ManyToManyCollection as P, OrmSession as Q, type RelationMap as R, type SelectQueryNode as S, type TableRef as T, type UpdateQueryNode as U, SelectQueryBuilder as V, type WindowFunctionNode as W, type ExecutionContext as X, type HydrationContext as Y, type CheckConstraint as Z, type TableOptions as _, type ColumnNode as a, defineTable as a0, type ColumnType as a1, type ReferentialAction as a2, type RawDefaultValue as a3, type DefaultValue as a4, col as a5, RelationKinds as a6, type RelationType as a7, type CascadeMode as a8, type RelationDef as a9, DomainEventBus as aA, addDomainEvent as aB, EntityStatus as aC, type TrackedEntity as aD, type RelationKey as aE, type RelationChange as aF, type RelationChangeEntry as aG, type DomainEvent as aH, type AnyDomainEvent as aI, type OrmDomainEvent as aJ, type HasDomainEvents as aK, type QueryLogEntry as aL, type QueryLogger as aM, createQueryLoggingExecutor as aN, type QueryResult as aO, rowsToQueryResult as aP, type SimpleQueryRunner as aQ, createExecutorFromQueryRunner as aR, type EntityOrTableTargetResolver as aS, type EntityConstructor as aT, hasMany as aa, hasOne as ab, belongsTo as ac, belongsToMany as ad, type RelationTargetTable as ae, type ColumnToTs as af, type InferRow as ag, type HasOneReference as ah, createColumn as ai, createLiteral as aj, isOperandNode as ak, isFunctionNode as al, isCaseExpressionNode as am, isWindowFunctionNode as an, isExpressionSelectionNode as ao, type HydrationPivotPlan as ap, type HydrationRelationPlan as aq, type HydrationMetadata as ar, type OrmInterceptor as as, type OrmSessionOptions as at, type OrmOptions as au, type DbExecutorFactory as av, type ExternalTransaction as aw, Orm as ax, type DomainEventHandler as ay, type InitialHandlers as az, type LogicalExpressionNode as b, type BetweenExpressionNode as c, type CaseExpressionNode as d, type ExistsExpressionNode as e, type OrderDirection as f, type ScalarSubqueryNode as g, type ColumnDef as h, type TableDef as i, type InsertQueryNode as j, type InsertCompiler as k, type CompiledQuery as l, type DialectKey as m, type UpdateCompiler as n, type DeleteQueryNode as o, type DeleteCompiler as p, type CompilerContext as q, type ForeignKeyReference as r, type IndexColumn as s, type IndexDef as t, type DbExecutor as u, type NamingStrategy as v, type EntityContext as w, type Entity as x, type HasManyRelation as y, type HasOneRelation as z };