metal-orm 1.0.32 → 1.0.34

package/dist/select-BuMpVcVt.d.ts

@@ -1,2424 +0,0 @@
-/**
- * Supported column data types for database schema definitions
- */
-type ColumnType = 'INT' | 'INTEGER' | 'BIGINT' | 'VARCHAR' | 'TEXT' | 'JSON' | 'ENUM' | 'DECIMAL' | 'FLOAT' | 'DOUBLE' | 'UUID' | 'BINARY' | 'VARBINARY' | 'BLOB' | 'BYTEA' | 'DATE' | 'DATETIME' | 'TIMESTAMP' | 'TIMESTAMPTZ' | 'BOOLEAN' | 'int' | 'integer' | 'bigint' | 'varchar' | 'text' | 'json' | 'enum' | 'decimal' | 'float' | 'double' | 'uuid' | 'binary' | 'varbinary' | 'blob' | 'bytea' | 'date' | 'datetime' | 'timestamp' | 'timestamptz' | 'boolean';
-type ReferentialAction = 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
-interface RawDefaultValue {
-    raw: string;
-}
-type DefaultValue = unknown | RawDefaultValue;
-interface ForeignKeyReference {
-    /** Target table name */
-    table: string;
-    /** Target column name */
-    column: string;
-    /** Optional constraint name */
-    name?: string;
-    /** ON DELETE action */
-    onDelete?: ReferentialAction;
-    /** ON UPDATE action */
-    onUpdate?: ReferentialAction;
-    /** Whether the constraint is deferrable (Postgres) */
-    deferrable?: boolean;
-}
-/**
- * Definition of a database column
- */
-interface ColumnDef<T extends ColumnType = ColumnType> {
-    /** Column name (filled at runtime by defineTable) */
-    name: string;
-    /** Data type of the column */
-    type: T;
-    /** Whether this column is a primary key */
-    primary?: boolean;
-    /** Whether this column cannot be null */
-    notNull?: boolean;
-    /** Whether this column must be unique (or name of the unique constraint) */
-    unique?: boolean | string;
-    /** Default value for the column */
-    default?: DefaultValue;
-    /** Whether the column auto-increments / identity */
-    autoIncrement?: boolean;
-    /** Identity strategy where supported */
-    generated?: 'always' | 'byDefault';
-    /** Inline check constraint expression */
-    check?: string;
-    /** Foreign key reference */
-    references?: ForeignKeyReference;
-    /** Column comment/description */
-    comment?: string;
-    /** Additional arguments for the column type (e.g., VARCHAR length) */
-    args?: any[];
-    /** Table name this column belongs to (filled at runtime by defineTable) */
-    table?: string;
-}
-/**
- * Factory for creating column definitions with common data types
- */
-declare const col: {
-    /**
-     * Creates an integer column definition
-     * @returns ColumnDef with INT type
-     */
-    int: () => ColumnDef<"INT">;
-    /**
-     * Creates a big integer column definition
-     */
-    bigint: () => ColumnDef<"BIGINT">;
-    /**
-     * Creates a variable character column definition
-     * @param length - Maximum length of the string
-     * @returns ColumnDef with VARCHAR type
-     */
-    varchar: (length: number) => ColumnDef<"VARCHAR">;
-    /**
-     * Creates a fixed precision decimal column definition
-     */
-    decimal: (precision: number, scale?: number) => ColumnDef<"DECIMAL">;
-    /**
-     * Creates a floating point column definition
-     */
-    float: (precision?: number) => ColumnDef<"FLOAT">;
-    /**
-     * Creates a UUID column definition
-     */
-    uuid: () => ColumnDef<"UUID">;
-    /**
-     * Creates a binary large object column definition
-     */
-    blob: () => ColumnDef<"BLOB">;
-    /**
-     * Creates a fixed-length binary column definition
-     */
-    binary: (length?: number) => ColumnDef<"BINARY">;
-    /**
-     * Creates a variable-length binary column definition
-     */
-    varbinary: (length?: number) => ColumnDef<"VARBINARY">;
-    /**
-     * Creates a Postgres bytea column definition
-     */
-    bytea: () => ColumnDef<"BYTEA">;
-    /**
-     * Creates a timestamp column definition
-     */
-    timestamp: () => ColumnDef<"TIMESTAMP">;
-    /**
-     * Creates a timestamptz column definition
-     */
-    timestamptz: () => ColumnDef<"TIMESTAMPTZ">;
-    /**
-     * Creates a date column definition
-     */
-    date: () => ColumnDef<"DATE">;
-    /**
-     * Creates a datetime column definition
-     */
-    datetime: () => ColumnDef<"DATETIME">;
-    /**
-     * Creates a JSON column definition
-     * @returns ColumnDef with JSON type
-     */
-    json: () => ColumnDef<"JSON">;
-    /**
-     * Creates a boolean column definition
-     * @returns ColumnDef with BOOLEAN type
-     */
-    boolean: () => ColumnDef<"BOOLEAN">;
-    /**
-     * Creates an enum column definition
-     * @param values - Enum values
-     */
-    enum: (values: string[]) => ColumnDef<"ENUM">;
-    /**
-     * Marks a column definition as a primary key
-     * @param def - Column definition to modify
-     * @returns Modified ColumnDef with primary: true
-     */
-    primaryKey: <T extends ColumnType>(def: ColumnDef<T>) => ColumnDef<T>;
-    /**
-     * Marks a column as NOT NULL
-     */
-    notNull: <T extends ColumnType>(def: ColumnDef<T>) => ColumnDef<T>;
-    /**
-     * Marks a column as UNIQUE
-     */
-    unique: <T extends ColumnType>(def: ColumnDef<T>, name?: string) => ColumnDef<T>;
-    /**
-     * Sets a default value for the column
-     */
-    default: <T extends ColumnType>(def: ColumnDef<T>, value: unknown) => ColumnDef<T>;
-    /**
-     * Sets a raw SQL default value for the column
-     */
-    defaultRaw: <T extends ColumnType>(def: ColumnDef<T>, expression: string) => ColumnDef<T>;
-    /**
-     * Marks a column as auto-increment / identity
-     */
-    autoIncrement: <T extends ColumnType>(def: ColumnDef<T>, strategy?: ColumnDef["generated"]) => ColumnDef<T>;
-    /**
-     * Adds a foreign key reference
-     */
-    references: <T extends ColumnType>(def: ColumnDef<T>, ref: ForeignKeyReference) => ColumnDef<T>;
-    /**
-     * Adds a check constraint to the column
-     */
-    check: <T extends ColumnType>(def: ColumnDef<T>, expression: string) => ColumnDef<T>;
-};
-
-/**
- * Types of relationships supported between tables
- */
-declare const RelationKinds: {
-    /** One-to-one relationship */
-    readonly HasOne: "HAS_ONE";
-    /** One-to-many relationship */
-    readonly HasMany: "HAS_MANY";
-    /** Many-to-one relationship */
-    readonly BelongsTo: "BELONGS_TO";
-    /** Many-to-many relationship with pivot metadata */
-    readonly BelongsToMany: "BELONGS_TO_MANY";
-};
-/**
- * Type representing the supported relationship kinds
- */
-type RelationType = (typeof RelationKinds)[keyof typeof RelationKinds];
-type CascadeMode = 'none' | 'all' | 'persist' | 'remove' | 'link';
-/**
- * One-to-many relationship definition
- */
-interface HasManyRelation<TTarget extends TableDef = TableDef> {
-    type: typeof RelationKinds.HasMany;
-    target: TTarget;
-    foreignKey: string;
-    localKey?: string;
-    cascade?: CascadeMode;
-}
-/**
- * One-to-one relationship definition
- */
-interface HasOneRelation<TTarget extends TableDef = TableDef> {
-    type: typeof RelationKinds.HasOne;
-    target: TTarget;
-    foreignKey: string;
-    localKey?: string;
-    cascade?: CascadeMode;
-}
-/**
- * Many-to-one relationship definition
- */
-interface BelongsToRelation<TTarget extends TableDef = TableDef> {
-    type: typeof RelationKinds.BelongsTo;
-    target: TTarget;
-    foreignKey: string;
-    localKey?: string;
-    cascade?: CascadeMode;
-}
-/**
- * Many-to-many relationship definition with rich pivot metadata
- */
-interface BelongsToManyRelation<TTarget extends TableDef = TableDef> {
-    type: typeof RelationKinds.BelongsToMany;
-    target: TTarget;
-    pivotTable: TableDef;
-    pivotForeignKeyToRoot: string;
-    pivotForeignKeyToTarget: string;
-    localKey?: string;
-    targetKey?: string;
-    pivotPrimaryKey?: string;
-    defaultPivotColumns?: string[];
-    cascade?: CascadeMode;
-}
-/**
- * Union type representing any supported relationship definition
- */
-type RelationDef = HasManyRelation | HasOneRelation | BelongsToRelation | BelongsToManyRelation;
-/**
- * Creates a one-to-many relationship definition
- * @param target - Target table of the relationship
- * @param foreignKey - Foreign key column name on the child table
- * @param localKey - Local key column name (optional)
- * @returns HasManyRelation definition
- *
- * @example
- * ```typescript
- * hasMany(usersTable, 'user_id')
- * ```
- */
-declare const hasMany: <TTarget extends TableDef>(target: TTarget, foreignKey: string, localKey?: string, cascade?: CascadeMode) => HasManyRelation<TTarget>;
-/**
- * Creates a one-to-one relationship definition
- * @param target - Target table of the relationship
- * @param foreignKey - Foreign key column name on the child table
- * @param localKey - Local key column name (optional)
- * @returns HasOneRelation definition
- */
-declare const hasOne: <TTarget extends TableDef>(target: TTarget, foreignKey: string, localKey?: string, cascade?: CascadeMode) => HasOneRelation<TTarget>;
-/**
- * Creates a many-to-one relationship definition
- * @param target - Target table of the relationship
- * @param foreignKey - Foreign key column name on the child table
- * @param localKey - Local key column name (optional)
- * @returns BelongsToRelation definition
- *
- * @example
- * ```typescript
- * belongsTo(usersTable, 'user_id')
- * ```
- */
-declare const belongsTo: <TTarget extends TableDef>(target: TTarget, foreignKey: string, localKey?: string, cascade?: CascadeMode) => BelongsToRelation<TTarget>;
-/**
- * Creates a many-to-many relationship definition with pivot metadata
- * @param target - Target table
- * @param pivotTable - Intermediate pivot table definition
- * @param options - Pivot metadata configuration
- * @returns BelongsToManyRelation definition
- */
-declare const belongsToMany: <TTarget extends TableDef>(target: TTarget, pivotTable: TableDef, options: {
-    pivotForeignKeyToRoot: string;
-    pivotForeignKeyToTarget: string;
-    localKey?: string;
-    targetKey?: string;
-    pivotPrimaryKey?: string;
-    defaultPivotColumns?: string[];
-    cascade?: CascadeMode;
-}) => BelongsToManyRelation<TTarget>;
-
-interface IndexColumn {
-    column: string;
-    order?: 'ASC' | 'DESC';
-    nulls?: 'FIRST' | 'LAST';
-}
-interface IndexDef {
-    name?: string;
-    columns: (string | IndexColumn)[];
-    unique?: boolean;
-    where?: string;
-}
-interface CheckConstraint {
-    name?: string;
-    expression: string;
-}
-interface TableOptions {
-    schema?: string;
-    primaryKey?: string[];
-    indexes?: IndexDef[];
-    checks?: CheckConstraint[];
-    comment?: string;
-    engine?: string;
-    charset?: string;
-    collation?: string;
-}
-interface TableHooks {
-    beforeInsert?(ctx: unknown, entity: any): Promise<void> | void;
-    afterInsert?(ctx: unknown, entity: any): Promise<void> | void;
-    beforeUpdate?(ctx: unknown, entity: any): Promise<void> | void;
-    afterUpdate?(ctx: unknown, entity: any): Promise<void> | void;
-    beforeDelete?(ctx: unknown, entity: any): Promise<void> | void;
-    afterDelete?(ctx: unknown, entity: any): Promise<void> | void;
-}
-/**
- * Definition of a database table with its columns and relationships
- * @typeParam T - Type of the columns record
- */
-interface TableDef<T extends Record<string, ColumnDef> = Record<string, ColumnDef>> {
-    /** Name of the table */
-    name: string;
-    /** Optional schema/catalog name */
-    schema?: string;
-    /** Record of column definitions keyed by column name */
-    columns: T;
-    /** Record of relationship definitions keyed by relation name */
-    relations: Record<string, RelationDef>;
-    /** Optional lifecycle hooks */
-    hooks?: TableHooks;
-    /** Composite primary key definition (falls back to column.primary flags) */
-    primaryKey?: string[];
-    /** Secondary indexes */
-    indexes?: IndexDef[];
-    /** Table-level check constraints */
-    checks?: CheckConstraint[];
-    /** Table comment/description */
-    comment?: string;
-    /** Dialect-specific options */
-    engine?: string;
-    charset?: string;
-    collation?: string;
-}
-/**
- * Creates a table definition with columns and relationships
- * @typeParam T - Type of the columns record
- * @param name - Name of the table
- * @param columns - Record of column definitions
- * @param relations - Record of relationship definitions (optional)
- * @returns Complete table definition with runtime-filled column metadata
- *
- * @example
- * ```typescript
- * const usersTable = defineTable('users', {
- *   id: col.primaryKey(col.int()),
- *   name: col.varchar(255),
- *   email: col.varchar(255)
- * });
- * ```
- */
-declare const defineTable: <T extends Record<string, ColumnDef>>(name: string, columns: T, relations?: Record<string, RelationDef>, hooks?: TableHooks, options?: TableOptions) => TableDef<T>;
-
-/**
- * Resolves a relation definition to its target table type.
- */
-type RelationTargetTable<TRel extends RelationDef> = TRel extends HasManyRelation<infer TTarget> ? TTarget : TRel extends HasOneRelation<infer TTarget> ? TTarget : TRel extends BelongsToRelation<infer TTarget> ? TTarget : TRel extends BelongsToManyRelation<infer TTarget> ? TTarget : never;
-/**
- * Maps a ColumnDef to its TypeScript type representation
- */
-type ColumnToTs<T extends ColumnDef> = T['type'] extends 'INT' | 'INTEGER' | 'int' | 'integer' ? number : T['type'] extends 'BIGINT' | 'bigint' ? number | bigint : T['type'] extends 'DECIMAL' | 'decimal' | 'FLOAT' | 'float' | 'DOUBLE' | 'double' ? number : T['type'] extends 'BOOLEAN' | 'boolean' ? boolean : T['type'] extends 'JSON' | 'json' ? unknown : T['type'] extends 'BLOB' | 'blob' | 'BINARY' | 'binary' | 'VARBINARY' | 'varbinary' | 'BYTEA' | 'bytea' ? Buffer : T['type'] extends 'DATE' | 'date' | 'DATETIME' | 'datetime' | 'TIMESTAMP' | 'timestamp' | 'TIMESTAMPTZ' | 'timestamptz' ? string : string;
-/**
- * Infers a row shape from a table definition
- */
-type InferRow<TTable extends TableDef> = {
-    [K in keyof TTable['columns']]: ColumnToTs<TTable['columns'][K]>;
-};
-type RelationResult$1<T extends RelationDef> = T extends HasManyRelation<infer TTarget> ? InferRow<TTarget>[] : T extends HasOneRelation<infer TTarget> ? InferRow<TTarget> | null : T extends BelongsToRelation<infer TTarget> ? InferRow<TTarget> | null : T extends BelongsToManyRelation<infer TTarget> ? (InferRow<TTarget> & {
-    _pivot?: any;
-})[] : never;
-/**
- * Maps relation names to the expected row results
- */
-type RelationMap<TTable extends TableDef> = {
-    [K in keyof TTable['relations']]: RelationResult$1<TTable['relations'][K]>;
-};
-interface HasManyCollection<TChild> {
-    load(): Promise<TChild[]>;
-    getItems(): TChild[];
-    add(data: Partial<TChild>): TChild;
-    attach(entity: TChild): void;
-    remove(entity: TChild): void;
-    clear(): void;
-}
-interface BelongsToReference<TParent> {
-    load(): Promise<TParent | null>;
-    get(): TParent | null;
-    set(data: Partial<TParent> | TParent | null): TParent | null;
-}
-interface HasOneReference<TChild> {
-    load(): Promise<TChild | null>;
-    get(): TChild | null;
-    set(data: Partial<TChild> | TChild | null): TChild | null;
-}
-interface ManyToManyCollection<TTarget> {
-    load(): Promise<TTarget[]>;
-    getItems(): TTarget[];
-    attach(target: TTarget | number | string): void;
-    detach(target: TTarget | number | string): void;
-    syncByIds(ids: (number | string)[]): Promise<void>;
-}
-type 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 HasOneRelation<infer TTarget> ? HasOneReference<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];
-/**
- * Supported database dialects
- */
-declare const SUPPORTED_DIALECTS: {
-    /** MySQL database dialect */
-    readonly MYSQL: "mysql";
-    /** SQLite database dialect */
-    readonly SQLITE: "sqlite";
-    /** Microsoft SQL Server dialect */
-    readonly MSSQL: "mssql";
-    /** PostgreSQL database dialect */
-    readonly POSTGRES: "postgres";
-};
-/**
- * Type representing any supported database dialect
- */
-type DialectName = (typeof SUPPORTED_DIALECTS)[keyof typeof SUPPORTED_DIALECTS];
-
-/**
- * Minimal column reference used by AST builders.
- * Accepts any object with a name and optional table/alias fields
- * (schema ColumnDef/TableDef remain structurally compatible).
- */
-interface ColumnRef {
-    name: string;
-    table?: string;
-    alias?: string;
-}
-/**
- * Minimal table reference used by AST builders.
- * Keeps AST decoupled from full schema TableDef shape.
- */
-interface TableRef {
-    name: string;
-    schema?: string;
-    alias?: string;
-}
-
-/**
- * AST node representing a literal value
- */
-interface LiteralNode {
-    type: 'Literal';
-    /** The literal value (string, number, boolean, or null) */
-    value: string | number | boolean | null;
-}
-/**
- * AST node representing a column reference
- */
-interface ColumnNode {
-    type: 'Column';
-    /** Table name the column belongs to */
-    table: string;
-    /** Column name */
-    name: string;
-    /** Optional alias for the column */
-    alias?: string;
-    /** Optional scope marker (e.g., 'outer' for correlated references) */
-    scope?: 'outer' | 'default';
-}
-/**
- * AST node representing a function call
- */
-interface FunctionNode {
-    type: 'Function';
-    /** Function name (e.g., COUNT, SUM) */
-    name: string;
-    /** Optional canonical function key for dialect-aware rendering */
-    fn?: string;
-    /** Function arguments */
-    args: OperandNode[];
-    /** Optional alias for the function result */
-    alias?: string;
-    /** Optional ORDER BY clause used by aggregations like GROUP_CONCAT */
-    orderBy?: OrderByNode[];
-    /** Optional separator argument used by GROUP_CONCAT-like functions */
-    separator?: OperandNode;
-    /** Optional DISTINCT modifier */
-    distinct?: boolean;
-}
-/**
- * AST node representing a JSON path expression
- */
-interface JsonPathNode {
-    type: 'JsonPath';
-    /** Source column */
-    column: ColumnNode;
-    /** JSON path expression */
-    path: string;
-    /** Optional alias for the result */
-    alias?: string;
-}
-/**
- * AST node representing a scalar subquery
- */
-interface ScalarSubqueryNode {
-    type: 'ScalarSubquery';
-    /** Subquery to execute */
-    query: SelectQueryNode;
-    /** Optional alias for the subquery result */
-    alias?: string;
-}
-/**
- * AST node representing a CASE expression
- */
-interface CaseExpressionNode {
-    type: 'CaseExpression';
-    /** WHEN-THEN conditions */
-    conditions: {
-        when: ExpressionNode;
-        then: OperandNode;
-    }[];
-    /** Optional ELSE clause */
-    else?: OperandNode;
-    /** Optional alias for the result */
-    alias?: string;
-}
-/**
- * AST node representing a window function
- */
-interface WindowFunctionNode {
-    type: 'WindowFunction';
-    /** Window function name (e.g., ROW_NUMBER, RANK) */
-    name: string;
-    /** Function arguments */
-    args: (ColumnNode | LiteralNode | JsonPathNode)[];
-    /** Optional PARTITION BY clause */
-    partitionBy?: ColumnNode[];
-    /** Optional ORDER BY clause */
-    orderBy?: OrderByNode[];
-    /** Optional alias for the result */
-    alias?: string;
-}
-/**
- * Union type representing any operand that can be used in expressions
- */
-type OperandNode = ColumnNode | LiteralNode | FunctionNode | JsonPathNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode;
-declare const isOperandNode: (node: any) => node is OperandNode;
-declare const isFunctionNode: (node: any) => node is FunctionNode;
-declare const isCaseExpressionNode: (node: any) => node is CaseExpressionNode;
-declare const isWindowFunctionNode: (node: any) => node is WindowFunctionNode;
-declare const isExpressionSelectionNode: (node: ColumnRef | FunctionNode | CaseExpressionNode | WindowFunctionNode) => node is FunctionNode | CaseExpressionNode | WindowFunctionNode;
-/**
- * AST node representing a binary expression (e.g., column = value)
- */
-interface BinaryExpressionNode {
-    type: 'BinaryExpression';
-    /** Left operand */
-    left: OperandNode;
-    /** Comparison operator */
-    operator: SqlOperator;
-    /** Right operand */
-    right: OperandNode;
-    /** Optional escape character for LIKE expressions */
-    escape?: LiteralNode;
-}
-/**
- * AST node representing a logical expression (AND/OR)
- */
-interface LogicalExpressionNode {
-    type: 'LogicalExpression';
-    /** Logical operator (AND or OR) */
-    operator: 'AND' | 'OR';
-    /** Operands to combine */
-    operands: ExpressionNode[];
-}
-/**
- * AST node representing a null check expression
- */
-interface NullExpressionNode {
-    type: 'NullExpression';
-    /** Operand to check for null */
-    left: OperandNode;
-    /** Null check operator */
-    operator: 'IS NULL' | 'IS NOT NULL';
-}
-/**
- * AST node representing an IN/NOT IN expression
- */
-interface InExpressionNode {
-    type: 'InExpression';
-    /** Left operand to check */
-    left: OperandNode;
-    /** IN/NOT IN operator */
-    operator: 'IN' | 'NOT IN';
-    /** Values to check against */
-    right: OperandNode[];
-}
-/**
- * AST node representing an EXISTS/NOT EXISTS expression
- */
-interface ExistsExpressionNode {
-    type: 'ExistsExpression';
-    /** EXISTS/NOT EXISTS operator */
-    operator: SqlOperator;
-    /** Subquery to check */
-    subquery: SelectQueryNode;
-}
-/**
- * AST node representing a BETWEEN/NOT BETWEEN expression
- */
-interface BetweenExpressionNode {
-    type: 'BetweenExpression';
-    /** Operand to check */
-    left: OperandNode;
-    /** BETWEEN/NOT BETWEEN operator */
-    operator: 'BETWEEN' | 'NOT BETWEEN';
-    /** Lower bound */
-    lower: OperandNode;
-    /** Upper bound */
-    upper: OperandNode;
-}
-/**
- * Union type representing any supported expression node
- */
-type ExpressionNode = BinaryExpressionNode | LogicalExpressionNode | NullExpressionNode | InExpressionNode | ExistsExpressionNode | BetweenExpressionNode;
-
-/**
- * AST node representing a JOIN clause
- */
-interface JoinNode {
-    type: 'Join';
-    /** Type of join (INNER, LEFT, RIGHT, etc.) */
-    kind: JoinKind;
-    /** Table to join */
-    table: TableSourceNode;
-    /** Join condition expression */
-    condition: ExpressionNode;
-    /** Optional metadata for non-SQL concerns (e.g., relation name) */
-    meta?: Record<string, unknown>;
-}
-
-/**
- * AST node representing a table reference in a query
- */
-interface TableNode {
-    type: 'Table';
-    /** Table name */
-    name: string;
-    /** Optional schema name */
-    schema?: string;
-    /** Optional table alias */
-    alias?: string;
-}
-/**
- * AST node representing a function used as a table source (table-valued function)
- */
-interface FunctionTableNode {
-    type: 'FunctionTable';
-    /** Function name */
-    name: string;
-    /** Optional schema for the function (some dialects) */
-    schema?: string;
-    /** Function arguments as operand nodes */
-    args?: any[];
-    /** Optional alias for the function table */
-    alias?: string;
-    /** LATERAL flag */
-    lateral?: boolean;
-    /** WITH ORDINALITY flag */
-    withOrdinality?: boolean;
-    /** Optional column aliases */
-    columnAliases?: string[];
-}
-/**
- * AST node representing a derived table (subquery with an alias)
- */
-interface DerivedTableNode {
-    type: 'DerivedTable';
-    /** Subquery providing the rows */
-    query: SelectQueryNode;
-    /** Required alias for the derived table */
-    alias: string;
-    /** Optional column aliases */
-    columnAliases?: string[];
-}
-type TableSourceNode = TableNode | FunctionTableNode | DerivedTableNode;
-/**
- * AST node representing an ORDER BY clause
- */
-interface OrderByNode {
-    type: 'OrderBy';
-    /** Column to order by */
-    column: ColumnNode;
-    /** Order direction (ASC or DESC) */
-    direction: OrderDirection;
-}
-/**
- * AST node representing a Common Table Expression (CTE)
- */
-interface CommonTableExpressionNode {
-    type: 'CommonTableExpression';
-    /** CTE name */
-    name: string;
-    /** Optional column names */
-    columns?: string[];
-    /** CTE query */
-    query: SelectQueryNode;
-    /** Whether the CTE is recursive */
-    recursive: boolean;
-}
-/**
- * Supported set operation kinds for compound SELECT queries
- */
-type SetOperationKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'EXCEPT';
-/**
- * AST node representing a set operation (UNION, INTERSECT, etc.)
- */
-interface SetOperationNode {
-    type: 'SetOperation';
-    /** Operator to combine queries */
-    operator: SetOperationKind;
-    /** Right-hand query in the compound expression */
-    query: SelectQueryNode;
-}
-/**
- * AST node representing a complete SELECT query
- */
-interface SelectQueryNode {
-    type: 'SelectQuery';
-    /** Optional CTEs (WITH clauses) */
-    ctes?: CommonTableExpressionNode[];
-    /** FROM clause table (either a Table or a FunctionTable) */
-    from: TableSourceNode;
-    /** SELECT clause columns */
-    columns: (ColumnNode | FunctionNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode)[];
-    /** JOIN clauses */
-    joins: JoinNode[];
-    /** Optional WHERE clause */
-    where?: ExpressionNode;
-    /** Optional GROUP BY clause */
-    groupBy?: ColumnNode[];
-    /** Optional HAVING clause */
-    having?: ExpressionNode;
-    /** Optional ORDER BY clause */
-    orderBy?: OrderByNode[];
-    /** Optional LIMIT clause */
-    limit?: number;
-    /** Optional OFFSET clause */
-    offset?: number;
-    /** Optional query metadata */
-    meta?: Record<string, unknown>;
-    /** Optional DISTINCT clause */
-    distinct?: ColumnNode[];
-    /** Optional set operations chaining this query with others */
-    setOps?: SetOperationNode[];
-}
-interface InsertQueryNode {
-    type: 'InsertQuery';
-    /** Target table */
-    into: TableNode;
-    /** Column order for inserted values */
-    columns: ColumnNode[];
-    /** Rows of values to insert */
-    values: OperandNode[][];
-    /** Optional RETURNING clause */
-    returning?: ColumnNode[];
-}
-interface UpdateAssignmentNode {
-    /** Column to update */
-    column: ColumnNode;
-    /** Value to set */
-    value: OperandNode;
-}
-interface UpdateQueryNode {
-    type: 'UpdateQuery';
-    /** Table being updated */
-    table: TableNode;
-    /** Assignments for SET clause */
-    set: UpdateAssignmentNode[];
-    /** Optional WHERE clause */
-    where?: ExpressionNode;
-    /** Optional RETURNING clause */
-    returning?: ColumnNode[];
-}
-interface DeleteQueryNode {
-    type: 'DeleteQuery';
-    /** Table to delete from */
-    from: TableNode;
-    /** Optional WHERE clause */
-    where?: ExpressionNode;
-    /** Optional RETURNING clause */
-    returning?: ColumnNode[];
-}
-
-/**
- * Plan describing pivot columns needed for hydration
- */
-interface HydrationPivotPlan {
-    table: string;
-    primaryKey: string;
-    aliasPrefix: string;
-    columns: string[];
-}
-/**
- * Plan for hydrating relationship data
- */
-interface HydrationRelationPlan {
-    /** Name of the relationship */
-    name: string;
-    /** Alias prefix for the relationship */
-    aliasPrefix: string;
-    /** Type of relationship */
-    type: RelationType;
-    /** Target table name */
-    targetTable: string;
-    /** Target table primary key */
-    targetPrimaryKey: string;
-    /** Foreign key column */
-    foreignKey: string;
-    /** Local key column */
-    localKey: string;
-    /** Columns to include */
-    columns: string[];
-    /** Optional pivot plan for many-to-many relationships */
-    pivot?: HydrationPivotPlan;
-}
-/**
- * Complete hydration plan for a query
- */
-interface HydrationPlan {
-    /** Root table name */
-    rootTable: string;
-    /** Root table primary key */
-    rootPrimaryKey: string;
-    /** Root table columns */
-    rootColumns: string[];
-    /** Relationship hydration plans */
-    relations: HydrationRelationPlan[];
-}
-/**
- * Metadata bag for attaching hydration to query ASTs without coupling AST types.
- */
-interface HydrationMetadata {
-    hydration?: HydrationPlan;
-    [key: string]: unknown;
-}
-
-interface FunctionRenderContext {
-    node: FunctionNode;
-    compiledArgs: string[];
-    /** Helper to compile additional operands (e.g., separators or ORDER BY columns) */
-    compileOperand: (operand: OperandNode) => string;
-}
-type FunctionRenderer = (ctx: FunctionRenderContext) => string;
-interface FunctionStrategy {
-    /**
-     * Returns a renderer for a specific function name (e.g. "DATE_ADD").
-     * Returns undefined if this dialect doesn't support the function.
-     */
-    getRenderer(functionName: string): FunctionRenderer | undefined;
-}
-
-/**
- * Context for SQL compilation with parameter management
- */
-interface CompilerContext {
-    /** Array of parameters */
-    params: unknown[];
-    /** Function to add a parameter and get its placeholder */
-    addParameter(value: unknown): string;
-}
-/**
- * Result of SQL compilation
- */
-interface CompiledQuery {
-    /** Generated SQL string */
-    sql: string;
-    /** Parameters for the query */
-    params: unknown[];
-}
-interface SelectCompiler {
-    compileSelect(ast: SelectQueryNode): CompiledQuery;
-}
-interface InsertCompiler {
-    compileInsert(ast: InsertQueryNode): CompiledQuery;
-}
-interface UpdateCompiler {
-    compileUpdate(ast: UpdateQueryNode): CompiledQuery;
-}
-interface DeleteCompiler {
-    compileDelete(ast: DeleteQueryNode): CompiledQuery;
-}
-/**
- * Abstract base class for SQL dialect implementations
- */
-declare abstract class Dialect implements SelectCompiler, InsertCompiler, UpdateCompiler, DeleteCompiler {
-    /** Dialect identifier used for function rendering and formatting */
-    protected abstract readonly dialect: DialectName;
-    /**
-     * Compiles a SELECT query AST to SQL
-     * @param ast - Query AST to compile
-     * @returns Compiled query with SQL and parameters
-     */
-    compileSelect(ast: SelectQueryNode): CompiledQuery;
-    compileInsert(ast: InsertQueryNode): CompiledQuery;
-    compileUpdate(ast: UpdateQueryNode): CompiledQuery;
-    compileDelete(ast: DeleteQueryNode): CompiledQuery;
-    supportsReturning(): boolean;
-    /**
-     * Compiles SELECT query AST to SQL (to be implemented by concrete dialects)
-     * @param ast - Query AST
-     * @param ctx - Compiler context
-     * @returns SQL string
-     */
-    protected abstract compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
-    protected abstract compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string;
-    protected abstract compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string;
-    protected abstract compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string;
-    /**
-     * Quotes an SQL identifier (to be implemented by concrete dialects)
-     * @param id - Identifier to quote
-     * @returns Quoted identifier
-     */
-    abstract quoteIdentifier(id: string): string;
-    /**
-     * Compiles a WHERE clause
-     * @param where - WHERE expression
-     * @param ctx - Compiler context
-     * @returns SQL WHERE clause or empty string
-     */
-    protected compileWhere(where: ExpressionNode | undefined, ctx: CompilerContext): string;
-    protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string;
-    /**
-     * Generates subquery for EXISTS expressions
-     * Rule: Always forces SELECT 1, ignoring column list
-     * Maintains FROM, JOINs, WHERE, GROUP BY, ORDER BY, LIMIT/OFFSET
-     * Does not add ';' at the end
-     * @param ast - Query AST
-     * @param ctx - Compiler context
-     * @returns SQL for EXISTS subquery
-     */
-    protected compileSelectForExists(ast: SelectQueryNode, ctx: CompilerContext): string;
-    /**
-     * Creates a new compiler context
-     * @returns Compiler context with parameter management
-     */
-    protected createCompilerContext(): CompilerContext;
-    /**
-     * Formats a parameter placeholder
-     * @param index - Parameter index
-     * @returns Formatted placeholder string
-     */
-    protected formatPlaceholder(index: number): string;
-    /**
-     * Whether the current dialect supports a given set operation.
-     * Override in concrete dialects to restrict support.
-     */
-    protected supportsSetOperation(kind: SetOperationKind): boolean;
-    /**
-     * Validates set-operation semantics:
-     * - Ensures the dialect supports requested operators.
-     * - Enforces that only the outermost compound query may have ORDER/LIMIT/OFFSET.
-     * @param ast - Query to validate
-     * @param isOutermost - Whether this node is the outermost compound query
-     */
-    protected validateSetOperations(ast: SelectQueryNode, isOutermost?: boolean): void;
-    /**
-     * Hoists CTEs from set-operation operands to the outermost query so WITH appears once.
-     * @param ast - Query AST
-     * @returns Normalized AST without inner CTEs and a list of hoisted CTEs
-     */
-    private hoistCtes;
-    /**
-     * Normalizes a SELECT AST before compilation (validation + CTE hoisting).
-     * @param ast - Query AST
-     * @returns Normalized query AST
-     */
-    protected normalizeSelectAst(ast: SelectQueryNode): SelectQueryNode;
-    private readonly expressionCompilers;
-    private readonly operandCompilers;
-    protected readonly functionStrategy: FunctionStrategy;
-    protected constructor(functionStrategy?: FunctionStrategy);
-    /**
-     * Creates a new Dialect instance (for testing purposes)
-     * @param functionStrategy - Optional function strategy
-     * @returns New Dialect instance
-     */
-    static create(functionStrategy?: FunctionStrategy): Dialect;
-    /**
-     * Registers an expression compiler for a specific node type
-     * @param type - Expression node type
-     * @param compiler - Compiler function
-     */
-    protected registerExpressionCompiler<T extends ExpressionNode>(type: T['type'], compiler: (node: T, ctx: CompilerContext) => string): void;
-    /**
-     * Registers an operand compiler for a specific node type
-     * @param type - Operand node type
-     * @param compiler - Compiler function
-     */
-    protected registerOperandCompiler<T extends OperandNode>(type: T['type'], compiler: (node: T, ctx: CompilerContext) => string): void;
-    /**
-     * Compiles an expression node
-     * @param node - Expression node to compile
-     * @param ctx - Compiler context
-     * @returns Compiled SQL expression
-     */
-    protected compileExpression(node: ExpressionNode, ctx: CompilerContext): string;
-    /**
-     * Compiles an operand node
-     * @param node - Operand node to compile
-     * @param ctx - Compiler context
-     * @returns Compiled SQL operand
-     */
-    protected compileOperand(node: OperandNode, ctx: CompilerContext): string;
-    private registerDefaultExpressionCompilers;
-    private registerDefaultOperandCompilers;
-    protected compileJsonPath(node: JsonPathNode): string;
-    /**
-     * Compiles a function operand, using the dialect's function strategy.
-     */
-    protected compileFunctionOperand(fnNode: FunctionNode, ctx: CompilerContext): string;
-}
-
-type DialectKey = 'postgres' | 'mysql' | 'sqlite' | 'mssql' | (string & {});
-
-/**
- * Node types that can be used in query projections
- */
-type ProjectionNode = ColumnNode | FunctionNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode;
-/**
- * Manages the state of a SELECT query being built
- */
-declare class SelectQueryState {
-    /**
-     * Table definition for the query
-     */
-    readonly table: TableDef;
-    /**
-     * Abstract Syntax Tree (AST) representation of the query
-     */
-    readonly ast: SelectQueryNode;
-    /**
-     * Creates a new SelectQueryState instance
-     * @param table - Table definition
-     * @param ast - Optional existing AST
-     */
-    constructor(table: TableDef, ast?: SelectQueryNode);
-    /**
-     * Creates a new SelectQueryState with updated AST
-     * @param nextAst - Updated AST
-     * @returns New SelectQueryState instance
-     */
-    private clone;
-    /**
-     * Adds columns to the query
-     * @param newCols - Columns to add
-     * @returns New SelectQueryState with added columns
-     */
-    withColumns(newCols: ProjectionNode[]): SelectQueryState;
-    /**
-     * Adds a join to the query
-     * @param join - Join node to add
-     * @returns New SelectQueryState with added join
-     */
-    withJoin(join: JoinNode): SelectQueryState;
-    /**
-     * Replaces the FROM clause.
-     * @param from - Table source for the FROM clause
-     * @returns New SelectQueryState with updated FROM
-     */
-    withFrom(from: TableSourceNode): SelectQueryState;
-    /**
-     * Adds a WHERE clause to the query
-     * @param predicate - WHERE predicate expression
-     * @returns New SelectQueryState with WHERE clause
-     */
-    withWhere(predicate: ExpressionNode): SelectQueryState;
-    /**
-     * Adds a HAVING clause to the query
-     * @param predicate - HAVING predicate expression
-     * @returns New SelectQueryState with HAVING clause
-     */
-    withHaving(predicate: ExpressionNode): SelectQueryState;
-    /**
-     * Adds GROUP BY columns to the query
-     * @param columns - Columns to group by
-     * @returns New SelectQueryState with GROUP BY clause
-     */
-    withGroupBy(columns: ColumnNode[]): SelectQueryState;
-    /**
-     * Adds ORDER BY clauses to the query
-     * @param orderBy - ORDER BY nodes
-     * @returns New SelectQueryState with ORDER BY clause
-     */
-    withOrderBy(orderBy: OrderByNode[]): SelectQueryState;
-    /**
-     * Adds DISTINCT columns to the query
-     * @param columns - Columns to make distinct
-     * @returns New SelectQueryState with DISTINCT clause
-     */
-    withDistinct(columns: ColumnNode[]): SelectQueryState;
-    /**
-     * Adds a LIMIT clause to the query
-     * @param limit - Maximum number of rows to return
-     * @returns New SelectQueryState with LIMIT clause
-     */
-    withLimit(limit: number): SelectQueryState;
-    /**
-     * Adds an OFFSET clause to the query
-     * @param offset - Number of rows to skip
-     * @returns New SelectQueryState with OFFSET clause
-     */
-    withOffset(offset: number): SelectQueryState;
-    /**
-     * Adds a Common Table Expression (CTE) to the query
-     * @param cte - CTE node to add
-     * @returns New SelectQueryState with CTE
-     */
-    withCte(cte: CommonTableExpressionNode): SelectQueryState;
-    /**
-     * Adds a set operation (UNION/INTERSECT/EXCEPT) to the query
-     * @param op - Set operation node to add
-     * @returns New SelectQueryState with set operation
-     */
-    withSetOperation(op: SetOperationNode): SelectQueryState;
-}
-
-/**
- * Manages hydration planning for query results
- */
-declare class HydrationPlanner {
-    private readonly table;
-    private readonly plan?;
-    /**
-     * Creates a new HydrationPlanner instance
-     * @param table - Table definition
-     * @param plan - Optional existing hydration plan
-     */
-    constructor(table: TableDef, plan?: HydrationPlan);
-    /**
-     * Captures root table columns for hydration planning
-     * @param columns - Columns to capture
-     * @returns Updated HydrationPlanner with captured columns
-     */
-    captureRootColumns(columns: ProjectionNode[]): HydrationPlanner;
-    /**
-     * Includes a relation in the hydration plan
-     * @param rel - Relation definition
-     * @param relationName - Name of the relation
-     * @param aliasPrefix - Alias prefix for relation columns
-     * @param columns - Columns to include from the relation
-     * @returns Updated HydrationPlanner with included relation
-     */
-    includeRelation(rel: RelationDef, relationName: string, aliasPrefix: string, columns: string[], pivot?: {
-        aliasPrefix: string;
-        columns: string[];
-    }): HydrationPlanner;
-    /**
-     * Gets the current hydration plan
-     * @returns Current hydration plan or undefined
-     */
-    getPlan(): HydrationPlan | undefined;
-    /**
-     * Gets the current hydration plan or creates a default one
-     * @returns Current hydration plan or default plan
-     */
-    private getPlanOrDefault;
-    /**
-     * Builds a relation plan for hydration
-     * @param rel - Relation definition
-     * @param relationName - Name of the relation
-     * @param aliasPrefix - Alias prefix for relation columns
-     * @param columns - Columns to include from the relation
-     * @returns Hydration relation plan
-     */
-    private buildRelationPlan;
-}
-
-/**
- * Manages hydration planning for query results
- */
-declare class HydrationManager {
-    private readonly table;
-    private readonly planner;
-    /**
-     * Creates a new HydrationManager instance
-     * @param table - Table definition
-     * @param planner - Hydration planner
-     */
-    constructor(table: TableDef, planner: HydrationPlanner);
-    /**
-     * Creates a new HydrationManager with updated planner
-     * @param nextPlanner - Updated hydration planner
-     * @returns New HydrationManager instance
-     */
-    private clone;
-    /**
-     * Handles column selection for hydration planning
-     * @param state - Current query state
-     * @param newColumns - Newly selected columns
-     * @returns Updated HydrationManager with captured columns
-     */
-    onColumnsSelected(state: SelectQueryState, newColumns: ProjectionNode[]): HydrationManager;
-    /**
-     * Handles relation inclusion for hydration planning
-     * @param state - Current query state
-     * @param relation - Relation definition
-     * @param relationName - Name of the relation
-     * @param aliasPrefix - Alias prefix for the relation
-     * @param targetColumns - Target columns to include
-     * @returns Updated HydrationManager with included relation
-     */
-    onRelationIncluded(state: SelectQueryState, relation: RelationDef, relationName: string, aliasPrefix: string, targetColumns: string[], pivot?: {
-        aliasPrefix: string;
-        columns: string[];
-    }): HydrationManager;
-    /**
-     * Applies hydration plan to the AST
-     * @param ast - Query AST to modify
-     * @returns AST with hydration metadata
-     */
-    applyToAst(ast: SelectQueryNode): SelectQueryNode;
-    /**
-     * Gets the current hydration plan
-     * @returns Hydration plan or undefined if none exists
-     */
-    getPlan(): HydrationPlan | undefined;
-    /**
-     * Attaches hydration metadata to a query AST node.
-     */
-    private attachHydrationMeta;
-    /**
-     * Determines whether the query needs pagination rewriting to keep LIMIT/OFFSET
-     * applied to parent rows when eager-loading multiplicative relations.
-     */
-    private requiresParentPagination;
-    private hasMultiplyingRelations;
-    /**
-     * Rewrites the query using CTEs so LIMIT/OFFSET target distinct parent rows
-     * instead of the joined result set.
-     *
-     * The strategy:
-     * - Hoist the original query (minus limit/offset) into a base CTE.
-     * - Select distinct parent ids from that base CTE with the original ordering and pagination.
-     * - Join the base CTE against the paged ids to retrieve the joined rows for just that page.
-     */
-    private wrapForParentPagination;
-    private nextCteName;
-    private getProjectionNames;
-    private buildProjectionAliasMap;
-    private mapOrderBy;
-    private buildPagingColumns;
-}
-
-/**
- * Result of column selection operation
- */
-interface ColumnSelectionResult {
-    /**
-     * Updated query state
-     */
-    state: SelectQueryState;
-    /**
-     * Columns that were added
-     */
-    addedColumns: ProjectionNode[];
-}
-/**
- * Service for manipulating query AST (Abstract Syntax Tree)
- */
-declare class QueryAstService {
-    private readonly table;
-    private readonly state;
-    /**
-     * Creates a new QueryAstService instance
-     * @param table - Table definition
-     * @param state - Current query state
-     */
-    constructor(table: TableDef, state: SelectQueryState);
-    /**
-     * Selects columns for the query
-     * @param columns - Columns to select (key: alias, value: column definition or expression)
-     * @returns Column selection result with updated state and added columns
-     */
-    select(columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>): ColumnSelectionResult;
-    /**
-     * Selects raw column expressions (best-effort parser for simple references/functions)
-     * @param cols - Raw column expressions
-     * @returns Column selection result with updated state and added columns
-     */
-    selectRaw(cols: string[]): ColumnSelectionResult;
-    /**
-     * Adds a Common Table Expression (CTE) to the query
-     * @param name - Name of the CTE
-     * @param query - Query for the CTE
-     * @param columns - Optional column names for the CTE
-     * @param recursive - Whether the CTE is recursive
-     * @returns Updated query state with CTE
-     */
-    withCte(name: string, query: SelectQueryNode, columns?: string[], recursive?: boolean): SelectQueryState;
-    /**
-     * Adds a set operation (UNION/UNION ALL/INTERSECT/EXCEPT) to the query
-     * @param operator - Set operator
-     * @param query - Right-hand side query
-     * @returns Updated query state with set operation
-     */
-    withSetOperation(operator: SetOperationKind, query: SelectQueryNode): SelectQueryState;
-    /**
-     * Replaces the FROM clause for the current query.
-     * @param from - Table source to use in the FROM clause
-     * @returns Updated query state with new FROM
-     */
-    withFrom(from: TableSourceNode): SelectQueryState;
-    /**
-     * Selects a subquery as a column
-     * @param alias - Alias for the subquery
-     * @param query - Subquery to select
-     * @returns Updated query state with subquery selection
-     */
-    selectSubquery(alias: string, query: SelectQueryNode): SelectQueryState;
-    /**
-     * Adds a JOIN clause to the query
-     * @param join - Join node to add
-     * @returns Updated query state with JOIN
-     */
-    withJoin(join: JoinNode): SelectQueryState;
-    /**
-     * Adds a WHERE clause to the query
-     * @param expr - Expression for the WHERE clause
-     * @returns Updated query state with WHERE clause
-     */
-    withWhere(expr: ExpressionNode): SelectQueryState;
-    /**
-     * Adds a GROUP BY clause to the query
-     * @param col - Column to group by
-     * @returns Updated query state with GROUP BY clause
-     */
-    withGroupBy(col: ColumnDef | ColumnNode): SelectQueryState;
-    /**
-     * Adds a HAVING clause to the query
-     * @param expr - Expression for the HAVING clause
-     * @returns Updated query state with HAVING clause
-     */
-    withHaving(expr: ExpressionNode): SelectQueryState;
-    /**
-     * Adds an ORDER BY clause to the query
-     * @param col - Column to order by
-     * @param direction - Order direction (ASC/DESC)
-     * @returns Updated query state with ORDER BY clause
-     */
-    withOrderBy(col: ColumnDef | ColumnNode, direction: OrderDirection): SelectQueryState;
-    /**
-     * Adds a DISTINCT clause to the query
-     * @param cols - Columns to make distinct
-     * @returns Updated query state with DISTINCT clause
-     */
-    withDistinct(cols: ColumnNode[]): SelectQueryState;
-    /**
-     * Adds a LIMIT clause to the query
-     * @param limit - Maximum number of rows to return
-     * @returns Updated query state with LIMIT clause
-     */
-    withLimit(limit: number): SelectQueryState;
-    /**
-     * Adds an OFFSET clause to the query
-     * @param offset - Number of rows to skip
-     * @returns Updated query state with OFFSET clause
-     */
-    withOffset(offset: number): SelectQueryState;
-    /**
-     * Combines expressions with AND operator
-     * @param existing - Existing expression
-     * @param next - New expression to combine
-     * @returns Combined expression
-     */
-    private combineExpressions;
-}
-
-/**
- * Result of a relation operation
- */
-interface RelationResult {
-    /**
-     * Updated query state
-     */
-    state: SelectQueryState;
-    /**
-     * Updated hydration manager
-     */
-    hydration: HydrationManager;
-}
-
-/**
- * Join kinds allowed when including a relation using `.include(...)`.
- */
-type RelationIncludeJoinKind = typeof JOIN_KINDS.LEFT | typeof JOIN_KINDS.INNER;
-/**
- * Options for including a relation in a query
- */
-interface RelationIncludeOptions {
-    columns?: string[];
-    aliasPrefix?: string;
-    filter?: ExpressionNode;
-    joinKind?: RelationIncludeJoinKind;
-    pivot?: {
-        columns?: string[];
-        aliasPrefix?: string;
-    };
-}
-
-/**
- * Service for handling relation operations (joins, includes, etc.)
- */
-declare class RelationService {
-    private readonly table;
-    private readonly state;
-    private readonly hydration;
-    private readonly createQueryAstService;
-    private readonly projectionHelper;
-    /**
-     * Creates a new RelationService instance
-     * @param table - Table definition
-     * @param state - Current query state
-     * @param hydration - Hydration manager
-     */
-    constructor(table: TableDef, state: SelectQueryState, hydration: HydrationManager, createQueryAstService: (table: TableDef, state: SelectQueryState) => QueryAstService);
-    /**
-     * Joins a relation to the query
-     * @param relationName - Name of the relation to join
-     * @param joinKind - Type of join to use
-     * @param extraCondition - Additional join condition
-     * @returns Relation result with updated state and hydration
-     */
-    joinRelation(relationName: string, joinKind: JoinKind, extraCondition?: ExpressionNode): RelationResult;
-    /**
-     * Matches records based on a relation with an optional predicate
-     * @param relationName - Name of the relation to match
-     * @param predicate - Optional predicate expression
-     * @returns Relation result with updated state and hydration
-     */
-    match(relationName: string, predicate?: ExpressionNode): RelationResult;
-    /**
-     * Includes a relation in the query result
-     * @param relationName - Name of the relation to include
-     * @param options - Options for relation inclusion
-     * @returns Relation result with updated state and hydration
-     */
-    include(relationName: string, options?: RelationIncludeOptions): RelationResult;
-    /**
-     * Applies relation correlation to a query AST
-     * @param relationName - Name of the relation
-     * @param ast - Query AST to modify
-     * @returns Modified query AST with relation correlation
-     */
-    applyRelationCorrelation(relationName: string, ast: SelectQueryNode, additionalCorrelation?: ExpressionNode): SelectQueryNode;
-    /**
-     * Creates a join node for a relation
-     * @param state - Current query state
-     * @param relationName - Name of the relation
-     * @param joinKind - Type of join to use
-     * @param extraCondition - Additional join condition
-     * @returns Updated query state with join
-     */
-    private withJoin;
-    /**
-     * Selects columns for a relation
-     * @param state - Current query state
-     * @param hydration - Hydration manager
-     * @param columns - Columns to select
-     * @returns Relation result with updated state and hydration
-     */
-    private selectColumns;
-    /**
-     * Gets a relation definition by name
-     * @param relationName - Name of the relation
-     * @returns Relation definition
-     * @throws Error if relation is not found
-     */
-    private getRelation;
-    /**
-     * Creates a QueryAstService instance
-     * @param state - Current query state
-     * @returns QueryAstService instance
-     */
-    private astService;
-    private rootTableName;
-}
-
-/**
- * Dependencies for query builder operations
- */
-interface SelectQueryBuilderDependencies {
-    /**
-     * Creates a new query state
-     * @param table - Table definition
-     * @returns New query state
-     */
-    createState: (table: TableDef) => SelectQueryState;
-    /**
-     * Creates a new hydration manager
-     * @param table - Table definition
-     * @returns New hydration manager
-     */
-    createHydration: (table: TableDef) => HydrationManager;
-    /**
-     * Creates a new hydration planner
-     * @param table - Table definition
-     * @returns Hydration planner
-     */
-    createHydrationPlanner: (table: TableDef) => HydrationPlanner;
-    /**
-     * Creates a new query AST service
-     * @param table - Table definition
-     * @param state - Query state
-     * @returns New query AST service
-     */
-    createQueryAstService: (table: TableDef, state: SelectQueryState) => QueryAstService;
-    /**
-     * Creates a new relation service
-     * @param table - Table definition
-     * @param state - Query state
-     * @param hydration - Hydration manager
-     * @returns New relation service
-     */
-    createRelationService: (table: TableDef, state: SelectQueryState, hydration: HydrationManager) => RelationService;
-}
-
-type QueryResult = {
-    columns: string[];
-    values: unknown[][];
-};
-interface DbExecutor {
-    executeSql(sql: string, params?: unknown[]): Promise<QueryResult[]>;
-    beginTransaction?(): Promise<void>;
-    commitTransaction?(): Promise<void>;
-    rollbackTransaction?(): Promise<void>;
-}
-/**
- * Convert an array of row objects into a QueryResult.
- */
-declare function rowsToQueryResult(rows: Array<Record<string, unknown>>): QueryResult;
-/**
- * Minimal contract that most SQL clients can implement.
- */
-interface SimpleQueryRunner {
-    query(sql: string, params?: unknown[]): Promise<Array<Record<string, unknown>>>;
-    beginTransaction?(): Promise<void>;
-    commitTransaction?(): Promise<void>;
-    rollbackTransaction?(): Promise<void>;
-}
-/**
- * Generic factory: turn any SimpleQueryRunner into a DbExecutor.
- */
-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;
-} | {
-    kind: 'attach';
-    entity: T;
-} | {
-    kind: 'remove';
-    entity: T;
-} | {
-    kind: 'detach';
-    entity: T;
-};
-/**
- * Represents a relation change entry in the unit of work
- */
-interface RelationChangeEntry {
-    /** Root entity that owns the relation */
-    root: any;
-    /** Key of the relation being changed */
-    relationKey: RelationKey;
-    /** Table definition of the root entity */
-    rootTable: TableDef;
-    /** Name of the relation */
-    relationName: string;
-    /** Relation definition */
-    relation: RelationDef;
-    /** The change being applied */
-    change: RelationChange<any>;
-}
-/**
- * Represents a domain event that can be emitted by entities
- * @typeParam TType - Type of the event (string literal)
- */
-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[];
-}
-
-/**
- * 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: TableSourceNode | string): string;
-    /**
-     * Converts a column reference to a property name
-     * @param column - Column node
-     * @returns Valid TypeScript property name
-     */
-    columnToProperty(column: ColumnNode): string;
-}
-
-interface QueryContext {
-    sql: string;
-    params: unknown[];
-}
-type QueryInterceptor = (ctx: QueryContext, next: () => Promise<QueryResult[]>) => Promise<QueryResult[]>;
-declare class InterceptorPipeline {
-    private interceptors;
-    use(interceptor: QueryInterceptor): void;
-    run(ctx: QueryContext, executor: DbExecutor): Promise<QueryResult[]>;
-}
-
-interface OrmOptions<E extends DomainEvent = OrmDomainEvent> {
-    dialect: Dialect;
-    executorFactory: DbExecutorFactory;
-    interceptors?: InterceptorPipeline;
-    namingStrategy?: NamingStrategy;
-}
-interface DbExecutorFactory {
-    createExecutor(options?: {
-        tx?: ExternalTransaction;
-    }): DbExecutor;
-    createTransactionalExecutor(): DbExecutor;
-}
-interface ExternalTransaction {
-}
-declare class Orm<E extends DomainEvent = OrmDomainEvent> {
-    readonly dialect: Dialect;
-    readonly interceptors: InterceptorPipeline;
-    readonly namingStrategy: NamingStrategy;
-    private readonly executorFactory;
-    constructor(opts: OrmOptions<E>);
-    createSession(options?: {
-        tx?: ExternalTransaction;
-    }): OrmSession<E>;
-    transaction<T>(fn: (session: OrmSession<E>) => Promise<T>): Promise<T>;
-}
-
-declare class IdentityMap {
-    private readonly buckets;
-    get bucketsMap(): Map<string, Map<string, TrackedEntity>>;
-    getEntity(table: TableDef, pk: string | number): any | undefined;
-    register(tracked: TrackedEntity): void;
-    remove(tracked: TrackedEntity): void;
-    getEntitiesForTable(table: TableDef): TrackedEntity[];
-    clear(): void;
-    private toIdentityKey;
-}
-
-declare class UnitOfWork {
-    private readonly dialect;
-    private readonly executor;
-    private readonly identityMap;
-    private readonly hookContext;
-    private readonly trackedEntities;
-    constructor(dialect: Dialect, executor: DbExecutor, identityMap: IdentityMap, hookContext: () => unknown);
-    get identityBuckets(): Map<string, Map<string, TrackedEntity>>;
-    getTracked(): TrackedEntity[];
-    getEntity(table: TableDef, pk: string | number): any | undefined;
-    getEntitiesForTable(table: TableDef): TrackedEntity[];
-    findTracked(entity: any): TrackedEntity | undefined;
-    setEntity(table: TableDef, pk: string | number, entity: any): void;
-    trackNew(table: TableDef, entity: any, pk?: string | number): void;
-    trackManaged(table: TableDef, pk: string | number, entity: any): void;
-    markDirty(entity: any): void;
-    markRemoved(entity: any): void;
-    flush(): Promise<void>;
-    reset(): void;
-    private flushInsert;
-    private flushUpdate;
-    private flushDelete;
-    private runHook;
-    private computeChanges;
-    private extractColumns;
-    private executeCompiled;
-    private getReturningColumns;
-    private applyReturningResults;
-    private normalizeColumnName;
-    private registerIdentity;
-    private createSnapshot;
-    private getPrimaryKeyValue;
-}
-
-type EventOfType<E extends DomainEvent, TType extends E['type']> = Extract<E, {
-    type: TType;
-}>;
-type DomainEventHandler<E extends DomainEvent, Context> = (event: E, ctx: Context) => Promise<void> | void;
-type InitialHandlers<E extends DomainEvent, Context> = {
-    [K in E['type']]?: DomainEventHandler<EventOfType<E, K>, Context>[];
-};
-declare class DomainEventBus<E extends DomainEvent, Context> {
-    private readonly handlers;
-    constructor(initialHandlers?: InitialHandlers<E, Context>);
-    on<TType extends E['type']>(type: TType, handler: DomainEventHandler<EventOfType<E, TType>, Context>): void;
-    register<TType extends E['type']>(type: TType, handler: DomainEventHandler<EventOfType<E, TType>, Context>): void;
-    dispatch(trackedEntities: Iterable<TrackedEntity>, ctx: Context): Promise<void>;
-}
-declare const addDomainEvent: <E extends DomainEvent>(entity: HasDomainEvents<E>, event: E) => void;
-
-declare class RelationChangeProcessor {
-    private readonly unitOfWork;
-    private readonly dialect;
-    private readonly executor;
-    private readonly relationChanges;
-    constructor(unitOfWork: UnitOfWork, dialect: Dialect, executor: DbExecutor);
-    registerChange(entry: RelationChangeEntry): void;
-    reset(): void;
-    process(): Promise<void>;
-    private handleHasManyChange;
-    private handleHasOneChange;
-    private handleBelongsToChange;
-    private handleBelongsToManyChange;
-    private assignHasManyForeignKey;
-    private detachHasManyChild;
-    private assignHasOneForeignKey;
-    private detachHasOneChild;
-    private insertPivotRow;
-    private deletePivotRow;
-    private resolvePrimaryKeyValue;
-}
-
-/**
- * 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;
-
-/**
- * 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;
-}
-
-interface EntityContext {
-    dialect: Dialect;
-    executor: DbExecutor;
-    getEntity(table: TableDef, pk: any): any;
-    setEntity(table: TableDef, pk: any, entity: any): void;
-    trackNew(table: TableDef, entity: any, pk?: any): void;
-    trackManaged(table: TableDef, pk: any, entity: any): void;
-    markDirty(entity: any): void;
-    markRemoved(entity: any): void;
-    getEntitiesForTable(table: TableDef): TrackedEntity[];
-    registerRelationChange(root: any, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<any>): void;
-}
-
-interface HydrationContext<E extends DomainEvent = AnyDomainEvent> {
-    identityMap: IdentityMap;
-    unitOfWork: UnitOfWork;
-    domainEvents: DomainEventBus<E, OrmSession<E>>;
-    relationChanges: RelationChangeProcessor;
-    entityContext: EntityContext;
-}
-
-interface OrmInterceptor {
-    beforeFlush?(ctx: EntityContext): Promise<void> | void;
-    afterFlush?(ctx: EntityContext): Promise<void> | void;
-}
-interface OrmSessionOptions<E extends DomainEvent = OrmDomainEvent> {
-    orm: Orm<E>;
-    executor: DbExecutor;
-    queryLogger?: QueryLogger;
-    interceptors?: OrmInterceptor[];
-    domainEventHandlers?: InitialHandlers<E, OrmSession<E>>;
-}
-declare class OrmSession<E extends DomainEvent = OrmDomainEvent> implements EntityContext {
-    readonly orm: Orm<E>;
-    readonly executor: DbExecutor;
-    readonly identityMap: IdentityMap;
-    readonly unitOfWork: UnitOfWork;
-    readonly domainEvents: DomainEventBus<E, OrmSession<E>>;
-    readonly relationChanges: RelationChangeProcessor;
-    private readonly interceptors;
-    constructor(opts: OrmSessionOptions<E>);
-    get dialect(): Dialect;
-    get identityBuckets(): Map<string, Map<string, TrackedEntity>>;
-    get tracked(): TrackedEntity[];
-    getEntity(table: TableDef, pk: any): any | undefined;
-    setEntity(table: TableDef, pk: any, entity: any): void;
-    trackNew(table: TableDef, entity: any, pk?: any): void;
-    trackManaged(table: TableDef, pk: any, entity: any): void;
-    markDirty(entity: any): void;
-    markRemoved(entity: any): void;
-    registerRelationChange: (root: any, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<any>) => void;
-    getEntitiesForTable(table: TableDef): TrackedEntity[];
-    registerInterceptor(interceptor: OrmInterceptor): void;
-    registerDomainEventHandler<TType extends E['type']>(type: TType, handler: DomainEventHandler<Extract<E, {
-        type: TType;
-    }>, OrmSession<E>>): void;
-    find<TTable extends TableDef>(entityClass: EntityConstructor, id: any): Promise<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)[];
-};
-type WhereHasOptions = {
-    correlate?: ExpressionNode;
-};
-type RelationCallback = <TChildTable extends TableDef>(qb: SelectQueryBuilder<any, TChildTable>) => SelectQueryBuilder<any, 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> {
-    private readonly env;
-    private readonly context;
-    private readonly columnSelector;
-    private readonly relationManager;
-    private readonly lazyRelations;
-    /**
-  
-     * Creates a new SelectQueryBuilder instance
-  
-     * @param table - Table definition to query
-  
-     * @param state - Optional initial query state
-  
-     * @param hydration - Optional hydration manager
-  
-     * @param dependencies - Optional query builder dependencies
-  
-     */
-    constructor(table: TTable, state?: SelectQueryState, hydration?: HydrationManager, dependencies?: Partial<SelectQueryBuilderDependencies>, lazyRelations?: Set<string>);
-    private clone;
-    /**
-     * Applies an alias to the root FROM table.
-     * @param alias - Alias to apply
-     */
-    as(alias: string): SelectQueryBuilder<T, TTable>;
-    private resolveQueryNode;
-    private applyCorrelation;
-    private createChildBuilder;
-    private applyAst;
-    private applyJoin;
-    private applySetOperation;
-    /**
-  
-     * Selects specific columns for the query
-  
-     * @param columns - Record of column definitions, function nodes, case expressions, or window functions
-  
-     * @returns New query builder instance with selected columns
-  
-     */
-    select(columns: Record<string, ColumnSelectionValue>): SelectQueryBuilder<T, TTable>;
-    /**
-     * Selects columns from the root table by name (typed).
-     * @param cols - Column names on the root table
-     */
-    selectColumns<K extends keyof TTable['columns'] & string>(...cols: K[]): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Selects raw column expressions
-  
-     * @param cols - Column expressions as strings
-  
-     * @returns New query builder instance with raw column selections
-  
-     */
-    selectRaw(...cols: string[]): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Adds a Common Table Expression (CTE) to the query
-  
-     * @param name - Name of the CTE
-  
-     * @param query - Query builder or query node for the CTE
-  
-     * @param columns - Optional column names for the CTE
-  
-     * @returns New query builder instance with the CTE
-  
-     */
-    with(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Adds a recursive Common Table Expression (CTE) to the query
-  
-     * @param name - Name of the CTE
-  
-     * @param query - Query builder or query node for the CTE
-  
-     * @param columns - Optional column names for the CTE
-  
-     * @returns New query builder instance with the recursive CTE
-  
-     */
-    withRecursive(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable>;
-    /**
-     * Replaces the FROM clause with a derived table (subquery with alias)
-     * @param subquery - Subquery to use as the FROM source
-     * @param alias - Alias for the derived table
-     * @param columnAliases - Optional column alias list
-     * @returns New query builder instance with updated FROM
-     */
-    fromSubquery(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, alias: string, columnAliases?: string[]): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Selects a subquery as a column
-  
-     * @param alias - Alias for the subquery column
-  
-     * @param sub - Query builder or query node for the subquery
-  
-     * @returns New query builder instance with the subquery selection
-  
-     */
-    selectSubquery(alias: string, sub: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
-    /**
-     * Adds a JOIN against a derived table (subquery with alias)
-     * @param subquery - Subquery to join
-     * @param alias - Alias for the derived table
-     * @param condition - Join condition expression
-     * @param joinKind - Join kind (defaults to INNER)
-     * @param columnAliases - Optional column alias list for the derived table
-     * @returns New query builder instance with the derived-table join
-     */
-    joinSubquery(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, alias: string, condition: BinaryExpressionNode, joinKind?: JoinKind, columnAliases?: string[]): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Adds an INNER JOIN to the query
-  
-     * @param table - Table to join
-  
-     * @param condition - Join condition expression
-  
-     * @returns New query builder instance with the INNER JOIN
-  
-     */
-    innerJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Adds a LEFT JOIN to the query
-  
-     * @param table - Table to join
-  
-     * @param condition - Join condition expression
-  
-     * @returns New query builder instance with the LEFT JOIN
-  
-     */
-    leftJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Adds a RIGHT JOIN to the query
-  
-     * @param table - Table to join
-  
-     * @param condition - Join condition expression
-  
-     * @returns New query builder instance with the RIGHT JOIN
-  
-     */
-    rightJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Matches records based on a relationship
-  
-     * @param relationName - Name of the relationship to match
-  
-     * @param predicate - Optional predicate expression
-  
-     * @returns New query builder instance with the relationship match
-  
-     */
-    match(relationName: string, predicate?: ExpressionNode): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Joins a related table
-  
-     * @param relationName - Name of the relationship to join
-  
-     * @param joinKind - Type of join (defaults to INNER)
-  
-     * @param extraCondition - Optional additional join condition
-  
-     * @returns New query builder instance with the relationship join
-  
-     */
-    joinRelation(relationName: string, joinKind?: JoinKind, extraCondition?: ExpressionNode): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Includes related data in the query results
-  
-     * @param relationName - Name of the relationship to include
-  
-     * @param options - Optional include options
-  
-     * @returns New query builder instance with the relationship inclusion
-  
-     */
-    include(relationName: string, options?: RelationIncludeOptions): SelectQueryBuilder<T, TTable>;
-    includeLazy<K extends keyof RelationMap<TTable>>(relationName: K): SelectQueryBuilder<T, TTable>;
-    /**
-     * Selects columns for a related table in a single hop.
-     */
-    selectRelationColumns<K extends keyof TTable['relations'] & string, TRel extends RelationDef = TTable['relations'][K], TTarget extends TableDef = RelationTargetTable<TRel>, C extends keyof TTarget['columns'] & string = keyof TTarget['columns'] & string>(relationName: K, ...cols: C[]): SelectQueryBuilder<T, TTable>;
-    /**
-     * Convenience alias for selecting specific columns from a relation.
-     */
-    includePick<K extends keyof TTable['relations'] & string, TRel extends RelationDef = TTable['relations'][K], TTarget extends TableDef = RelationTargetTable<TRel>, C extends keyof TTarget['columns'] & string = keyof TTarget['columns'] & string>(relationName: K, cols: C[]): SelectQueryBuilder<T, TTable>;
-    /**
-     * Selects columns for the root table and relations from a single config object.
-     */
-    selectColumnsDeep(config: DeepSelectConfig<TTable>): SelectQueryBuilder<T, TTable>;
-    getLazyRelations(): (keyof RelationMap<TTable>)[];
-    getTable(): TTable;
-    execute(ctx: OrmSession): Promise<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, correlate?: ExpressionNode): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Adds a WHERE NOT EXISTS condition to the query
-  
-     * @param subquery - Subquery to check for non-existence
-  
-     * @returns New query builder instance with the WHERE NOT EXISTS condition
-  
-     */
-    whereNotExists(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, correlate?: ExpressionNode): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Adds a WHERE EXISTS condition based on a relationship
-  
-     * @param relationName - Name of the relationship to check
-  
-     * @param callback - Optional callback to modify the relationship query
-  
-     * @returns New query builder instance with the relationship existence check
-  
-     */
-    whereHas(relationName: string, callbackOrOptions?: RelationCallback | WhereHasOptions, maybeOptions?: WhereHasOptions): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Adds a WHERE NOT EXISTS condition based on a relationship
-  
-     * @param relationName - Name of the relationship to check
-  
-     * @param callback - Optional callback to modify the relationship query
-  
-     * @returns New query builder instance with the relationship non-existence check
-  
-     */
-    whereHasNot(relationName: string, callbackOrOptions?: RelationCallback | WhereHasOptions, maybeOptions?: WhereHasOptions): SelectQueryBuilder<T, TTable>;
-    /**
-  
-     * Compiles the query to SQL for a specific dialect
-  
-     * @param dialect - Database dialect to compile for
-  
-     * @returns Compiled query with SQL and parameters
-  
-     */
-    compile(dialect: SelectDialectInput): CompiledQuery;
-    /**
-  
-     * Converts the query to SQL string for a specific dialect
-  
-     * @param dialect - Database dialect to generate SQL for
-  
-     * @returns SQL string representation of the query
-  
-     */
-    toSql(dialect: SelectDialectInput): string;
-    /**
-  
-     * Gets the hydration plan for the query
-  
-     * @returns Hydration plan or undefined if none exists
-  
-     */
-    getHydrationPlan(): HydrationPlan | undefined;
-    /**
-  
-     * Gets the Abstract Syntax Tree (AST) representation of the query
-  
-     * @returns Query AST with hydration applied
-  
-     */
-    getAST(): SelectQueryNode;
-}
-/**
-
- * 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 HydrationContext as $, type Entity as A, type BinaryExpressionNode as B, type ColumnRef as C, Dialect as D, type ExpressionNode as E, type FunctionNode as F, type HasManyRelation as G, type HydrationPlan as H, type InExpressionNode as I, type JsonPathNode as J, type HasOneRelation as K, type LiteralNode as L, type BelongsToRelation as M, type NullExpressionNode as N, type OperandNode as O, type BelongsToManyRelation as P, type HasManyCollection as Q, type RelationMap as R, type SelectQueryNode as S, type TableRef as T, type UpdateQueryNode as U, type BelongsToReference as V, type WindowFunctionNode as W, type ManyToManyCollection as X, OrmSession as Y, SelectQueryBuilder as Z, type ExecutionContext as _, type ColumnNode as a, type CheckConstraint as a0, type TableOptions as a1, type TableHooks as a2, defineTable as a3, type ColumnType as a4, type ReferentialAction as a5, type RawDefaultValue as a6, type DefaultValue as a7, col as a8, RelationKinds as a9, Orm as aA, type DomainEventHandler as aB, type InitialHandlers as aC, DomainEventBus as aD, addDomainEvent as aE, EntityStatus as aF, type TrackedEntity as aG, type RelationKey as aH, type RelationChange as aI, type RelationChangeEntry as aJ, type DomainEvent as aK, type AnyDomainEvent as aL, type OrmDomainEvent as aM, type HasDomainEvents as aN, type QueryLogEntry as aO, type QueryLogger as aP, createQueryLoggingExecutor as aQ, type QueryResult as aR, rowsToQueryResult as aS, type SimpleQueryRunner as aT, createExecutorFromQueryRunner as aU, type EntityOrTableTargetResolver as aV, type EntityConstructor as aW, type RelationType as aa, type CascadeMode as ab, type RelationDef as ac, hasMany as ad, hasOne as ae, belongsTo as af, belongsToMany as ag, type RelationTargetTable as ah, type ColumnToTs as ai, type InferRow as aj, type HasOneReference as ak, createColumn as al, createLiteral as am, isOperandNode as an, isFunctionNode as ao, isCaseExpressionNode as ap, isWindowFunctionNode as aq, isExpressionSelectionNode as ar, type HydrationPivotPlan as as, type HydrationRelationPlan as at, type HydrationMetadata as au, type OrmInterceptor as av, type OrmSessionOptions as aw, type OrmOptions as ax, type DbExecutorFactory as ay, type ExternalTransaction 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 FunctionTableNode as r, type DerivedTableNode as s, type TableSourceNode as t, type ForeignKeyReference as u, type IndexColumn as v, type IndexDef as w, type DbExecutor as x, type NamingStrategy as y, type EntityContext as z };