metal-orm 1.0.7 → 1.0.9

package/dist/index.d.cts

@@ -0,0 +1,701 @@
+import { O as OperandNode, C as ColumnDef, a as ColumnNode, B as BinaryExpressionNode, E as ExpressionNode, L as LogicalExpressionNode, N as NullExpressionNode, b as LiteralNode, I as InExpressionNode, c as BetweenExpressionNode, J as JsonPathNode, d as CaseExpressionNode, S as SelectQueryNode, e as ExistsExpressionNode, W as WindowFunctionNode, f as OrderDirection, F as FunctionNode, g as ScalarSubqueryNode, T as TableDef, h as InsertQueryNode, i as InsertCompiler, j as CompiledQuery, U as UpdateQueryNode, k as UpdateCompiler, D as DeleteQueryNode, l as DeleteCompiler, m as Dialect, n as CompilerContext, H as HydrationPlan, R as RelationMap, o as OrmContext, p as Entity, q as HasManyRelation, r as BelongsToRelation, s as BelongsToManyRelation, t as HasManyCollection, u as BelongsToReference, M as ManyToManyCollection, v as SelectQueryBuilder } from './select-654m4qy8.cjs';
+export { K as CascadeMode, Y as ColumnToTs, y as ColumnType, a8 as DbExecutor, ad as DomainEventHandler, a6 as EntityStatus, ab as HasDomainEvents, Z as InferRow, ae as OrmContextOptions, ac as OrmInterceptor, a7 as QueryResult, aa as RelationChange, P as RelationDef, a9 as RelationKey, A as RelationKinds, G as RelationType, w as TableHooks, a5 as addDomainEvent, V as belongsTo, X as belongsToMany, z as col, _ as createColumn, $ as createLiteral, x as defineTable, Q as hasMany, a2 as isCaseExpressionNode, a4 as isExpressionSelectionNode, a1 as isFunctionNode, a0 as isOperandNode, a3 as isWindowFunctionNode } from './select-654m4qy8.cjs';
+
+/**
+ * Converts a primitive or existing operand into an operand node
+ * @param value - Value or operand to normalize
+ * @returns OperandNode representing the value
+ */
+declare const valueToOperand: (value: unknown) => OperandNode;
+declare const columnOperand: (col: ColumnDef | ColumnNode) => ColumnNode;
+/**
+ * Creates an equality expression (left = right)
+ * @param left - Left operand
+ * @param right - Right operand
+ * @returns Binary expression node with equality operator
+ */
+declare const eq: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDef | string | number) => BinaryExpressionNode;
+/**
+ * Creates a not equal expression (left != right)
+ */
+declare const neq: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDef | string | number) => BinaryExpressionNode;
+/**
+ * Creates a greater-than expression (left > right)
+ * @param left - Left operand
+ * @param right - Right operand
+ * @returns Binary expression node with greater-than operator
+ */
+declare const gt: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDef | string | number) => BinaryExpressionNode;
+/**
+ * Creates a greater than or equal expression (left >= right)
+ */
+declare const gte: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDef | string | number) => BinaryExpressionNode;
+/**
+ * Creates a less-than expression (left < right)
+ * @param left - Left operand
+ * @param right - Right operand
+ * @returns Binary expression node with less-than operator
+ */
+declare const lt: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDef | string | number) => BinaryExpressionNode;
+/**
+ * Creates a less than or equal expression (left <= right)
+ */
+declare const lte: (left: OperandNode | ColumnDef, right: OperandNode | ColumnDef | string | number) => BinaryExpressionNode;
+/**
+ * Creates a LIKE pattern matching expression
+ * @param left - Left operand
+ * @param pattern - Pattern to match
+ * @param escape - Optional escape character
+ * @returns Binary expression node with LIKE operator
+ */
+declare const like: (left: OperandNode | ColumnDef, pattern: string, escape?: string) => BinaryExpressionNode;
+/**
+ * Creates a NOT LIKE pattern matching expression
+ * @param left - Left operand
+ * @param pattern - Pattern to match
+ * @param escape - Optional escape character
+ * @returns Binary expression node with NOT LIKE operator
+ */
+declare const notLike: (left: OperandNode | ColumnDef, pattern: string, escape?: string) => BinaryExpressionNode;
+/**
+ * Creates a logical AND expression
+ * @param operands - Expressions to combine with AND
+ * @returns Logical expression node with AND operator
+ */
+declare const and: (...operands: ExpressionNode[]) => LogicalExpressionNode;
+/**
+ * Creates a logical OR expression
+ * @param operands - Expressions to combine with OR
+ * @returns Logical expression node with OR operator
+ */
+declare const or: (...operands: ExpressionNode[]) => LogicalExpressionNode;
+/**
+ * Creates an IS NULL expression
+ * @param left - Operand to check for null
+ * @returns Null expression node with IS NULL operator
+ */
+declare const isNull: (left: OperandNode | ColumnDef) => NullExpressionNode;
+/**
+ * Creates an IS NOT NULL expression
+ * @param left - Operand to check for non-null
+ * @returns Null expression node with IS NOT NULL operator
+ */
+declare const isNotNull: (left: OperandNode | ColumnDef) => NullExpressionNode;
+/**
+ * Creates an IN expression (value IN list)
+ * @param left - Operand to check
+ * @param values - Values to check against
+ * @returns IN expression node
+ */
+declare const inList: (left: OperandNode | ColumnDef, values: (string | number | LiteralNode)[]) => InExpressionNode;
+/**
+ * Creates a NOT IN expression (value NOT IN list)
+ * @param left - Operand to check
+ * @param values - Values to check against
+ * @returns NOT IN expression node
+ */
+declare const notInList: (left: OperandNode | ColumnDef, values: (string | number | LiteralNode)[]) => InExpressionNode;
+/**
+ * Creates a BETWEEN expression (value BETWEEN lower AND upper)
+ * @param left - Operand to check
+ * @param lower - Lower bound
+ * @param upper - Upper bound
+ * @returns BETWEEN expression node
+ */
+declare const between: (left: OperandNode | ColumnDef, lower: OperandNode | ColumnDef | string | number, upper: OperandNode | ColumnDef | string | number) => BetweenExpressionNode;
+/**
+ * Creates a NOT BETWEEN expression (value NOT BETWEEN lower AND upper)
+ * @param left - Operand to check
+ * @param lower - Lower bound
+ * @param upper - Upper bound
+ * @returns NOT BETWEEN expression node
+ */
+declare const notBetween: (left: OperandNode | ColumnDef, lower: OperandNode | ColumnDef | string | number, upper: OperandNode | ColumnDef | string | number) => BetweenExpressionNode;
+/**
+ * Creates a JSON path expression
+ * @param col - Source column
+ * @param path - JSON path expression
+ * @returns JSON path node
+ */
+declare const jsonPath: (col: ColumnDef | ColumnNode, path: string) => JsonPathNode;
+/**
+ * Creates a CASE expression
+ * @param conditions - Array of WHEN-THEN conditions
+ * @param elseValue - Optional ELSE value
+ * @returns CASE expression node
+ */
+declare const caseWhen: (conditions: {
+    when: ExpressionNode;
+    then: OperandNode | ColumnDef | string | number | boolean | null;
+}[], elseValue?: OperandNode | ColumnDef | string | number | boolean | null) => CaseExpressionNode;
+/**
+ * Creates an EXISTS expression
+ * @param subquery - Subquery to check for existence
+ * @returns EXISTS expression node
+ */
+declare const exists: (subquery: SelectQueryNode) => ExistsExpressionNode;
+/**
+ * Creates a NOT EXISTS expression
+ * @param subquery - Subquery to check for non-existence
+ * @returns NOT EXISTS expression node
+ */
+declare const notExists: (subquery: SelectQueryNode) => ExistsExpressionNode;
+
+/**
+ * Creates a ROW_NUMBER window function
+ * @returns Window function node for ROW_NUMBER
+ */
+declare const rowNumber: () => WindowFunctionNode;
+/**
+ * Creates a RANK window function
+ * @returns Window function node for RANK
+ */
+declare const rank: () => WindowFunctionNode;
+/**
+ * Creates a DENSE_RANK window function
+ * @returns Window function node for DENSE_RANK
+ */
+declare const denseRank: () => WindowFunctionNode;
+/**
+ * Creates an NTILE window function
+ * @param n - Number of buckets
+ * @returns Window function node for NTILE
+ */
+declare const ntile: (n: number) => WindowFunctionNode;
+/**
+ * Creates a LAG window function
+ * @param col - Column to lag
+ * @param offset - Offset (defaults to 1)
+ * @param defaultValue - Default value if no row exists
+ * @returns Window function node for LAG
+ */
+declare const lag: (col: ColumnDef | ColumnNode, offset?: number, defaultValue?: any) => WindowFunctionNode;
+/**
+ * Creates a LEAD window function
+ * @param col - Column to lead
+ * @param offset - Offset (defaults to 1)
+ * @param defaultValue - Default value if no row exists
+ * @returns Window function node for LEAD
+ */
+declare const lead: (col: ColumnDef | ColumnNode, offset?: number, defaultValue?: any) => WindowFunctionNode;
+/**
+ * Creates a FIRST_VALUE window function
+ * @param col - Column to get first value from
+ * @returns Window function node for FIRST_VALUE
+ */
+declare const firstValue: (col: ColumnDef | ColumnNode) => WindowFunctionNode;
+/**
+ * Creates a LAST_VALUE window function
+ * @param col - Column to get last value from
+ * @returns Window function node for LAST_VALUE
+ */
+declare const lastValue: (col: ColumnDef | ColumnNode) => WindowFunctionNode;
+/**
+ * Creates a custom window function
+ * @param name - Window function name
+ * @param args - Function arguments
+ * @param partitionBy - Optional PARTITION BY columns
+ * @param orderBy - Optional ORDER BY clauses
+ * @returns Window function node
+ */
+declare const windowFunction: (name: string, args?: (ColumnDef | ColumnNode | LiteralNode | JsonPathNode)[], partitionBy?: (ColumnDef | ColumnNode)[], orderBy?: {
+    column: ColumnDef | ColumnNode;
+    direction: OrderDirection;
+}[]) => WindowFunctionNode;
+
+/**
+ * Creates a COUNT function expression
+ * @param col - Column to count
+ * @returns Function node with COUNT
+ */
+declare const count: (col: ColumnDef | ColumnNode) => FunctionNode;
+/**
+ * Creates a SUM function expression
+ * @param col - Column to sum
+ * @returns Function node with SUM
+ */
+declare const sum: (col: ColumnDef | ColumnNode) => FunctionNode;
+/**
+ * Creates an AVG function expression
+ * @param col - Column to average
+ * @returns Function node with AVG
+ */
+declare const avg: (col: ColumnDef | ColumnNode) => FunctionNode;
+
+/**
+ * Visitor for expression nodes
+ */
+interface ExpressionVisitor<R> {
+    visitBinaryExpression(node: BinaryExpressionNode): R;
+    visitLogicalExpression(node: LogicalExpressionNode): R;
+    visitNullExpression(node: NullExpressionNode): R;
+    visitInExpression(node: InExpressionNode): R;
+    visitExistsExpression(node: ExistsExpressionNode): R;
+    visitBetweenExpression(node: BetweenExpressionNode): R;
+}
+/**
+ * Visitor for operand nodes
+ */
+interface OperandVisitor<R> {
+    visitColumn(node: ColumnNode): R;
+    visitLiteral(node: LiteralNode): R;
+    visitFunction(node: FunctionNode): R;
+    visitJsonPath(node: JsonPathNode): R;
+    visitScalarSubquery(node: ScalarSubqueryNode): R;
+    visitCaseExpression(node: CaseExpressionNode): R;
+    visitWindowFunction(node: WindowFunctionNode): R;
+}
+/**
+ * Dispatches an expression node to the visitor
+ * @param node - Expression node to visit
+ * @param visitor - Visitor implementation
+ */
+declare const visitExpression: <R>(node: ExpressionNode, visitor: ExpressionVisitor<R>) => R;
+/**
+ * Dispatches an operand node to the visitor
+ * @param node - Operand node to visit
+ * @param visitor - Visitor implementation
+ */
+declare const visitOperand: <R>(node: OperandNode, visitor: OperandVisitor<R>) => R;
+
+/**
+ * Maintains immutable state for building INSERT queries
+ */
+declare class InsertQueryState {
+    readonly table: TableDef;
+    readonly ast: InsertQueryNode;
+    constructor(table: TableDef, ast?: InsertQueryNode);
+    private clone;
+    withValues(rows: Record<string, unknown>[]): InsertQueryState;
+    withReturning(columns: ColumnNode[]): InsertQueryState;
+}
+
+/**
+ * Builder for INSERT queries
+ */
+declare class InsertQueryBuilder<T> {
+    private readonly table;
+    private readonly state;
+    constructor(table: TableDef, state?: InsertQueryState);
+    private clone;
+    values(rowOrRows: Record<string, unknown> | Record<string, unknown>[]): InsertQueryBuilder<T>;
+    returning(...columns: (ColumnDef | ColumnNode)[]): InsertQueryBuilder<T>;
+    compile(compiler: InsertCompiler): CompiledQuery;
+    toSql(compiler: InsertCompiler): string;
+    getAST(): InsertQueryNode;
+}
+
+/**
+ * Immutable state for UPDATE queries
+ */
+declare class UpdateQueryState {
+    readonly table: TableDef;
+    readonly ast: UpdateQueryNode;
+    constructor(table: TableDef, ast?: UpdateQueryNode);
+    private clone;
+    withSet(values: Record<string, unknown>): UpdateQueryState;
+    withWhere(expr: ExpressionNode): UpdateQueryState;
+    withReturning(columns: ColumnNode[]): UpdateQueryState;
+}
+
+/**
+ * Builder for UPDATE queries
+ */
+declare class UpdateQueryBuilder<T> {
+    private readonly table;
+    private readonly state;
+    constructor(table: TableDef, state?: UpdateQueryState);
+    private clone;
+    set(values: Record<string, unknown>): UpdateQueryBuilder<T>;
+    where(expr: ExpressionNode): UpdateQueryBuilder<T>;
+    returning(...columns: (ColumnDef | ColumnNode)[]): UpdateQueryBuilder<T>;
+    compile(compiler: UpdateCompiler): CompiledQuery;
+    toSql(compiler: UpdateCompiler): string;
+    getAST(): UpdateQueryNode;
+}
+
+/**
+ * Maintains immutable state for DELETE queries
+ */
+declare class DeleteQueryState {
+    readonly table: TableDef;
+    readonly ast: DeleteQueryNode;
+    constructor(table: TableDef, ast?: DeleteQueryNode);
+    private clone;
+    withWhere(expr: ExpressionNode): DeleteQueryState;
+    withReturning(columns: ColumnNode[]): DeleteQueryState;
+}
+
+/**
+ * Builder for DELETE queries
+ */
+declare class DeleteQueryBuilder<T> {
+    private readonly table;
+    private readonly state;
+    constructor(table: TableDef, state?: DeleteQueryState);
+    private clone;
+    where(expr: ExpressionNode): DeleteQueryBuilder<T>;
+    returning(...columns: (ColumnDef | ColumnNode)[]): DeleteQueryBuilder<T>;
+    compile(compiler: DeleteCompiler): CompiledQuery;
+    toSql(compiler: DeleteCompiler): string;
+    getAST(): DeleteQueryNode;
+}
+
+/**
+ * MySQL dialect implementation
+ */
+declare class MySqlDialect extends Dialect {
+    /**
+     * Creates a new MySqlDialect instance
+     */
+    constructor();
+    /**
+     * Quotes an identifier using MySQL backtick syntax
+     * @param id - Identifier to quote
+     * @returns Quoted identifier
+     */
+    quoteIdentifier(id: string): string;
+    /**
+     * Compiles JSON path expression using MySQL syntax
+     * @param node - JSON path node
+     * @returns MySQL JSON path expression
+     */
+    protected compileJsonPath(node: JsonPathNode): string;
+    /**
+     * Compiles SELECT query AST to MySQL SQL
+     * @param ast - Query AST
+     * @param ctx - Compiler context
+     * @returns MySQL SQL string
+     */
+    protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
+    protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string;
+    protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string;
+    protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string;
+}
+
+/**
+ * Microsoft SQL Server dialect implementation
+ */
+declare class SqlServerDialect extends Dialect {
+    /**
+     * Creates a new SqlServerDialect instance
+     */
+    constructor();
+    /**
+     * Quotes an identifier using SQL Server bracket syntax
+     * @param id - Identifier to quote
+     * @returns Quoted identifier
+     */
+    quoteIdentifier(id: string): string;
+    /**
+     * Compiles JSON path expression using SQL Server syntax
+     * @param node - JSON path node
+     * @returns SQL Server JSON path expression
+     */
+    protected compileJsonPath(node: JsonPathNode): string;
+    /**
+     * Formats parameter placeholders using SQL Server named parameter syntax
+     * @param index - Parameter index
+     * @returns Named parameter placeholder
+     */
+    protected formatPlaceholder(index: number): string;
+    /**
+     * Compiles SELECT query AST to SQL Server SQL
+     * @param ast - Query AST
+     * @param ctx - Compiler context
+     * @returns SQL Server SQL string
+     */
+    protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
+    protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string;
+    protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string;
+    protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string;
+}
+
+/**
+ * SQLite dialect implementation
+ */
+declare class SqliteDialect extends Dialect {
+    /**
+     * Creates a new SqliteDialect instance
+     */
+    constructor();
+    /**
+     * Quotes an identifier using SQLite double-quote syntax
+     * @param id - Identifier to quote
+     * @returns Quoted identifier
+     */
+    quoteIdentifier(id: string): string;
+    /**
+     * Compiles JSON path expression using SQLite syntax
+     * @param node - JSON path node
+     * @returns SQLite JSON path expression
+     */
+    protected compileJsonPath(node: JsonPathNode): string;
+    /**
+     * Compiles SELECT query AST to SQLite SQL
+     * @param ast - Query AST
+     * @param ctx - Compiler context
+     * @returns SQLite SQL string
+     */
+    protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string;
+    protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string;
+    protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string;
+    protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string;
+    protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string;
+}
+
+/**
+ * Browser-compatible implementation of AsyncLocalStorage
+ * Provides a simple in-memory store for browser environments
+ * @typeParam T - Type of the stored data
+ */
+declare class AsyncLocalStorage<T> {
+    private store;
+    /**
+     * Executes a callback with the specified store value
+     * @param store - Value to store during callback execution
+     * @param callback - Function to execute with the store value
+     * @returns Result of the callback function
+     */
+    run<R>(store: T, callback: () => R): R;
+    /**
+     * Gets the currently stored value
+     * @returns Current store value or undefined if none exists
+     */
+    getStore(): T | undefined;
+}
+
+/**
+ * Hydrates query results according to a hydration plan
+ * @param rows - Raw database rows
+ * @param plan - Hydration plan
+ * @returns Hydrated result objects with nested relations
+ */
+declare const hydrateRows: (rows: Record<string, any>[], plan?: HydrationPlan) => Record<string, any>[];
+
+/**
+ * Generates TypeScript code from query AST nodes
+ */
+declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVisitor<string> {
+    /**
+     * Generates TypeScript code from a query AST
+     * @param ast - Query AST to generate code from
+     * @returns Generated TypeScript code
+     */
+    generate(ast: SelectQueryNode): string;
+    /**
+     * Builds TypeScript method chain lines from query AST
+     * @param ast - Query AST
+     * @returns Array of TypeScript method chain lines
+     */
+    private buildSelectLines;
+    /**
+     * Prints an expression node to TypeScript code
+     * @param expr - Expression node to print
+     * @returns TypeScript code representation
+     */
+    private printExpression;
+    /**
+     * Prints an operand node to TypeScript code
+     * @param node - Operand node to print
+     * @returns TypeScript code representation
+     */
+    private printOperand;
+    visitBinaryExpression(binary: BinaryExpressionNode): string;
+    visitLogicalExpression(logical: LogicalExpressionNode): string;
+    visitNullExpression(nullExpr: NullExpressionNode): string;
+    visitInExpression(inExpr: InExpressionNode): string;
+    visitExistsExpression(existsExpr: ExistsExpressionNode): string;
+    visitBetweenExpression(betweenExpr: BetweenExpressionNode): string;
+    visitColumn(node: ColumnNode): string;
+    visitLiteral(node: LiteralNode): string;
+    visitFunction(node: FunctionNode): string;
+    visitJsonPath(node: JsonPathNode): string;
+    visitScalarSubquery(node: ScalarSubqueryNode): string;
+    visitCaseExpression(node: CaseExpressionNode): string;
+    visitWindowFunction(node: WindowFunctionNode): string;
+    /**
+     * Prints a binary expression to TypeScript code
+     * @param binary - Binary expression node
+     * @returns TypeScript code representation
+     */
+    private printBinaryExpression;
+    /**
+     * Prints a logical expression to TypeScript code
+     * @param logical - Logical expression node
+     * @returns TypeScript code representation
+     */
+    private printLogicalExpression;
+    /**
+     * Prints an IN expression to TypeScript code
+     * @param inExpr - IN expression node
+     * @returns TypeScript code representation
+     */
+    private printInExpression;
+    /**
+     * Prints a null expression to TypeScript code
+     * @param nullExpr - Null expression node
+     * @returns TypeScript code representation
+     */
+    private printNullExpression;
+    /**
+     * Prints a BETWEEN expression to TypeScript code
+     * @param betweenExpr - BETWEEN expression node
+     * @returns TypeScript code representation
+     */
+    private printBetweenExpression;
+    /**
+     * Prints an EXISTS expression to TypeScript code
+     * @param existsExpr - EXISTS expression node
+     * @returns TypeScript code representation
+     */
+    private printExistsExpression;
+    /**
+     * Prints a column operand to TypeScript code
+     * @param column - Column node
+     * @returns TypeScript code representation
+     */
+    private printColumnOperand;
+    /**
+     * Prints a literal operand to TypeScript code
+     * @param literal - Literal node
+     * @returns TypeScript code representation
+     */
+    private printLiteralOperand;
+    /**
+     * Prints a function operand to TypeScript code
+     * @param fn - Function node
+     * @returns TypeScript code representation
+     */
+    private printFunctionOperand;
+    /**
+     * Prints a JSON path operand to TypeScript code
+     * @param json - JSON path node
+     * @returns TypeScript code representation
+     */
+    private printJsonPathOperand;
+    /**
+     * Prints a scalar subquery operand to TypeScript code
+     * @param node - Scalar subquery node
+     * @returns TypeScript code representation
+     */
+    private printScalarSubqueryOperand;
+    /**
+     * Prints a CASE expression operand to TypeScript code
+     * @param node - CASE expression node
+     * @returns TypeScript code representation
+     */
+    private printCaseExpressionOperand;
+    /**
+     * Prints a window function operand to TypeScript code
+     * @param node - Window function node
+     * @returns TypeScript code representation
+     */
+    private printWindowFunctionOperand;
+    /**
+     * Converts method chain lines to inline format
+     * @param lines - Method chain lines
+     * @returns Inline method chain string
+     */
+    private inlineChain;
+    /**
+     * Maps SQL operators to TypeScript function names
+     * @param op - SQL operator
+     * @returns TypeScript function name
+     */
+    private mapOp;
+}
+
+declare const createEntityProxy: <TTable extends TableDef, TLazy extends keyof RelationMap<TTable> = keyof RelationMap<TTable>>(ctx: OrmContext, table: TTable, row: Record<string, any>, lazyRelations?: TLazy[]) => Entity<TTable>;
+declare const createEntityFromRow: <TTable extends TableDef>(ctx: OrmContext, table: TTable, row: Record<string, any>, lazyRelations?: (keyof RelationMap<TTable>)[]) => Entity<TTable>;
+
+type Rows$3 = Record<string, any>[];
+declare const loadHasManyRelation: (ctx: OrmContext, rootTable: TableDef, _relationName: string, relation: HasManyRelation) => Promise<Map<string, Rows$3>>;
+declare const loadBelongsToRelation: (ctx: OrmContext, rootTable: TableDef, _relationName: string, relation: BelongsToRelation) => Promise<Map<string, Record<string, any>>>;
+declare const loadBelongsToManyRelation: (ctx: OrmContext, rootTable: TableDef, _relationName: string, relation: BelongsToManyRelation) => Promise<Map<string, Rows$3>>;
+
+interface EntityMeta<TTable extends TableDef> {
+    ctx: OrmContext;
+    table: TTable;
+    lazyRelations: (keyof RelationMap<TTable>)[];
+    relationCache: Map<string, Promise<any>>;
+    relationHydration: Map<string, Map<string, any>>;
+    relationWrappers: Map<string, unknown>;
+}
+
+type Rows$2 = Record<string, any>[];
+declare class DefaultHasManyCollection<TChild> implements HasManyCollection<TChild> {
+    private readonly ctx;
+    private readonly meta;
+    private readonly root;
+    private readonly relationName;
+    private readonly relation;
+    private readonly rootTable;
+    private readonly loader;
+    private readonly createEntity;
+    private readonly localKey;
+    private loaded;
+    private items;
+    private readonly added;
+    private readonly removed;
+    constructor(ctx: OrmContext, meta: EntityMeta<any>, root: any, relationName: string, relation: HasManyRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows$2>>, createEntity: (row: Record<string, any>) => TChild, localKey: string);
+    load(): Promise<TChild[]>;
+    getItems(): TChild[];
+    add(data: Partial<TChild>): TChild;
+    attach(entity: TChild): void;
+    remove(entity: TChild): void;
+    clear(): void;
+    private get relationKey();
+    private hydrateFromCache;
+}
+
+type Rows$1 = Record<string, any>;
+declare class DefaultBelongsToReference<TParent> implements BelongsToReference<TParent> {
+    private readonly ctx;
+    private readonly meta;
+    private readonly root;
+    private readonly relationName;
+    private readonly relation;
+    private readonly rootTable;
+    private readonly loader;
+    private readonly createEntity;
+    private readonly targetKey;
+    private loaded;
+    private current;
+    constructor(ctx: OrmContext, meta: EntityMeta<any>, root: any, relationName: string, relation: BelongsToRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows$1>>, createEntity: (row: Record<string, any>) => TParent, targetKey: string);
+    load(): Promise<TParent | null>;
+    get(): TParent | null;
+    set(data: Partial<TParent> | TParent | null): TParent | null;
+    private get relationKey();
+    private populateFromHydrationCache;
+}
+
+type Rows = Record<string, any>[];
+declare class DefaultManyToManyCollection<TTarget> implements ManyToManyCollection<TTarget> {
+    private readonly ctx;
+    private readonly meta;
+    private readonly root;
+    private readonly relationName;
+    private readonly relation;
+    private readonly rootTable;
+    private readonly loader;
+    private readonly createEntity;
+    private readonly localKey;
+    private loaded;
+    private items;
+    constructor(ctx: OrmContext, meta: EntityMeta<any>, root: any, relationName: string, relation: BelongsToManyRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows>>, createEntity: (row: Record<string, any>) => TTarget, localKey: string);
+    load(): Promise<TTarget[]>;
+    getItems(): TTarget[];
+    attach(target: TTarget | number | string): void;
+    detach(target: TTarget | number | string): void;
+    syncByIds(ids: (number | string)[]): Promise<void>;
+    private ensureEntity;
+    private extractId;
+    private get relationKey();
+    private get targetKey();
+    private hydrateFromCache;
+}
+
+declare function executeHydrated<TTable extends TableDef>(ctx: OrmContext, qb: SelectQueryBuilder<any, TTable>): Promise<Entity<TTable>[]>;
+
+export { AsyncLocalStorage, BelongsToManyRelation, BelongsToReference, BelongsToRelation, BetweenExpressionNode, BinaryExpressionNode, CaseExpressionNode, ColumnDef, ColumnNode, DefaultBelongsToReference, DefaultHasManyCollection, DefaultManyToManyCollection, DeleteQueryBuilder, Entity, ExistsExpressionNode, ExpressionNode, type ExpressionVisitor, FunctionNode, HasManyCollection, HasManyRelation, InExpressionNode, InsertQueryBuilder, JsonPathNode, LiteralNode, LogicalExpressionNode, ManyToManyCollection, MySqlDialect, NullExpressionNode, OperandNode, type OperandVisitor, OrmContext, RelationMap, ScalarSubqueryNode, SelectQueryBuilder, SqlServerDialect, SqliteDialect, TableDef, TypeScriptGenerator, UpdateQueryBuilder, WindowFunctionNode, and, avg, between, caseWhen, columnOperand, count, createEntityFromRow, createEntityProxy, denseRank, eq, executeHydrated, exists, firstValue, gt, gte, hydrateRows, inList, isNotNull, isNull, jsonPath, lag, lastValue, lead, like, loadBelongsToManyRelation, loadBelongsToRelation, loadHasManyRelation, lt, lte, neq, notBetween, notExists, notInList, notLike, ntile, or, rank, rowNumber, sum, valueToOperand, visitExpression, visitOperand, windowFunction };