metal-orm 1.0.7 → 1.0.9

package/dist/select-654m4qy8.d.ts

@@ -0,0 +1,1522 @@
+/**
+ * Supported column data types for database schema definitions
+ */
+type ColumnType = 'INT' | 'INTEGER' | 'VARCHAR' | 'TEXT' | 'JSON' | 'ENUM' | 'BOOLEAN' | 'int' | 'integer' | 'varchar' | 'text' | 'json' | 'enum' | 'boolean';
+/**
+ * Definition of a database column
+ */
+interface ColumnDef<T extends ColumnType = ColumnType> {
+    /** Column name (filled at runtime by defineTable) */
+    name: string;
+    /** Data type of the column */
+    type: T;
+    /** Whether this column is a primary key */
+    primary?: boolean;
+    /** Whether this column cannot be null */
+    notNull?: boolean;
+    /** Additional arguments for the column type (e.g., VARCHAR length) */
+    args?: any[];
+    /** Table name this column belongs to (filled at runtime by defineTable) */
+    table?: string;
+}
+/**
+ * Factory for creating column definitions with common data types
+ */
+declare const col: {
+    /**
+     * Creates an integer column definition
+     * @returns ColumnDef with INT type
+     */
+    int: () => ColumnDef<"INT">;
+    /**
+     * Creates a variable character column definition
+     * @param length - Maximum length of the string
+     * @returns ColumnDef with VARCHAR type
+     */
+    varchar: (length: number) => ColumnDef<"VARCHAR">;
+    /**
+     * Creates a JSON column definition
+     * @returns ColumnDef with JSON type
+     */
+    json: () => ColumnDef<"JSON">;
+    /**
+     * Creates a boolean column definition
+     * @returns ColumnDef with BOOLEAN type
+     */
+    boolean: () => ColumnDef<"BOOLEAN">;
+    /**
+     * Marks a column definition as a primary key
+     * @param def - Column definition to modify
+     * @returns Modified ColumnDef with primary: true
+     */
+    primaryKey: <T extends ColumnType>(def: ColumnDef<T>) => ColumnDef<T>;
+};
+
+/**
+ * Types of relationships supported between tables
+ */
+declare const RelationKinds: {
+    /** One-to-many relationship */
+    readonly HasMany: "HAS_MANY";
+    /** Many-to-one relationship */
+    readonly BelongsTo: "BELONGS_TO";
+    /** Many-to-many relationship with pivot metadata */
+    readonly BelongsToMany: "BELONGS_TO_MANY";
+};
+/**
+ * Type representing the supported relationship kinds
+ */
+type RelationType = (typeof RelationKinds)[keyof typeof RelationKinds];
+type CascadeMode = 'none' | 'all' | 'persist' | 'remove' | 'link';
+/**
+ * One-to-many relationship definition
+ */
+interface HasManyRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.HasMany;
+    target: TTarget;
+    foreignKey: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
+/**
+ * Many-to-one relationship definition
+ */
+interface BelongsToRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.BelongsTo;
+    target: TTarget;
+    foreignKey: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
+/**
+ * Many-to-many relationship definition with rich pivot metadata
+ */
+interface BelongsToManyRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.BelongsToMany;
+    target: TTarget;
+    pivotTable: TableDef;
+    pivotForeignKeyToRoot: string;
+    pivotForeignKeyToTarget: string;
+    localKey?: string;
+    targetKey?: string;
+    pivotPrimaryKey?: string;
+    defaultPivotColumns?: string[];
+    cascade?: CascadeMode;
+}
+/**
+ * Union type representing any supported relationship definition
+ */
+type RelationDef = HasManyRelation | BelongsToRelation | BelongsToManyRelation;
+/**
+ * Creates a one-to-many relationship definition
+ * @param target - Target table of the relationship
+ * @param foreignKey - Foreign key column name on the child table
+ * @param localKey - Local key column name (optional)
+ * @returns HasManyRelation definition
+ *
+ * @example
+ * ```typescript
+ * hasMany(usersTable, 'user_id')
+ * ```
+ */
+declare const hasMany: <TTarget extends TableDef>(target: TTarget, foreignKey: string, localKey?: string, cascade?: CascadeMode) => HasManyRelation<TTarget>;
+/**
+ * Creates a many-to-one relationship definition
+ * @param target - Target table of the relationship
+ * @param foreignKey - Foreign key column name on the child table
+ * @param localKey - Local key column name (optional)
+ * @returns BelongsToRelation definition
+ *
+ * @example
+ * ```typescript
+ * belongsTo(usersTable, 'user_id')
+ * ```
+ */
+declare const belongsTo: <TTarget extends TableDef>(target: TTarget, foreignKey: string, localKey?: string, cascade?: CascadeMode) => BelongsToRelation<TTarget>;
+/**
+ * Creates a many-to-many relationship definition with pivot metadata
+ * @param target - Target table
+ * @param pivotTable - Intermediate pivot table definition
+ * @param options - Pivot metadata configuration
+ * @returns BelongsToManyRelation definition
+ */
+declare const belongsToMany: <TTarget extends TableDef>(target: TTarget, pivotTable: TableDef, options: {
+    pivotForeignKeyToRoot: string;
+    pivotForeignKeyToTarget: string;
+    localKey?: string;
+    targetKey?: string;
+    pivotPrimaryKey?: string;
+    defaultPivotColumns?: string[];
+    cascade?: CascadeMode;
+}) => BelongsToManyRelation<TTarget>;
+
+interface TableHooks {
+    beforeInsert?(ctx: unknown, entity: any): Promise<void> | void;
+    afterInsert?(ctx: unknown, entity: any): Promise<void> | void;
+    beforeUpdate?(ctx: unknown, entity: any): Promise<void> | void;
+    afterUpdate?(ctx: unknown, entity: any): Promise<void> | void;
+    beforeDelete?(ctx: unknown, entity: any): Promise<void> | void;
+    afterDelete?(ctx: unknown, entity: any): Promise<void> | void;
+}
+/**
+ * Definition of a database table with its columns and relationships
+ * @typeParam T - Type of the columns record
+ */
+interface TableDef<T extends Record<string, ColumnDef> = Record<string, ColumnDef>> {
+    /** Name of the table */
+    name: string;
+    /** Record of column definitions keyed by column name */
+    columns: T;
+    /** Record of relationship definitions keyed by relation name */
+    relations: Record<string, RelationDef>;
+    /** Optional lifecycle hooks */
+    hooks?: TableHooks;
+}
+/**
+ * Creates a table definition with columns and relationships
+ * @typeParam T - Type of the columns record
+ * @param name - Name of the table
+ * @param columns - Record of column definitions
+ * @param relations - Record of relationship definitions (optional)
+ * @returns Complete table definition with runtime-filled column metadata
+ *
+ * @example
+ * ```typescript
+ * const usersTable = defineTable('users', {
+ *   id: col.primaryKey(col.int()),
+ *   name: col.varchar(255),
+ *   email: col.varchar(255)
+ * });
+ * ```
+ */
+declare const defineTable: <T extends Record<string, ColumnDef>>(name: string, columns: T, relations?: Record<string, RelationDef>, hooks?: TableHooks) => TableDef<T>;
+
+/**
+ * Maps a ColumnDef to its TypeScript type representation
+ */
+type ColumnToTs<T extends ColumnDef> = T['type'] extends 'INT' | 'INTEGER' | 'int' | 'integer' ? number : T['type'] extends 'BOOLEAN' | 'boolean' ? boolean : T['type'] extends 'JSON' | 'json' ? unknown : string;
+/**
+ * Infers a row shape from a table definition
+ */
+type InferRow<TTable extends TableDef> = {
+    [K in keyof TTable['columns']]: ColumnToTs<TTable['columns'][K]>;
+};
+type RelationResult$1<T extends RelationDef> = T extends HasManyRelation<infer TTarget> ? InferRow<TTarget>[] : T extends BelongsToRelation<infer TTarget> ? InferRow<TTarget> | null : T extends BelongsToManyRelation<infer TTarget> ? (InferRow<TTarget> & {
+    _pivot?: any;
+})[] : never;
+/**
+ * Maps relation names to the expected row results
+ */
+type RelationMap<TTable extends TableDef> = {
+    [K in keyof TTable['relations']]: RelationResult$1<TTable['relations'][K]>;
+};
+interface HasManyCollection<TChild> {
+    load(): Promise<TChild[]>;
+    getItems(): TChild[];
+    add(data: Partial<TChild>): TChild;
+    attach(entity: TChild): void;
+    remove(entity: TChild): void;
+    clear(): void;
+}
+interface BelongsToReference<TParent> {
+    load(): Promise<TParent | null>;
+    get(): TParent | null;
+    set(data: Partial<TParent> | TParent | null): TParent | null;
+}
+interface ManyToManyCollection<TTarget> {
+    load(): Promise<TTarget[]>;
+    getItems(): TTarget[];
+    attach(target: TTarget | number | string): void;
+    detach(target: TTarget | number | string): void;
+    syncByIds(ids: (number | string)[]): Promise<void>;
+}
+type Entity<TTable extends TableDef, TRow = InferRow<TTable>> = TRow & {
+    [K in keyof RelationMap<TTable>]: TTable['relations'][K] extends HasManyRelation<infer TTarget> ? HasManyCollection<Entity<TTarget>> : TTable['relations'][K] extends BelongsToManyRelation<infer TTarget> ? ManyToManyCollection<Entity<TTarget>> : TTable['relations'][K] extends BelongsToRelation<infer TTarget> ? BelongsToReference<Entity<TTarget>> : never;
+} & {
+    $load<K extends keyof RelationMap<TTable>>(relation: K): Promise<RelationMap<TTable>[K]>;
+};
+
+/**
+ * SQL operators used in query conditions
+ */
+declare const SQL_OPERATORS: {
+    /** Equality operator */
+    readonly EQUALS: "=";
+    /** Not equals operator */
+    readonly NOT_EQUALS: "!=";
+    /** Greater than operator */
+    readonly GREATER_THAN: ">";
+    /** Greater than or equal operator */
+    readonly GREATER_OR_EQUAL: ">=";
+    /** Less than operator */
+    readonly LESS_THAN: "<";
+    /** Less than or equal operator */
+    readonly LESS_OR_EQUAL: "<=";
+    /** LIKE pattern matching operator */
+    readonly LIKE: "LIKE";
+    /** NOT LIKE pattern matching operator */
+    readonly NOT_LIKE: "NOT LIKE";
+    /** IN membership operator */
+    readonly IN: "IN";
+    /** NOT IN membership operator */
+    readonly NOT_IN: "NOT IN";
+    /** BETWEEN range operator */
+    readonly BETWEEN: "BETWEEN";
+    /** NOT BETWEEN range operator */
+    readonly NOT_BETWEEN: "NOT BETWEEN";
+    /** IS NULL null check operator */
+    readonly IS_NULL: "IS NULL";
+    /** IS NOT NULL null check operator */
+    readonly IS_NOT_NULL: "IS NOT NULL";
+    /** Logical AND operator */
+    readonly AND: "AND";
+    /** Logical OR operator */
+    readonly OR: "OR";
+    /** EXISTS operator */
+    readonly EXISTS: "EXISTS";
+    /** NOT EXISTS operator */
+    readonly NOT_EXISTS: "NOT EXISTS";
+};
+/**
+ * Type representing any supported SQL operator
+ */
+type SqlOperator = (typeof SQL_OPERATORS)[keyof typeof SQL_OPERATORS];
+/**
+ * Types of SQL joins supported
+ */
+declare const JOIN_KINDS: {
+    /** INNER JOIN type */
+    readonly INNER: "INNER";
+    /** LEFT JOIN type */
+    readonly LEFT: "LEFT";
+    /** RIGHT JOIN type */
+    readonly RIGHT: "RIGHT";
+    /** CROSS JOIN type */
+    readonly CROSS: "CROSS";
+};
+/**
+ * Type representing any supported join kind
+ */
+type JoinKind = (typeof JOIN_KINDS)[keyof typeof JOIN_KINDS];
+/**
+ * Ordering directions for result sorting
+ */
+declare const ORDER_DIRECTIONS: {
+    /** Ascending order */
+    readonly ASC: "ASC";
+    /** Descending order */
+    readonly DESC: "DESC";
+};
+/**
+ * Type representing any supported order direction
+ */
+type OrderDirection = (typeof ORDER_DIRECTIONS)[keyof typeof ORDER_DIRECTIONS];
+
+/**
+ * AST node representing a literal value
+ */
+interface LiteralNode {
+    type: 'Literal';
+    /** The literal value (string, number, boolean, or null) */
+    value: string | number | boolean | null;
+}
+/**
+ * AST node representing a column reference
+ */
+interface ColumnNode {
+    type: 'Column';
+    /** Table name the column belongs to */
+    table: string;
+    /** Column name */
+    name: string;
+    /** Optional alias for the column */
+    alias?: string;
+}
+/**
+ * AST node representing a function call
+ */
+interface FunctionNode {
+    type: 'Function';
+    /** Function name (e.g., COUNT, SUM) */
+    name: string;
+    /** Function arguments */
+    args: (ColumnNode | LiteralNode | JsonPathNode)[];
+    /** Optional alias for the function result */
+    alias?: string;
+}
+/**
+ * AST node representing a JSON path expression
+ */
+interface JsonPathNode {
+    type: 'JsonPath';
+    /** Source column */
+    column: ColumnNode;
+    /** JSON path expression */
+    path: string;
+    /** Optional alias for the result */
+    alias?: string;
+}
+/**
+ * AST node representing a scalar subquery
+ */
+interface ScalarSubqueryNode {
+    type: 'ScalarSubquery';
+    /** Subquery to execute */
+    query: SelectQueryNode;
+    /** Optional alias for the subquery result */
+    alias?: string;
+}
+/**
+ * AST node representing a CASE expression
+ */
+interface CaseExpressionNode {
+    type: 'CaseExpression';
+    /** WHEN-THEN conditions */
+    conditions: {
+        when: ExpressionNode;
+        then: OperandNode;
+    }[];
+    /** Optional ELSE clause */
+    else?: OperandNode;
+    /** Optional alias for the result */
+    alias?: string;
+}
+/**
+ * AST node representing a window function
+ */
+interface WindowFunctionNode {
+    type: 'WindowFunction';
+    /** Window function name (e.g., ROW_NUMBER, RANK) */
+    name: string;
+    /** Function arguments */
+    args: (ColumnNode | LiteralNode | JsonPathNode)[];
+    /** Optional PARTITION BY clause */
+    partitionBy?: ColumnNode[];
+    /** Optional ORDER BY clause */
+    orderBy?: OrderByNode[];
+    /** Optional alias for the result */
+    alias?: string;
+}
+/**
+ * Union type representing any operand that can be used in expressions
+ */
+type OperandNode = ColumnNode | LiteralNode | FunctionNode | JsonPathNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode;
+declare const isOperandNode: (node: any) => node is OperandNode;
+declare const isFunctionNode: (node: any) => node is FunctionNode;
+declare const isCaseExpressionNode: (node: any) => node is CaseExpressionNode;
+declare const isWindowFunctionNode: (node: any) => node is WindowFunctionNode;
+declare const isExpressionSelectionNode: (node: ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode) => node is FunctionNode | CaseExpressionNode | WindowFunctionNode;
+/**
+ * AST node representing a binary expression (e.g., column = value)
+ */
+interface BinaryExpressionNode {
+    type: 'BinaryExpression';
+    /** Left operand */
+    left: OperandNode;
+    /** Comparison operator */
+    operator: SqlOperator;
+    /** Right operand */
+    right: OperandNode;
+    /** Optional escape character for LIKE expressions */
+    escape?: LiteralNode;
+}
+/**
+ * AST node representing a logical expression (AND/OR)
+ */
+interface LogicalExpressionNode {
+    type: 'LogicalExpression';
+    /** Logical operator (AND or OR) */
+    operator: 'AND' | 'OR';
+    /** Operands to combine */
+    operands: ExpressionNode[];
+}
+/**
+ * AST node representing a null check expression
+ */
+interface NullExpressionNode {
+    type: 'NullExpression';
+    /** Operand to check for null */
+    left: OperandNode;
+    /** Null check operator */
+    operator: 'IS NULL' | 'IS NOT NULL';
+}
+/**
+ * AST node representing an IN/NOT IN expression
+ */
+interface InExpressionNode {
+    type: 'InExpression';
+    /** Left operand to check */
+    left: OperandNode;
+    /** IN/NOT IN operator */
+    operator: 'IN' | 'NOT IN';
+    /** Values to check against */
+    right: OperandNode[];
+}
+/**
+ * AST node representing an EXISTS/NOT EXISTS expression
+ */
+interface ExistsExpressionNode {
+    type: 'ExistsExpression';
+    /** EXISTS/NOT EXISTS operator */
+    operator: SqlOperator;
+    /** Subquery to check */
+    subquery: SelectQueryNode;
+}
+/**
+ * AST node representing a BETWEEN/NOT BETWEEN expression
+ */
+interface BetweenExpressionNode {
+    type: 'BetweenExpression';
+    /** Operand to check */
+    left: OperandNode;
+    /** BETWEEN/NOT BETWEEN operator */
+    operator: 'BETWEEN' | 'NOT BETWEEN';
+    /** Lower bound */
+    lower: OperandNode;
+    /** Upper bound */
+    upper: OperandNode;
+}
+/**
+ * Union type representing any supported expression node
+ */
+type ExpressionNode = BinaryExpressionNode | LogicalExpressionNode | NullExpressionNode | InExpressionNode | ExistsExpressionNode | BetweenExpressionNode;
+
+/**
+ * AST node representing a JOIN clause
+ */
+interface JoinNode {
+    type: 'Join';
+    /** Type of join (INNER, LEFT, RIGHT, etc.) */
+    kind: JoinKind;
+    /** Table to join */
+    table: TableNode;
+    /** Join condition expression */
+    condition: ExpressionNode;
+    /** Optional relation name for code generation */
+    relationName?: string;
+}
+
+/**
+ * AST node representing a table reference in a query
+ */
+interface TableNode {
+    type: 'Table';
+    /** Table name */
+    name: string;
+    /** Optional schema name */
+    schema?: string;
+    /** Optional table alias */
+    alias?: string;
+}
+/**
+ * AST node representing an ORDER BY clause
+ */
+interface OrderByNode {
+    type: 'OrderBy';
+    /** Column to order by */
+    column: ColumnNode;
+    /** Order direction (ASC or DESC) */
+    direction: OrderDirection;
+}
+/**
+ * Plan describing pivot columns needed for hydration
+ */
+interface HydrationPivotPlan {
+    table: string;
+    primaryKey: string;
+    aliasPrefix: string;
+    columns: string[];
+}
+/**
+ * Plan for hydrating relationship data
+ */
+interface HydrationRelationPlan {
+    /** Name of the relationship */
+    name: string;
+    /** Alias prefix for the relationship */
+    aliasPrefix: string;
+    /** Type of relationship */
+    type: RelationType;
+    /** Target table name */
+    targetTable: string;
+    /** Target table primary key */
+    targetPrimaryKey: string;
+    /** Foreign key column */
+    foreignKey: string;
+    /** Local key column */
+    localKey: string;
+    /** Columns to include */
+    columns: string[];
+    /** Optional pivot plan for many-to-many relationships */
+    pivot?: HydrationPivotPlan;
+}
+/**
+ * Complete hydration plan for a query
+ */
+interface HydrationPlan {
+    /** Root table name */
+    rootTable: string;
+    /** Root table primary key */
+    rootPrimaryKey: string;
+    /** Root table columns */
+    rootColumns: string[];
+    /** Relationship hydration plans */
+    relations: HydrationRelationPlan[];
+}
+/**
+ * Query metadata including hydration information
+ */
+interface QueryMetadata {
+    /** Optional hydration plan */
+    hydration?: HydrationPlan;
+}
+/**
+ * AST node representing a Common Table Expression (CTE)
+ */
+interface CommonTableExpressionNode {
+    type: 'CommonTableExpression';
+    /** CTE name */
+    name: string;
+    /** Optional column names */
+    columns?: string[];
+    /** CTE query */
+    query: SelectQueryNode;
+    /** Whether the CTE is recursive */
+    recursive: boolean;
+}
+/**
+ * AST node representing a complete SELECT query
+ */
+interface SelectQueryNode {
+    type: 'SelectQuery';
+    /** Optional CTEs (WITH clauses) */
+    ctes?: CommonTableExpressionNode[];
+    /** FROM clause table */
+    from: TableNode;
+    /** SELECT clause columns */
+    columns: (ColumnNode | FunctionNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode)[];
+    /** JOIN clauses */
+    joins: JoinNode[];
+    /** Optional WHERE clause */
+    where?: ExpressionNode;
+    /** Optional GROUP BY clause */
+    groupBy?: ColumnNode[];
+    /** Optional HAVING clause */
+    having?: ExpressionNode;
+    /** Optional ORDER BY clause */
+    orderBy?: OrderByNode[];
+    /** Optional LIMIT clause */
+    limit?: number;
+    /** Optional OFFSET clause */
+    offset?: number;
+    /** Optional query metadata */
+    meta?: QueryMetadata;
+    /** Optional DISTINCT clause */
+    distinct?: ColumnNode[];
+}
+interface InsertQueryNode {
+    type: 'InsertQuery';
+    /** Target table */
+    into: TableNode;
+    /** Column order for inserted values */
+    columns: ColumnNode[];
+    /** Rows of values to insert */
+    values: OperandNode[][];
+    /** Optional RETURNING clause */
+    returning?: ColumnNode[];
+}
+interface UpdateAssignmentNode {
+    /** Column to update */
+    column: ColumnNode;
+    /** Value to set */
+    value: OperandNode;
+}
+interface UpdateQueryNode {
+    type: 'UpdateQuery';
+    /** Table being updated */
+    table: TableNode;
+    /** Assignments for SET clause */
+    set: UpdateAssignmentNode[];
+    /** Optional WHERE clause */
+    where?: ExpressionNode;
+    /** Optional RETURNING clause */
+    returning?: ColumnNode[];
+}
+interface DeleteQueryNode {
+    type: 'DeleteQuery';
+    /** Table to delete from */
+    from: TableNode;
+    /** Optional WHERE clause */
+    where?: ExpressionNode;
+    /** Optional RETURNING clause */
+    returning?: ColumnNode[];
+}
+
+/**
+ * Context for SQL compilation with parameter management
+ */
+interface CompilerContext {
+    /** Array of parameters */
+    params: unknown[];
+    /** Function to add a parameter and get its placeholder */
+    addParameter(value: unknown): string;
+}
+/**
+ * Result of SQL compilation
+ */
+interface CompiledQuery {
+    /** Generated SQL string */
+    sql: string;
+    /** Parameters for the query */
+    params: unknown[];
+}
+interface SelectCompiler {
+    compileSelect(ast: SelectQueryNode): CompiledQuery;
+}
+interface InsertCompiler {
+    compileInsert(ast: InsertQueryNode): CompiledQuery;
+}
+interface UpdateCompiler {
+    compileUpdate(ast: UpdateQueryNode): CompiledQuery;
+}
+interface DeleteCompiler {
+    compileDelete(ast: DeleteQueryNode): CompiledQuery;
+}
+/**
+ * Abstract base class for SQL dialect implementations
+ */
+declare abstract class Dialect implements SelectCompiler, InsertCompiler, UpdateCompiler, DeleteCompiler {
+    /**
+     * Compiles a SELECT query AST to SQL
+     * @param ast - Query AST to compile
+     * @returns Compiled query with SQL and parameters
+     */
+    compileSelect(ast: SelectQueryNode): CompiledQuery;
+    compileInsert(ast: InsertQueryNode): CompiledQuery;
+    compileUpdate(ast: UpdateQueryNode): CompiledQuery;
+    compileDelete(ast: DeleteQueryNode): CompiledQuery;
+    /**
+     * Compiles SELECT query AST to SQL (to be implemented by concrete dialects)
+     * @param ast - Query AST
+     * @param ctx - Compiler context
+     * @returns SQL string
+     */
+    protected abstract compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
+    protected abstract compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string;
+    protected abstract compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string;
+    protected abstract compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string;
+    /**
+     * Quotes an SQL identifier (to be implemented by concrete dialects)
+     * @param id - Identifier to quote
+     * @returns Quoted identifier
+     */
+    abstract quoteIdentifier(id: string): string;
+    /**
+     * Compiles a WHERE clause
+     * @param where - WHERE expression
+     * @param ctx - Compiler context
+     * @returns SQL WHERE clause or empty string
+     */
+    protected compileWhere(where: ExpressionNode | undefined, ctx: CompilerContext): string;
+    protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string;
+    /**
+     * Generates subquery for EXISTS expressions
+     * Rule: Always forces SELECT 1, ignoring column list
+     * Maintains FROM, JOINs, WHERE, GROUP BY, ORDER BY, LIMIT/OFFSET
+     * Does not add ';' at the end
+     * @param ast - Query AST
+     * @param ctx - Compiler context
+     * @returns SQL for EXISTS subquery
+     */
+    protected compileSelectForExists(ast: SelectQueryNode, ctx: CompilerContext): string;
+    /**
+     * Creates a new compiler context
+     * @returns Compiler context with parameter management
+     */
+    protected createCompilerContext(): CompilerContext;
+    /**
+     * Formats a parameter placeholder
+     * @param index - Parameter index
+     * @returns Formatted placeholder string
+     */
+    protected formatPlaceholder(index: number): string;
+    private readonly expressionCompilers;
+    private readonly operandCompilers;
+    protected constructor();
+    /**
+     * Registers an expression compiler for a specific node type
+     * @param type - Expression node type
+     * @param compiler - Compiler function
+     */
+    protected registerExpressionCompiler<T extends ExpressionNode>(type: T['type'], compiler: (node: T, ctx: CompilerContext) => string): void;
+    /**
+     * Registers an operand compiler for a specific node type
+     * @param type - Operand node type
+     * @param compiler - Compiler function
+     */
+    protected registerOperandCompiler<T extends OperandNode>(type: T['type'], compiler: (node: T, ctx: CompilerContext) => string): void;
+    /**
+     * Compiles an expression node
+     * @param node - Expression node to compile
+     * @param ctx - Compiler context
+     * @returns Compiled SQL expression
+     */
+    protected compileExpression(node: ExpressionNode, ctx: CompilerContext): string;
+    /**
+     * Compiles an operand node
+     * @param node - Operand node to compile
+     * @param ctx - Compiler context
+     * @returns Compiled SQL operand
+     */
+    protected compileOperand(node: OperandNode, ctx: CompilerContext): string;
+    private registerDefaultExpressionCompilers;
+    private registerDefaultOperandCompilers;
+    protected compileJsonPath(node: JsonPathNode): string;
+}
+
+/**
+ * Node types that can be used in query projections
+ */
+type ProjectionNode = ColumnNode | FunctionNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode;
+/**
+ * Manages the state of a SELECT query being built
+ */
+declare class SelectQueryState {
+    /**
+     * Table definition for the query
+     */
+    readonly table: TableDef;
+    /**
+     * Abstract Syntax Tree (AST) representation of the query
+     */
+    readonly ast: SelectQueryNode;
+    /**
+     * Creates a new SelectQueryState instance
+     * @param table - Table definition
+     * @param ast - Optional existing AST
+     */
+    constructor(table: TableDef, ast?: SelectQueryNode);
+    /**
+     * Creates a new SelectQueryState with updated AST
+     * @param nextAst - Updated AST
+     * @returns New SelectQueryState instance
+     */
+    private clone;
+    /**
+     * Adds columns to the query
+     * @param newCols - Columns to add
+     * @returns New SelectQueryState with added columns
+     */
+    withColumns(newCols: ProjectionNode[]): SelectQueryState;
+    /**
+     * Adds a join to the query
+     * @param join - Join node to add
+     * @returns New SelectQueryState with added join
+     */
+    withJoin(join: JoinNode): SelectQueryState;
+    /**
+     * Adds a WHERE clause to the query
+     * @param predicate - WHERE predicate expression
+     * @returns New SelectQueryState with WHERE clause
+     */
+    withWhere(predicate: ExpressionNode): SelectQueryState;
+    /**
+     * Adds a HAVING clause to the query
+     * @param predicate - HAVING predicate expression
+     * @returns New SelectQueryState with HAVING clause
+     */
+    withHaving(predicate: ExpressionNode): SelectQueryState;
+    /**
+     * Adds GROUP BY columns to the query
+     * @param columns - Columns to group by
+     * @returns New SelectQueryState with GROUP BY clause
+     */
+    withGroupBy(columns: ColumnNode[]): SelectQueryState;
+    /**
+     * Adds ORDER BY clauses to the query
+     * @param orderBy - ORDER BY nodes
+     * @returns New SelectQueryState with ORDER BY clause
+     */
+    withOrderBy(orderBy: OrderByNode[]): SelectQueryState;
+    /**
+     * Adds DISTINCT columns to the query
+     * @param columns - Columns to make distinct
+     * @returns New SelectQueryState with DISTINCT clause
+     */
+    withDistinct(columns: ColumnNode[]): SelectQueryState;
+    /**
+     * Adds a LIMIT clause to the query
+     * @param limit - Maximum number of rows to return
+     * @returns New SelectQueryState with LIMIT clause
+     */
+    withLimit(limit: number): SelectQueryState;
+    /**
+     * Adds an OFFSET clause to the query
+     * @param offset - Number of rows to skip
+     * @returns New SelectQueryState with OFFSET clause
+     */
+    withOffset(offset: number): SelectQueryState;
+    /**
+     * Adds a Common Table Expression (CTE) to the query
+     * @param cte - CTE node to add
+     * @returns New SelectQueryState with CTE
+     */
+    withCte(cte: CommonTableExpressionNode): SelectQueryState;
+}
+
+/**
+ * Manages hydration planning for query results
+ */
+declare class HydrationPlanner {
+    private readonly table;
+    private readonly plan?;
+    /**
+     * Creates a new HydrationPlanner instance
+     * @param table - Table definition
+     * @param plan - Optional existing hydration plan
+     */
+    constructor(table: TableDef, plan?: HydrationPlan);
+    /**
+     * Captures root table columns for hydration planning
+     * @param columns - Columns to capture
+     * @returns Updated HydrationPlanner with captured columns
+     */
+    captureRootColumns(columns: ProjectionNode[]): HydrationPlanner;
+    /**
+     * Includes a relation in the hydration plan
+     * @param rel - Relation definition
+     * @param relationName - Name of the relation
+     * @param aliasPrefix - Alias prefix for relation columns
+     * @param columns - Columns to include from the relation
+     * @returns Updated HydrationPlanner with included relation
+     */
+    includeRelation(rel: RelationDef, relationName: string, aliasPrefix: string, columns: string[], pivot?: {
+        aliasPrefix: string;
+        columns: string[];
+    }): HydrationPlanner;
+    /**
+     * Gets the current hydration plan
+     * @returns Current hydration plan or undefined
+     */
+    getPlan(): HydrationPlan | undefined;
+    /**
+     * Gets the current hydration plan or creates a default one
+     * @returns Current hydration plan or default plan
+     */
+    private getPlanOrDefault;
+    /**
+     * Builds a relation plan for hydration
+     * @param rel - Relation definition
+     * @param relationName - Name of the relation
+     * @param aliasPrefix - Alias prefix for relation columns
+     * @param columns - Columns to include from the relation
+     * @returns Hydration relation plan
+     */
+    private buildRelationPlan;
+}
+
+/**
+ * Manages hydration planning for query results
+ */
+declare class HydrationManager {
+    private readonly table;
+    private readonly planner;
+    /**
+     * Creates a new HydrationManager instance
+     * @param table - Table definition
+     * @param planner - Hydration planner
+     */
+    constructor(table: TableDef, planner: HydrationPlanner);
+    /**
+     * Creates a new HydrationManager with updated planner
+     * @param nextPlanner - Updated hydration planner
+     * @returns New HydrationManager instance
+     */
+    private clone;
+    /**
+     * Handles column selection for hydration planning
+     * @param state - Current query state
+     * @param newColumns - Newly selected columns
+     * @returns Updated HydrationManager with captured columns
+     */
+    onColumnsSelected(state: SelectQueryState, newColumns: ProjectionNode[]): HydrationManager;
+    /**
+     * Handles relation inclusion for hydration planning
+     * @param state - Current query state
+     * @param relation - Relation definition
+     * @param relationName - Name of the relation
+     * @param aliasPrefix - Alias prefix for the relation
+     * @param targetColumns - Target columns to include
+     * @returns Updated HydrationManager with included relation
+     */
+    onRelationIncluded(state: SelectQueryState, relation: RelationDef, relationName: string, aliasPrefix: string, targetColumns: string[], pivot?: {
+        aliasPrefix: string;
+        columns: string[];
+    }): HydrationManager;
+    /**
+     * Applies hydration plan to the AST
+     * @param ast - Query AST to modify
+     * @returns AST with hydration metadata
+     */
+    applyToAst(ast: SelectQueryNode): SelectQueryNode;
+    /**
+     * Gets the current hydration plan
+     * @returns Hydration plan or undefined if none exists
+     */
+    getPlan(): HydrationPlan | undefined;
+}
+
+/**
+ * Result of column selection operation
+ */
+interface ColumnSelectionResult {
+    /**
+     * Updated query state
+     */
+    state: SelectQueryState;
+    /**
+     * Columns that were added
+     */
+    addedColumns: ProjectionNode[];
+}
+/**
+ * Service for manipulating query AST (Abstract Syntax Tree)
+ */
+declare class QueryAstService {
+    private readonly table;
+    private readonly state;
+    /**
+     * Creates a new QueryAstService instance
+     * @param table - Table definition
+     * @param state - Current query state
+     */
+    constructor(table: TableDef, state: SelectQueryState);
+    /**
+     * Selects columns for the query
+     * @param columns - Columns to select (key: alias, value: column definition or expression)
+     * @returns Column selection result with updated state and added columns
+     */
+    select(columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>): ColumnSelectionResult;
+    /**
+     * Selects raw column expressions (best-effort parser for simple references/functions)
+     * @param cols - Raw column expressions
+     * @returns Column selection result with updated state and added columns
+     */
+    selectRaw(cols: string[]): ColumnSelectionResult;
+    /**
+     * Adds a Common Table Expression (CTE) to the query
+     * @param name - Name of the CTE
+     * @param query - Query for the CTE
+     * @param columns - Optional column names for the CTE
+     * @param recursive - Whether the CTE is recursive
+     * @returns Updated query state with CTE
+     */
+    withCte(name: string, query: SelectQueryNode, columns?: string[], recursive?: boolean): SelectQueryState;
+    /**
+     * Selects a subquery as a column
+     * @param alias - Alias for the subquery
+     * @param query - Subquery to select
+     * @returns Updated query state with subquery selection
+     */
+    selectSubquery(alias: string, query: SelectQueryNode): SelectQueryState;
+    /**
+     * Adds a JOIN clause to the query
+     * @param join - Join node to add
+     * @returns Updated query state with JOIN
+     */
+    withJoin(join: JoinNode): SelectQueryState;
+    /**
+     * Adds a WHERE clause to the query
+     * @param expr - Expression for the WHERE clause
+     * @returns Updated query state with WHERE clause
+     */
+    withWhere(expr: ExpressionNode): SelectQueryState;
+    /**
+     * Adds a GROUP BY clause to the query
+     * @param col - Column to group by
+     * @returns Updated query state with GROUP BY clause
+     */
+    withGroupBy(col: ColumnDef | ColumnNode): SelectQueryState;
+    /**
+     * Adds a HAVING clause to the query
+     * @param expr - Expression for the HAVING clause
+     * @returns Updated query state with HAVING clause
+     */
+    withHaving(expr: ExpressionNode): SelectQueryState;
+    /**
+     * Adds an ORDER BY clause to the query
+     * @param col - Column to order by
+     * @param direction - Order direction (ASC/DESC)
+     * @returns Updated query state with ORDER BY clause
+     */
+    withOrderBy(col: ColumnDef | ColumnNode, direction: OrderDirection): SelectQueryState;
+    /**
+     * Adds a DISTINCT clause to the query
+     * @param cols - Columns to make distinct
+     * @returns Updated query state with DISTINCT clause
+     */
+    withDistinct(cols: ColumnNode[]): SelectQueryState;
+    /**
+     * Adds a LIMIT clause to the query
+     * @param limit - Maximum number of rows to return
+     * @returns Updated query state with LIMIT clause
+     */
+    withLimit(limit: number): SelectQueryState;
+    /**
+     * Adds an OFFSET clause to the query
+     * @param offset - Number of rows to skip
+     * @returns Updated query state with OFFSET clause
+     */
+    withOffset(offset: number): SelectQueryState;
+    /**
+     * Combines expressions with AND operator
+     * @param existing - Existing expression
+     * @param next - New expression to combine
+     * @returns Combined expression
+     */
+    private combineExpressions;
+}
+
+/**
+ * Result of a relation operation
+ */
+interface RelationResult {
+    /**
+     * Updated query state
+     */
+    state: SelectQueryState;
+    /**
+     * Updated hydration manager
+     */
+    hydration: HydrationManager;
+}
+
+/**
+ * Join kinds allowed when including a relation using `.include(...)`.
+ */
+type RelationIncludeJoinKind = typeof JOIN_KINDS.LEFT | typeof JOIN_KINDS.INNER;
+/**
+ * Options for including a relation in a query
+ */
+interface RelationIncludeOptions {
+    columns?: string[];
+    aliasPrefix?: string;
+    filter?: ExpressionNode;
+    joinKind?: RelationIncludeJoinKind;
+    pivot?: {
+        columns?: string[];
+        aliasPrefix?: string;
+    };
+}
+
+/**
+ * Service for handling relation operations (joins, includes, etc.)
+ */
+declare class RelationService {
+    private readonly table;
+    private readonly state;
+    private readonly hydration;
+    private readonly createQueryAstService;
+    private readonly projectionHelper;
+    /**
+     * Creates a new RelationService instance
+     * @param table - Table definition
+     * @param state - Current query state
+     * @param hydration - Hydration manager
+     */
+    constructor(table: TableDef, state: SelectQueryState, hydration: HydrationManager, createQueryAstService: (table: TableDef, state: SelectQueryState) => QueryAstService);
+    /**
+     * Joins a relation to the query
+     * @param relationName - Name of the relation to join
+     * @param joinKind - Type of join to use
+     * @param extraCondition - Additional join condition
+     * @returns Relation result with updated state and hydration
+     */
+    joinRelation(relationName: string, joinKind: JoinKind, extraCondition?: ExpressionNode): RelationResult;
+    /**
+     * Matches records based on a relation with an optional predicate
+     * @param relationName - Name of the relation to match
+     * @param predicate - Optional predicate expression
+     * @returns Relation result with updated state and hydration
+     */
+    match(relationName: string, predicate?: ExpressionNode): RelationResult;
+    /**
+     * Includes a relation in the query result
+     * @param relationName - Name of the relation to include
+     * @param options - Options for relation inclusion
+     * @returns Relation result with updated state and hydration
+     */
+    include(relationName: string, options?: RelationIncludeOptions): RelationResult;
+    /**
+     * Applies relation correlation to a query AST
+     * @param relationName - Name of the relation
+     * @param ast - Query AST to modify
+     * @returns Modified query AST with relation correlation
+     */
+    applyRelationCorrelation(relationName: string, ast: SelectQueryNode): SelectQueryNode;
+    /**
+     * Creates a join node for a relation
+     * @param state - Current query state
+     * @param relationName - Name of the relation
+     * @param joinKind - Type of join to use
+     * @param extraCondition - Additional join condition
+     * @returns Updated query state with join
+     */
+    private withJoin;
+    /**
+     * Selects columns for a relation
+     * @param state - Current query state
+     * @param hydration - Hydration manager
+     * @param columns - Columns to select
+     * @returns Relation result with updated state and hydration
+     */
+    private selectColumns;
+    /**
+     * Gets a relation definition by name
+     * @param relationName - Name of the relation
+     * @returns Relation definition
+     * @throws Error if relation is not found
+     */
+    private getRelation;
+    /**
+     * Creates a QueryAstService instance
+     * @param state - Current query state
+     * @returns QueryAstService instance
+     */
+    private astService;
+}
+
+/**
+ * Dependencies for query builder operations
+ */
+interface SelectQueryBuilderDependencies {
+    /**
+     * Creates a new query state
+     * @param table - Table definition
+     * @returns New query state
+     */
+    createState: (table: TableDef) => SelectQueryState;
+    /**
+     * Creates a new hydration manager
+     * @param table - Table definition
+     * @returns New hydration manager
+     */
+    createHydration: (table: TableDef) => HydrationManager;
+    /**
+     * Creates a new hydration planner
+     * @param table - Table definition
+     * @returns Hydration planner
+     */
+    createHydrationPlanner: (table: TableDef) => HydrationPlanner;
+    /**
+     * Creates a new query AST service
+     * @param table - Table definition
+     * @param state - Query state
+     * @returns New query AST service
+     */
+    createQueryAstService: (table: TableDef, state: SelectQueryState) => QueryAstService;
+    /**
+     * Creates a new relation service
+     * @param table - Table definition
+     * @param state - Query state
+     * @param hydration - Hydration manager
+     * @returns New relation service
+     */
+    createRelationService: (table: TableDef, state: SelectQueryState, hydration: HydrationManager) => RelationService;
+}
+
+type QueryResult = {
+    columns: string[];
+    values: unknown[][];
+};
+interface DbExecutor {
+    executeSql(sql: string, params?: unknown[]): Promise<QueryResult[]>;
+    beginTransaction?(): Promise<void>;
+    commitTransaction?(): Promise<void>;
+    rollbackTransaction?(): Promise<void>;
+}
+
+declare enum EntityStatus {
+    New = "new",
+    Managed = "managed",
+    Dirty = "dirty",
+    Removed = "removed",
+    Detached = "detached"
+}
+interface TrackedEntity {
+    table: TableDef;
+    entity: any;
+    pk: string | number | null;
+    status: EntityStatus;
+    original: Record<string, any> | null;
+}
+type RelationKey = string;
+type RelationChange<T> = {
+    kind: 'add';
+    entity: T;
+} | {
+    kind: 'attach';
+    entity: T;
+} | {
+    kind: 'remove';
+    entity: T;
+} | {
+    kind: 'detach';
+    entity: T;
+};
+interface HasDomainEvents {
+    domainEvents?: any[];
+}
+
+type DomainEventHandler$1<Context> = (event: any, ctx: Context) => Promise<void> | void;
+declare const addDomainEvent: (entity: HasDomainEvents, event: any) => void;
+
+interface OrmInterceptor {
+    beforeFlush?(ctx: OrmContext): Promise<void> | void;
+    afterFlush?(ctx: OrmContext): Promise<void> | void;
+}
+type DomainEventHandler = DomainEventHandler$1<OrmContext>;
+interface OrmContextOptions {
+    dialect: Dialect;
+    executor: DbExecutor;
+    interceptors?: OrmInterceptor[];
+    domainEventHandlers?: Record<string, DomainEventHandler[]>;
+}
+declare class OrmContext {
+    private readonly options;
+    private readonly identityMap;
+    private readonly unitOfWork;
+    private readonly relationChanges;
+    private readonly interceptors;
+    private readonly domainEvents;
+    constructor(options: OrmContextOptions);
+    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;
+    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>;
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+}
+
+/**
+ * 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;
+    private readonly context;
+    private readonly columnSelector;
+    private readonly relationManager;
+    private readonly lazyRelations;
+    /**
+     * Creates a new SelectQueryBuilder instance
+     * @param table - Table definition to query
+     * @param state - Optional initial query state
+     * @param hydration - Optional hydration manager
+     * @param dependencies - Optional query builder dependencies
+     */
+    constructor(table: TTable, state?: SelectQueryState, hydration?: HydrationManager, dependencies?: Partial<SelectQueryBuilderDependencies>, lazyRelations?: Set<string>);
+    private clone;
+    private resolveQueryNode;
+    private createChildBuilder;
+    private applyAst;
+    private applyJoin;
+    /**
+     * 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, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>): 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>;
+    getLazyRelations(): (keyof RelationMap<TTable>)[];
+    getTable(): TTable;
+    execute(ctx: OrmContext): 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>;
+    /**
+     * 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: Dialect): 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: Dialect): 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 { createLiteral as $, RelationKinds as A, type BinaryExpressionNode as B, type ColumnDef as C, type DeleteQueryNode as D, type ExpressionNode as E, type FunctionNode as F, type RelationType as G, type HydrationPlan as H, type InExpressionNode as I, type JsonPathNode as J, type CascadeMode as K, type LogicalExpressionNode as L, type ManyToManyCollection as M, type NullExpressionNode as N, type OperandNode as O, type RelationDef as P, hasMany as Q, type RelationMap as R, type SelectQueryNode as S, type TableDef as T, type UpdateQueryNode as U, belongsTo as V, type WindowFunctionNode as W, belongsToMany as X, type ColumnToTs as Y, type InferRow as Z, createColumn as _, type ColumnNode as a, isOperandNode as a0, isFunctionNode as a1, isCaseExpressionNode as a2, isWindowFunctionNode as a3, isExpressionSelectionNode as a4, addDomainEvent as a5, EntityStatus as a6, type QueryResult as a7, type DbExecutor as a8, type RelationKey as a9, type RelationChange as aa, type HasDomainEvents as ab, type OrmInterceptor as ac, type DomainEventHandler as ad, type OrmContextOptions as ae, 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 InsertQueryNode as h, type InsertCompiler as i, type CompiledQuery as j, type UpdateCompiler as k, type DeleteCompiler as l, Dialect as m, type CompilerContext as n, OrmContext as o, type Entity as p, type HasManyRelation as q, type BelongsToRelation as r, type BelongsToManyRelation as s, type HasManyCollection as t, type BelongsToReference as u, SelectQueryBuilder as v, type TableHooks as w, defineTable as x, type ColumnType as y, col as z };