metal-orm 1.0.56 → 1.0.58

package/dist/index.d.ts

@@ -453,7 +453,7 @@ type InferRow<TTable extends TableDef> = {
     [K in keyof TTable['columns']]: ColumnToTs<TTable['columns'][K]>;
 };
 type RelationResult$1<T extends RelationDef> = T extends HasManyRelation<infer TTarget> ? InferRow<TTarget>[] : T extends HasOneRelation<infer TTarget> ? InferRow<TTarget> | null : T extends BelongsToRelation<infer TTarget> ? InferRow<TTarget> | null : T extends BelongsToManyRelation<infer TTarget> ? (InferRow<TTarget> & {
-    _pivot?: unknown;
+    _pivot?: Record<string, unknown>;
 })[] : never;
 /**
  * Maps relation names to the expected row results
@@ -461,7 +461,14 @@ type RelationResult$1<T extends RelationDef> = T extends HasManyRelation<infer T
 type RelationMap<TTable extends TableDef> = {
     [K in keyof TTable['relations']]: RelationResult$1<TTable['relations'][K]>;
 };
+type RelationWrapper$1<TRel extends RelationDef> = TRel extends HasManyRelation<infer TTarget> ? HasManyCollection<EntityInstance<TTarget>> & ReadonlyArray<EntityInstance<TTarget>> : TRel extends HasOneRelation<infer TTarget> ? HasOneReference<EntityInstance<TTarget>> : TRel extends BelongsToManyRelation<infer TTarget> ? ManyToManyCollection<EntityInstance<TTarget> & {
+    _pivot?: Record<string, unknown>;
+}> & ReadonlyArray<EntityInstance<TTarget> & {
+    _pivot?: Record<string, unknown>;
+}> : TRel extends BelongsToRelation<infer TTarget> ? BelongsToReference<EntityInstance<TTarget>> : never;
 interface HasManyCollection<TChild> {
+    length: number;
+    [Symbol.iterator](): Iterator<TChild>;
     load(): Promise<TChild[]>;
     getItems(): TChild[];
     add(data: Partial<TChild>): TChild;
@@ -469,17 +476,21 @@ interface HasManyCollection<TChild> {
     remove(entity: TChild): void;
     clear(): void;
 }
-interface BelongsToReference<TParent> {
+interface BelongsToReferenceApi<TParent extends object = object> {
     load(): Promise<TParent | null>;
     get(): TParent | null;
     set(data: Partial<TParent> | TParent | null): TParent | null;
 }
-interface HasOneReference<TChild> {
+type BelongsToReference<TParent extends object = object> = BelongsToReferenceApi<TParent> & Partial<TParent>;
+interface HasOneReferenceApi<TChild extends object = object> {
     load(): Promise<TChild | null>;
     get(): TChild | null;
     set(data: Partial<TChild> | TChild | null): TChild | null;
 }
+type HasOneReference<TChild extends object = object> = HasOneReferenceApi<TChild> & Partial<TChild>;
 interface ManyToManyCollection<TTarget> {
+    length: number;
+    [Symbol.iterator](): Iterator<TTarget>;
     load(): Promise<TTarget[]>;
     getItems(): TTarget[];
     attach(target: TTarget | number | string): void;
@@ -487,10 +498,15 @@ interface ManyToManyCollection<TTarget> {
     syncByIds(ids: (number | string)[]): Promise<void>;
 }
 type EntityInstance<TTable extends TableDef, TRow = InferRow<TTable>> = TRow & {
-    [K in keyof RelationMap<TTable>]: TTable['relations'][K] extends HasManyRelation<infer TTarget> ? HasManyCollection<EntityInstance<TTarget>> : TTable['relations'][K] extends HasOneRelation<infer TTarget> ? HasOneReference<EntityInstance<TTarget>> : TTable['relations'][K] extends BelongsToManyRelation<infer TTarget> ? ManyToManyCollection<EntityInstance<TTarget>> : TTable['relations'][K] extends BelongsToRelation<infer TTarget> ? BelongsToReference<EntityInstance<TTarget>> : never;
+    [K in keyof RelationMap<TTable>]: RelationWrapper$1<TTable['relations'][K]>;
 } & {
     $load<K extends keyof RelationMap<TTable>>(relation: K): Promise<RelationMap<TTable>[K]>;
 };
+type Primitive = string | number | boolean | Date | bigint | Buffer | null | undefined;
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+type SelectableKeys<T> = {
+    [K in keyof T]-?: IsAny<T[K]> extends true ? never : NonNullable<T[K]> extends Primitive ? K : never;
+}[keyof T];
 
 /**
  * SQL operators used in query conditions
@@ -533,6 +549,25 @@ declare const SQL_OPERATORS: {
     /** NOT EXISTS operator */
     readonly NOT_EXISTS: "NOT EXISTS";
 };
+/**
+ * SQL bitwise operators
+ */
+declare const BITWISE_OPERATORS: {
+    /** Bitwise AND */
+    readonly AND: "&";
+    /** Bitwise OR */
+    readonly OR: "|";
+    /** Bitwise XOR */
+    readonly XOR: "^";
+    /** Bitwise Shift Left */
+    readonly SHIFT_LEFT: "<<";
+    /** Bitwise Shift Right */
+    readonly SHIFT_RIGHT: ">>";
+};
+/**
+ * Type representing supported bitwise operators
+ */
+type BitwiseOperator = (typeof BITWISE_OPERATORS)[keyof typeof BITWISE_OPERATORS];
 /**
  * Type representing any supported SQL operator
  */
@@ -705,6 +740,16 @@ interface CastExpressionNode {
     /** Optional alias for the result */
     alias?: string;
 }
+/**
+ * AST node representing a COLLATE expression (expression COLLATE collationName).
+ */
+interface CollateExpressionNode {
+    type: 'Collate';
+    /** Expression to be collated */
+    expression: OperandNode;
+    /** Collation name */
+    collation: string;
+}
 /**
  * AST node representing a window function
  */
@@ -733,11 +778,12 @@ interface ArithmeticExpressionNode {
 /**
  * Union type representing any operand that can be used in expressions
  */
-type OperandNode = AliasRefNode | ColumnNode | LiteralNode | FunctionNode | JsonPathNode | ScalarSubqueryNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode | ArithmeticExpressionNode;
+type OperandNode = AliasRefNode | ColumnNode | LiteralNode | FunctionNode | JsonPathNode | ScalarSubqueryNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode | ArithmeticExpressionNode | BitwiseExpressionNode | CollateExpressionNode;
 declare const isOperandNode: (node: unknown) => node is OperandNode;
 declare const isFunctionNode: (node: unknown) => node is FunctionNode;
 declare const isCaseExpressionNode: (node: unknown) => node is CaseExpressionNode;
 declare const isCastExpressionNode: (node: unknown) => node is CastExpressionNode;
+declare const isCollateExpressionNode: (node: unknown) => node is CollateExpressionNode;
 declare const isWindowFunctionNode: (node: unknown) => node is WindowFunctionNode;
 declare const isExpressionSelectionNode: (node: ColumnRef | FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode) => node is FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode;
 /**
@@ -754,6 +800,18 @@ interface BinaryExpressionNode {
     /** Optional escape character for LIKE expressions */
     escape?: LiteralNode;
 }
+/**
+ * AST node representing a bitwise expression (e.g., a & b)
+ */
+interface BitwiseExpressionNode {
+    type: 'BitwiseExpression';
+    /** Left operand */
+    left: OperandNode;
+    /** Bitwise operator */
+    operator: BitwiseOperator;
+    /** Right operand */
+    right: OperandNode;
+}
 /**
  * AST node representing a logical expression (AND/OR)
  */
@@ -813,7 +871,7 @@ interface BetweenExpressionNode {
 /**
  * Union type representing any supported expression node
  */
-type ExpressionNode = BinaryExpressionNode | LogicalExpressionNode | NullExpressionNode | InExpressionNode | ExistsExpressionNode | BetweenExpressionNode | ArithmeticExpressionNode;
+type ExpressionNode = BinaryExpressionNode | LogicalExpressionNode | NullExpressionNode | InExpressionNode | ExistsExpressionNode | BetweenExpressionNode | ArithmeticExpressionNode | BitwiseExpressionNode;
 
 type LiteralValue = LiteralNode['value'];
 type ValueOperandInput = OperandNode | LiteralValue;
@@ -956,6 +1014,26 @@ declare const add: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRe
 declare const sub: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number) => ArithmeticExpressionNode;
 declare const mul: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number) => ArithmeticExpressionNode;
 declare const div: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number) => ArithmeticExpressionNode;
+/**
+ * Creates a bitwise AND expression (left & right)
+ */
+declare const bitAnd: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number) => BitwiseExpressionNode;
+/**
+ * Creates a bitwise OR expression (left | right)
+ */
+declare const bitOr: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number) => BitwiseExpressionNode;
+/**
+ * Creates a bitwise XOR expression (left ^ right)
+ */
+declare const bitXor: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number) => BitwiseExpressionNode;
+/**
+ * Creates a bitwise shift left expression (left << right)
+ */
+declare const shiftLeft: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number) => BitwiseExpressionNode;
+/**
+ * Creates a bitwise shift right expression (left >> right)
+ */
+declare const shiftRight: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | string | number) => BitwiseExpressionNode;
 /**
  * Creates a JSON path expression
  * @param col - Source column
@@ -989,6 +1067,13 @@ declare const exists: (subquery: SelectQueryNode) => ExistsExpressionNode;
  * @returns NOT EXISTS expression node
  */
 declare const notExists: (subquery: SelectQueryNode) => ExistsExpressionNode;
+/**
+ * Creates a COLLATE expression (expression COLLATE collationName)
+ * @param expression - Expression to be collated
+ * @param collation - Collation name
+ * @returns COLLATE expression node
+ */
+declare const collate: (expression: OperandNode | ColumnRef | string | number | boolean | null, collation: string) => CollateExpressionNode;
 
 /**
  * Creates a ROW_NUMBER window function
@@ -1099,6 +1184,18 @@ type GroupConcatOptions = {
  * Aggregates grouped strings into a single value.
  */
 declare const groupConcat: (col: ColumnRef | ColumnNode, options?: GroupConcatOptions) => FunctionNode;
+/**
+ * Creates a STDDEV function expression
+ * @param col - Column to calculate standard deviation for
+ * @returns Function node with STDDEV
+ */
+declare const stddev: (col: ColumnRef | ColumnNode) => FunctionNode;
+/**
+ * Creates a VARIANCE function expression
+ * @param col - Column to calculate variance for
+ * @returns Function node with VARIANCE
+ */
+declare const variance: (col: ColumnRef | ColumnNode) => FunctionNode;
 
 /**
  * Visitor for expression nodes
@@ -1111,6 +1208,7 @@ interface ExpressionVisitor<R> {
     visitExistsExpression?(node: ExistsExpressionNode): R;
     visitBetweenExpression?(node: BetweenExpressionNode): R;
     visitArithmeticExpression?(node: ArithmeticExpressionNode): R;
+    visitBitwiseExpression?(node: BitwiseExpressionNode): R;
     otherwise?(node: ExpressionNode): R;
 }
 /**
@@ -1125,6 +1223,7 @@ interface OperandVisitor<R> {
     visitCaseExpression?(node: CaseExpressionNode): R;
     visitCast?(node: CastExpressionNode): R;
     visitWindowFunction?(node: WindowFunctionNode): R;
+    visitCollate?(node: CollateExpressionNode): R;
     visitAliasRef?(node: AliasRefNode): R;
     otherwise?(node: OperandNode): R;
 }
@@ -1199,6 +1298,7 @@ interface TableNode {
  */
 interface FunctionTableNode {
     type: 'FunctionTable';
+    key?: string;
     /** Function name */
     name: string;
     /** Optional schema for the function (some dialects) */
@@ -1445,6 +1545,17 @@ interface FunctionStrategy {
     getRenderer(functionName: string): FunctionRenderer | undefined;
 }
 
+interface TableFunctionRenderContext {
+    node: FunctionTableNode;
+    compiledArgs: string[];
+    compileOperand: (operand: OperandNode) => string;
+    quoteIdentifier: (id: string) => string;
+}
+type TableFunctionRenderer = (ctx: TableFunctionRenderContext) => string;
+interface TableFunctionStrategy {
+    getRenderer(key: string): TableFunctionRenderer | undefined;
+}
+
 /**
  * Context for SQL compilation with parameter management
  */
@@ -1564,13 +1675,14 @@ declare abstract class Dialect implements SelectCompiler, InsertCompiler, Update
     private readonly expressionCompilers;
     private readonly operandCompilers;
     protected readonly functionStrategy: FunctionStrategy;
-    protected constructor(functionStrategy?: FunctionStrategy);
+    protected readonly tableFunctionStrategy: TableFunctionStrategy;
+    protected constructor(functionStrategy?: FunctionStrategy, tableFunctionStrategy?: TableFunctionStrategy);
     /**
      * Creates a new Dialect instance (for testing purposes)
      * @param functionStrategy - Optional function strategy
      * @returns New Dialect instance
      */
-    static create(functionStrategy?: FunctionStrategy): Dialect;
+    static create(functionStrategy?: FunctionStrategy, tableFunctionStrategy?: TableFunctionStrategy): Dialect;
     /**
      * Registers an expression compiler for a specific node type
      * @param type - Expression node type
@@ -2040,7 +2152,7 @@ type RelationIncludeJoinKind = typeof JOIN_KINDS.LEFT | typeof JOIN_KINDS.INNER;
  * Options for including a relation in a query
  */
 interface RelationIncludeOptions {
-    columns?: string[];
+    columns?: readonly string[];
     aliasPrefix?: string;
     filter?: ExpressionNode;
     joinKind?: RelationIncludeJoinKind;
@@ -2073,7 +2185,7 @@ declare class RelationService {
      * @param extraCondition - Additional join condition
      * @returns Relation result with updated state and hydration
      */
-    joinRelation(relationName: string, joinKind: JoinKind, extraCondition?: ExpressionNode): RelationResult;
+    joinRelation(relationName: string, joinKind: JoinKind, extraCondition?: ExpressionNode, tableSource?: TableSourceNode): RelationResult;
     /**
      * Matches records based on a relation with an optional predicate
      * @param relationName - Name of the relation to match
@@ -2112,6 +2224,17 @@ declare class RelationService {
      * @returns Relation result with updated state and hydration
      */
     private selectColumns;
+    private combineWithAnd;
+    private splitFilterExpressions;
+    private flattenAnd;
+    private isExpressionSelfContained;
+    private collectReferencedTables;
+    private collectFromExpression;
+    private collectFromOperand;
+    private collectFromOrderingTerm;
+    private createFilteredRelationCte;
+    private generateUniqueCteName;
+    private resolveTargetTableName;
     /**
      * Gets a relation definition by name
      * @param relationName - Name of the relation
@@ -2546,6 +2669,10 @@ interface QueryContext {
     params: unknown[];
 }
 type QueryInterceptor = (ctx: QueryContext, next: () => Promise<QueryResult[]>) => Promise<QueryResult[]>;
+/**
+ * Pipeline for query interceptors.
+ * Interceptors can wrap query execution to add logging, tracing, caching, etc.
+ */
 declare class InterceptorPipeline {
     private interceptors;
     use(interceptor: QueryInterceptor): void;
@@ -2621,12 +2748,31 @@ declare class Orm<E extends DomainEvent = OrmDomainEvent> {
     dispose(): Promise<void>;
 }
 
+/**
+ * Simple identity map for tracking entities within a session.
+ * Ensures that the same database record is represented by a single entity instance.
+ */
 declare class IdentityMap {
     private readonly buckets;
     get bucketsMap(): Map<string, Map<string, TrackedEntity>>;
+    /**
+     * Retrieves an entity from the identity map if it exists.
+     * @param table The table definition of the entity.
+     * @param pk The primary key value.
+     * @returns The entity instance if found, undefined otherwise.
+     */
     getEntity(table: TableDef, pk: string | number): unknown | undefined;
+    /**
+     * Registers a tracked entity in the identity map.
+     * @param tracked The tracked entity metadata and instance.
+     */
     register(tracked: TrackedEntity): void;
     remove(tracked: TrackedEntity): void;
+    /**
+     * Returns all tracked entities for a specific table.
+     * @param table The table definition.
+     * @returns Array of tracked entities.
+     */
     getEntitiesForTable(table: TableDef): TrackedEntity[];
     clear(): void;
     private toIdentityKey;
@@ -3054,11 +3200,21 @@ interface EntityContext {
     registerRelationChange(root: unknown, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<unknown>): void;
 }
 
+/**
+ * Context used during the hydration of entities from database results.
+ * It carries necessary services and processors to handle identity management,
+ * unit of work registration, and relation changes.
+ */
 interface HydrationContext<E extends DomainEvent = AnyDomainEvent> {
+    /** The identity map used to track and reuse entity instances. */
     identityMap: IdentityMap;
+    /** The unit of work used to track changes in hydrated entities. */
     unitOfWork: UnitOfWork;
+    /** The bus used to dispatch domain events during or after hydration. */
     domainEvents: DomainEventBus<E, OrmSession<E>>;
+    /** Processor for handling changes in entity relations during hydration. */
     relationChanges: RelationChangeProcessor;
+    /** Context providing access to entity-specific metadata and services. */
     entityContext: EntityContext;
 }
 
@@ -3078,14 +3234,14 @@ interface SaveGraphOptions {
 
 type AnyId = number | string;
 type AnyFn = (...args: unknown[]) => unknown;
-type RelationWrapper = HasManyCollection<unknown> | HasOneReference<unknown> | BelongsToReference<unknown> | ManyToManyCollection<unknown>;
+type RelationWrapper = HasManyCollection<unknown> | HasOneReference | BelongsToReference | ManyToManyCollection<unknown>;
 type FunctionKeys<T> = {
     [K in keyof T & string]-?: T[K] extends AnyFn ? K : never;
 }[keyof T & string];
-type RelationKeys<T> = {
+type RelationKeys$1<T> = {
     [K in keyof T & string]-?: NonNullable<T[K]> extends RelationWrapper ? K : never;
 }[keyof T & string];
-type ColumnKeys<T> = Exclude<keyof T & string, FunctionKeys<T> | RelationKeys<T>>;
+type ColumnKeys<T> = Exclude<keyof T & string, FunctionKeys<T> | RelationKeys$1<T>>;
 type SaveGraphJsonScalar<T> = T extends Date ? string : T;
 /**
  * Input scalar type for `OrmSession.saveGraph` payloads.
@@ -3098,7 +3254,7 @@ type ColumnInput$1<TEntity> = {
 };
 type RelationInputValue<T> = T extends HasManyCollection<infer C> ? Array<SaveGraphInputPayload<C> | AnyId> : T extends HasOneReference<infer C> ? SaveGraphInputPayload<C> | AnyId | null : T extends BelongsToReference<infer P> ? SaveGraphInputPayload<P> | AnyId | null : T extends ManyToManyCollection<infer Tgt> ? Array<SaveGraphInputPayload<Tgt> | AnyId> : never;
 type RelationInput<TEntity> = {
-    [K in RelationKeys<TEntity>]?: RelationInputValue<NonNullable<TEntity[K]>>;
+    [K in RelationKeys$1<TEntity>]?: RelationInputValue<NonNullable<TEntity[K]>>;
 };
 /**
  * Typed payload accepted by `OrmSession.saveGraph`:
@@ -3351,6 +3507,7 @@ declare class SelectQueryBuilder<T = unknown, TTable extends TableDef = TableDef
     private readonly columnSelector;
     private readonly relationManager;
     private readonly lazyRelations;
+    private readonly lazyRelationOptions;
     /**
      * Creates a new SelectQueryBuilder instance
      * @param table - Table definition to query
@@ -3358,7 +3515,7 @@ declare class SelectQueryBuilder<T = unknown, TTable extends TableDef = TableDef
      * @param hydration - Optional hydration manager
      * @param dependencies - Optional query builder dependencies
      */
-    constructor(table: TTable, state?: SelectQueryState, hydration?: HydrationManager, dependencies?: Partial<SelectQueryBuilderDependencies>, lazyRelations?: Set<string>);
+    constructor(table: TTable, state?: SelectQueryState, hydration?: HydrationManager, dependencies?: Partial<SelectQueryBuilderDependencies>, lazyRelations?: Set<string>, lazyRelationOptions?: Map<string, RelationIncludeOptions>);
     /**
      * Creates a new SelectQueryBuilder instance with updated context and lazy relations
      * @param context - Updated query context
@@ -3536,15 +3693,12 @@ declare class SelectQueryBuilder<T = unknown, TTable extends TableDef = TableDef
     /**
      * Includes a relation lazily in the query results
      * @param relationName - Name of the relation to include lazily
+     * @param options - Optional include options for lazy loading
      * @returns New query builder instance with lazy relation inclusion
      */
-    includeLazy<K extends keyof RelationMap<TTable>>(relationName: K): SelectQueryBuilder<T, TTable>;
-    /**
-     * Selects columns for a related table in a single hop.
-     */
-    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>;
+    includeLazy<K extends keyof RelationMap<TTable>>(relationName: K, options?: RelationIncludeOptions): SelectQueryBuilder<T, TTable>;
     /**
-     * Convenience alias for selecting specific columns from a relation.
+     * Convenience alias for including only 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>;
     /**
@@ -3558,6 +3712,11 @@ declare class SelectQueryBuilder<T = unknown, TTable extends TableDef = TableDef
      * @returns Array of lazy relation names
      */
     getLazyRelations(): (keyof RelationMap<TTable>)[];
+    /**
+     * Gets lazy relation include options
+     * @returns Map of relation names to include options
+     */
+    getLazyRelationOptions(): Map<string, RelationIncludeOptions>;
     /**
      * Gets the table definition for this query builder
      * @returns Table definition
@@ -4136,6 +4295,11 @@ interface ReturningStrategy {
     formatReturningColumns(returning: ColumnNode[], quoteIdentifier: (id: string) => string): string;
 }
 
+/**
+ * Base class for SQL dialects.
+ * Provides a common framework for compiling AST nodes into SQL strings.
+ * Specific dialects should extend this class and implement dialect-specific logic.
+ */
 declare abstract class SqlDialectBase extends Dialect {
     abstract quoteIdentifier(id: string): string;
     protected paginationStrategy: PaginationStrategy;
@@ -4505,75 +4669,75 @@ declare const registerSchemaIntrospector: (dialect: DialectName, introspector: S
  */
 declare const getSchemaIntrospector: (dialect: DialectName) => SchemaIntrospector | undefined;
 
-type OperandInput$2 = OperandNode | ColumnDef | string | number | boolean | null;
+type OperandInput$5 = OperandNode | ColumnDef | string | number | boolean | null;
 /**
  * Converts a string to lowercase.
  * @param value - The string value.
  * @returns A FunctionNode representing the LOWER SQL function.
  */
-declare const lower: (value: OperandInput$2) => FunctionNode;
+declare const lower: (value: OperandInput$5) => FunctionNode;
 /**
  * Converts a string to uppercase.
  * @param value - The string value.
  * @returns A FunctionNode representing the UPPER SQL function.
  */
-declare const upper: (value: OperandInput$2) => FunctionNode;
+declare const upper: (value: OperandInput$5) => FunctionNode;
 /**
  * Returns the ASCII code of the first character of a string.
  * @param value - The string value.
  * @returns A FunctionNode representing the ASCII SQL function.
  */
-declare const ascii: (value: OperandInput$2) => FunctionNode;
+declare const ascii: (value: OperandInput$5) => FunctionNode;
 /**
  * Returns a string from one or more ASCII codes.
  * @param codes - The ASCII codes.
  * @returns A FunctionNode representing the CHAR SQL function.
  */
-declare const char: (...codes: OperandInput$2[]) => FunctionNode;
+declare const char: (...codes: OperandInput$5[]) => FunctionNode;
 /**
  * Returns the number of characters in a string.
  * @param value - The string value.
  * @returns A FunctionNode representing the CHAR_LENGTH SQL function.
  */
-declare const charLength: (value: OperandInput$2) => FunctionNode;
+declare const charLength: (value: OperandInput$5) => FunctionNode;
 /**
  * Returns the length of a string in bytes or characters.
  * @param value - The string value.
  * @returns A FunctionNode representing the LENGTH SQL function.
  */
-declare const length: (value: OperandInput$2) => FunctionNode;
+declare const length: (value: OperandInput$5) => FunctionNode;
 /**
  * Removes leading and trailing whitespace or specified characters from a string.
  * @param value - The string value.
  * @param chars - The characters to trim (optional).
  * @returns A FunctionNode representing the TRIM SQL function.
  */
-declare const trim: (value: OperandInput$2, chars?: OperandInput$2) => FunctionNode;
+declare const trim: (value: OperandInput$5, chars?: OperandInput$5) => FunctionNode;
 /**
  * Removes leading whitespace from a string.
  * @param value - The string value.
  * @returns A FunctionNode representing the LTRIM SQL function.
  */
-declare const ltrim: (value: OperandInput$2) => FunctionNode;
+declare const ltrim: (value: OperandInput$5) => FunctionNode;
 /**
  * Removes trailing whitespace from a string.
  * @param value - The string value.
  * @returns A FunctionNode representing the RTRIM SQL function.
  */
-declare const rtrim: (value: OperandInput$2) => FunctionNode;
+declare const rtrim: (value: OperandInput$5) => FunctionNode;
 /**
  * Concatenates two or more strings.
  * @param args - The strings to concatenate.
  * @returns A FunctionNode representing the CONCAT SQL function.
  */
-declare const concat: (...args: OperandInput$2[]) => FunctionNode;
+declare const concat: (...args: OperandInput$5[]) => FunctionNode;
 /**
  * Concatenates strings with a separator.
  * @param separator - The separator string.
  * @param args - The strings to concatenate.
  * @returns A FunctionNode representing the CONCAT_WS SQL function.
  */
-declare const concatWs: (separator: OperandInput$2, ...args: OperandInput$2[]) => FunctionNode;
+declare const concatWs: (separator: OperandInput$5, ...args: OperandInput$5[]) => FunctionNode;
 /**
  * Extracts a substring from a string.
  * @param value - The string value.
@@ -4581,35 +4745,35 @@ declare const concatWs: (separator: OperandInput$2, ...args: OperandInput$2[]) =
  * @param length - The length of the substring (optional).
  * @returns A FunctionNode representing the SUBSTR SQL function.
  */
-declare const substr: (value: OperandInput$2, start: OperandInput$2, length?: OperandInput$2) => FunctionNode;
+declare const substr: (value: OperandInput$5, start: OperandInput$5, length?: OperandInput$5) => FunctionNode;
 /**
  * Returns the leftmost characters of a string.
  * @param value - The string value.
  * @param len - The number of characters to return.
  * @returns A FunctionNode representing the LEFT SQL function.
  */
-declare const left: (value: OperandInput$2, len: OperandInput$2) => FunctionNode;
+declare const left: (value: OperandInput$5, len: OperandInput$5) => FunctionNode;
 /**
  * Returns the rightmost characters of a string.
  * @param value - The string value.
  * @param len - The number of characters to return.
  * @returns A FunctionNode representing the RIGHT SQL function.
  */
-declare const right: (value: OperandInput$2, len: OperandInput$2) => FunctionNode;
+declare const right: (value: OperandInput$5, len: OperandInput$5) => FunctionNode;
 /**
  * Returns the position of a substring in a string.
  * @param substring - The substring to search for.
  * @param value - The string to search in.
  * @returns A FunctionNode representing the POSITION SQL function.
  */
-declare const position: (substring: OperandInput$2, value: OperandInput$2) => FunctionNode;
+declare const position: (substring: OperandInput$5, value: OperandInput$5) => FunctionNode;
 /**
  * Returns the position of a substring in a string.
  * @param value - The string to search in.
  * @param substring - The substring to search for.
  * @returns A FunctionNode representing the INSTR SQL function.
  */
-declare const instr: (value: OperandInput$2, substring: OperandInput$2) => FunctionNode;
+declare const instr: (value: OperandInput$5, substring: OperandInput$5) => FunctionNode;
 /**
  * Returns the position of a substring in a string, optionally starting from a position.
  * @param substring - The substring to search for.
@@ -4617,7 +4781,7 @@ declare const instr: (value: OperandInput$2, substring: OperandInput$2) => Funct
  * @param start - The starting position (optional).
  * @returns A FunctionNode representing the LOCATE SQL function.
  */
-declare const locate: (substring: OperandInput$2, value: OperandInput$2, start?: OperandInput$2) => FunctionNode;
+declare const locate: (substring: OperandInput$5, value: OperandInput$5, start?: OperandInput$5) => FunctionNode;
 /**
  * Replaces occurrences of a substring in a string.
  * @param value - The string to search in.
@@ -4625,14 +4789,14 @@ declare const locate: (substring: OperandInput$2, value: OperandInput$2, start?:
  * @param replacement - The replacement string.
  * @returns A FunctionNode representing the REPLACE SQL function.
  */
-declare const replace: (value: OperandInput$2, search: OperandInput$2, replacement: OperandInput$2) => FunctionNode;
+declare const replace: (value: OperandInput$5, search: OperandInput$5, replacement: OperandInput$5) => FunctionNode;
 /**
  * Repeats a string a specified number of times.
  * @param value - The string to repeat.
  * @param count - The number of times to repeat.
  * @returns A FunctionNode representing the REPEAT SQL function.
  */
-declare const repeat: (value: OperandInput$2, count: OperandInput$2) => FunctionNode;
+declare const repeat: (value: OperandInput$5, count: OperandInput$5) => FunctionNode;
 /**
  * Left-pads a string to a certain length with another string.
  * @param value - The string to pad.
@@ -4640,7 +4804,7 @@ declare const repeat: (value: OperandInput$2, count: OperandInput$2) => Function
  * @param pad - The padding string.
  * @returns A FunctionNode representing the LPAD SQL function.
  */
-declare const lpad: (value: OperandInput$2, len: OperandInput$2, pad: OperandInput$2) => FunctionNode;
+declare const lpad: (value: OperandInput$5, len: OperandInput$5, pad: OperandInput$5) => FunctionNode;
 /**
  * Right-pads a string to a certain length with another string.
  * @param value - The string to pad.
@@ -4648,120 +4812,169 @@ declare const lpad: (value: OperandInput$2, len: OperandInput$2, pad: OperandInp
  * @param pad - The padding string.
  * @returns A FunctionNode representing the RPAD SQL function.
  */
-declare const rpad: (value: OperandInput$2, len: OperandInput$2, pad: OperandInput$2) => FunctionNode;
+declare const rpad: (value: OperandInput$5, len: OperandInput$5, pad: OperandInput$5) => FunctionNode;
 /**
  * Returns a string consisting of a specified number of spaces.
  * @param count - The number of spaces.
  * @returns A FunctionNode representing the SPACE SQL function.
  */
-declare const space: (count: OperandInput$2) => FunctionNode;
+declare const space: (count: OperandInput$5) => FunctionNode;
+/**
+ * Reverses a string.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the REVERSE SQL function.
+ */
+declare const reverse: (value: OperandInput$5) => FunctionNode;
+/**
+ * Capitalizes the first letter of each word in a string.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the INITCAP SQL function.
+ */
+declare const initcap: (value: OperandInput$5) => FunctionNode;
+/**
+ * Returns the MD5 hash of a string.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the MD5 SQL function.
+ */
+declare const md5: (value: OperandInput$5) => FunctionNode;
+/**
+ * Returns the SHA-1 hash of a string.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the SHA1 SQL function.
+ */
+declare const sha1: (value: OperandInput$5) => FunctionNode;
+/**
+ * Returns the SHA-2 hash of a string with a specified bit length.
+ * @param value - The string value.
+ * @param bits - The bit length (e.g., 224, 256, 384, 512).
+ * @returns A FunctionNode representing the SHA2 SQL function.
+ */
+declare const sha2: (value: OperandInput$5, bits: OperandInput$5) => FunctionNode;
+/**
+ * Returns the length of a string in bits.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the BIT_LENGTH SQL function.
+ */
+declare const bitLength: (value: OperandInput$5) => FunctionNode;
+/**
+ * Returns the length of a string in bytes.
+ * @param value - The string value.
+ * @returns A FunctionNode representing the OCTET_LENGTH SQL function.
+ */
+declare const octetLength: (value: OperandInput$5) => FunctionNode;
+/**
+ * Returns a string from an ASCII code.
+ * @param code - The ASCII code.
+ * @returns A FunctionNode representing the CHR/CHAR SQL function.
+ */
+declare const chr: (code: OperandInput$5) => FunctionNode;
 
-type OperandInput$1 = OperandNode | ColumnDef | string | number | boolean | null;
+type OperandInput$4 = OperandNode | ColumnDef | string | number | boolean | null;
 /**
  * Returns the absolute value of a number.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the ABS SQL function.
  */
-declare const abs: (value: OperandInput$1) => FunctionNode;
+declare const abs: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the arccosine (inverse cosine) of a number.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the ACOS SQL function.
  */
-declare const acos: (value: OperandInput$1) => FunctionNode;
+declare const acos: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the arcsine (inverse sine) of a number.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the ASIN SQL function.
  */
-declare const asin: (value: OperandInput$1) => FunctionNode;
+declare const asin: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the arctangent (inverse tangent) of a number.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the ATAN SQL function.
  */
-declare const atan: (value: OperandInput$1) => FunctionNode;
+declare const atan: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the arctangent of the two arguments.
  * @param y - The y-coordinate.
  * @param x - The x-coordinate.
  * @returns A FunctionNode representing the ATAN2 SQL function.
  */
-declare const atan2: (y: OperandInput$1, x: OperandInput$1) => FunctionNode;
+declare const atan2: (y: OperandInput$4, x: OperandInput$4) => FunctionNode;
 /**
  * Returns the smallest integer greater than or equal to a number.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the CEIL SQL function.
  */
-declare const ceil: (value: OperandInput$1) => FunctionNode;
+declare const ceil: (value: OperandInput$4) => FunctionNode;
 /**
  * Alias for ceil. Returns the smallest integer greater than or equal to a number.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the CEILING SQL function.
  */
-declare const ceiling: (value: OperandInput$1) => FunctionNode;
+declare const ceiling: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the cosine of a number (in radians).
  * @param value - The numeric value in radians.
  * @returns A FunctionNode representing the COS SQL function.
  */
-declare const cos: (value: OperandInput$1) => FunctionNode;
+declare const cos: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the cotangent of a number.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the COT SQL function.
  */
-declare const cot: (value: OperandInput$1) => FunctionNode;
+declare const cot: (value: OperandInput$4) => FunctionNode;
 /**
  * Converts radians to degrees.
  * @param value - The angle in radians.
  * @returns A FunctionNode representing the DEGREES SQL function.
  */
-declare const degrees: (value: OperandInput$1) => FunctionNode;
+declare const degrees: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns e raised to the power of the argument.
  * @param value - The exponent.
  * @returns A FunctionNode representing the EXP SQL function.
  */
-declare const exp: (value: OperandInput$1) => FunctionNode;
+declare const exp: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the largest integer less than or equal to a number.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the FLOOR SQL function.
  */
-declare const floor: (value: OperandInput$1) => FunctionNode;
+declare const floor: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the natural logarithm (base e) of a number.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the LN SQL function.
  */
-declare const ln: (value: OperandInput$1) => FunctionNode;
+declare const ln: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the base-10 logarithm of a number.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the LOG SQL function.
  */
-declare const log: (value: OperandInput$1) => FunctionNode;
+declare const log: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the base-10 logarithm of a number.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the LOG10 SQL function.
  */
-declare const log10: (value: OperandInput$1) => FunctionNode;
+declare const log10: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the logarithm of a number for a specific base.
  * @param base - The base of the logarithm.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the LOG_BASE SQL function.
  */
-declare const logBase: (base: OperandInput$1, value: OperandInput$1) => FunctionNode;
+declare const logBase: (base: OperandInput$4, value: OperandInput$4) => FunctionNode;
 /**
  * Returns the remainder of dividing x by y.
  * @param x - The dividend.
  * @param y - The divisor.
  * @returns A FunctionNode representing the MOD SQL function.
  */
-declare const mod: (x: OperandInput$1, y: OperandInput$1) => FunctionNode;
+declare const mod: (x: OperandInput$4, y: OperandInput$4) => FunctionNode;
 /**
  * Returns the value of PI (approximately 3.14159...).
  * @returns A FunctionNode representing the PI SQL function.
@@ -4773,20 +4986,20 @@ declare const pi: () => FunctionNode;
  * @param y - The exponent.
  * @returns A FunctionNode representing the POWER SQL function.
  */
-declare const power: (x: OperandInput$1, y: OperandInput$1) => FunctionNode;
+declare const power: (x: OperandInput$4, y: OperandInput$4) => FunctionNode;
 /**
  * Alias for power. Returns x raised to the power of y.
  * @param x - The base.
  * @param y - The exponent.
  * @returns A FunctionNode representing the POW SQL function.
  */
-declare const pow: (x: OperandInput$1, y: OperandInput$1) => FunctionNode;
+declare const pow: (x: OperandInput$4, y: OperandInput$4) => FunctionNode;
 /**
  * Converts degrees to radians.
  * @param value - The angle in degrees.
  * @returns A FunctionNode representing the RADIANS SQL function.
  */
-declare const radians: (value: OperandInput$1) => FunctionNode;
+declare const radians: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns a random number between 0 and 1.
  * @returns A FunctionNode representing the RANDOM SQL function.
@@ -4803,47 +5016,59 @@ declare const rand: () => FunctionNode;
  * @param decimals - The number of decimal places (optional).
  * @returns A FunctionNode representing the ROUND SQL function.
  */
-declare const round: (value: OperandInput$1, decimals?: OperandInput$1) => FunctionNode;
+declare const round: (value: OperandInput$4, decimals?: OperandInput$4) => FunctionNode;
 /**
  * Returns the sign of a number (-1 for negative, 0 for zero, 1 for positive).
  * @param value - The numeric value.
  * @returns A FunctionNode representing the SIGN SQL function.
  */
-declare const sign: (value: OperandInput$1) => FunctionNode;
+declare const sign: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the sine of a number (in radians).
  * @param value - The numeric value in radians.
  * @returns A FunctionNode representing the SIN SQL function.
  */
-declare const sin: (value: OperandInput$1) => FunctionNode;
+declare const sin: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the square root of a number.
  * @param value - The numeric value.
  * @returns A FunctionNode representing the SQRT SQL function.
  */
-declare const sqrt: (value: OperandInput$1) => FunctionNode;
+declare const sqrt: (value: OperandInput$4) => FunctionNode;
 /**
  * Returns the tangent of a number (in radians).
  * @param value - The numeric value in radians.
  * @returns A FunctionNode representing the TAN SQL function.
  */
-declare const tan: (value: OperandInput$1) => FunctionNode;
+declare const tan: (value: OperandInput$4) => FunctionNode;
 /**
  * Truncates a number to a specified number of decimal places without rounding.
  * @param value - The numeric value to truncate.
  * @param decimals - The number of decimal places (optional).
  * @returns A FunctionNode representing the TRUNC SQL function.
  */
-declare const trunc: (value: OperandInput$1, decimals?: OperandInput$1) => FunctionNode;
+declare const trunc: (value: OperandInput$4, decimals?: OperandInput$4) => FunctionNode;
 /**
  * Alias for trunc. Truncates a number to a specified number of decimal places without rounding.
  * @param value - The numeric value to truncate.
  * @param decimals - The number of decimal places.
  * @returns A FunctionNode representing the TRUNCATE SQL function.
  */
-declare const truncate: (value: OperandInput$1, decimals: OperandInput$1) => FunctionNode;
+declare const truncate: (value: OperandInput$4, decimals: OperandInput$4) => FunctionNode;
+/**
+ * Returns the base-2 logarithm of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the LOG2 SQL function.
+ */
+declare const log2: (value: OperandInput$4) => FunctionNode;
+/**
+ * Returns the cube root of a number.
+ * @param value - The numeric value.
+ * @returns A FunctionNode representing the CBRT SQL function.
+ */
+declare const cbrt: (value: OperandInput$4) => FunctionNode;
 
-type OperandInput = OperandNode | ColumnDef | string | number | boolean | null;
+type OperandInput$3 = OperandNode | ColumnDef | string | number | boolean | null;
 /**
  * Returns the current local date and time.
  * @returns A FunctionNode representing the NOW() SQL function.
@@ -4864,31 +5089,41 @@ declare const currentTime: () => FunctionNode;
  * @returns A FunctionNode representing the UTC_NOW() SQL function.
  */
 declare const utcNow: () => FunctionNode;
+/**
+ * Returns the current local time.
+ * @returns A FunctionNode representing the LOCALTIME SQL function.
+ */
+declare const localTime: () => FunctionNode;
+/**
+ * Returns the current local timestamp.
+ * @returns A FunctionNode representing the LOCALTIMESTAMP SQL function.
+ */
+declare const localTimestamp: () => FunctionNode;
 /**
  * Extracts a specified part from a date or datetime value.
  * @param part - The date part to extract (e.g., 'YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'SECOND').
  * @param date - The date or datetime value to extract from.
  * @returns A FunctionNode representing the EXTRACT SQL function.
  */
-declare const extract: (part: OperandInput, date: OperandInput) => FunctionNode;
+declare const extract: (part: OperandInput$3, date: OperandInput$3) => FunctionNode;
 /**
  * Extracts the year from a date or datetime value.
  * @param date - The date or datetime value.
  * @returns A FunctionNode representing the YEAR SQL function.
  */
-declare const year: (date: OperandInput) => FunctionNode;
+declare const year: (date: OperandInput$3) => FunctionNode;
 /**
  * Extracts the month from a date or datetime value.
  * @param date - The date or datetime value.
  * @returns A FunctionNode representing the MONTH SQL function.
  */
-declare const month: (date: OperandInput) => FunctionNode;
+declare const month: (date: OperandInput$3) => FunctionNode;
 /**
  * Extracts the day of the month from a date or datetime value.
  * @param date - The date or datetime value.
  * @returns A FunctionNode representing the DAY SQL function.
  */
-declare const day: (date: OperandInput) => FunctionNode;
+declare const day: (date: OperandInput$3) => FunctionNode;
 /**
  * Adds a specified time interval to a date or datetime value.
  * @param date - The date or datetime value to add to.
@@ -4896,7 +5131,7 @@ declare const day: (date: OperandInput) => FunctionNode;
  * @param unit - The unit type (e.g., 'DAY', 'MONTH', 'YEAR', 'HOUR', 'MINUTE', 'SECOND').
  * @returns A FunctionNode representing the DATE_ADD SQL function.
  */
-declare const dateAdd: (date: OperandInput, interval: OperandInput, unit: OperandInput) => FunctionNode;
+declare const dateAdd: (date: OperandInput$3, interval: OperandInput$3, unit: OperandInput$3) => FunctionNode;
 /**
  * Subtracts a specified time interval from a date or datetime value.
  * @param date - The date or datetime value to subtract from.
@@ -4904,21 +5139,21 @@ declare const dateAdd: (date: OperandInput, interval: OperandInput, unit: Operan
  * @param unit - The unit type (e.g., 'DAY', 'MONTH', 'YEAR', 'HOUR', 'MINUTE', 'SECOND').
  * @returns A FunctionNode representing the DATE_SUB SQL function.
  */
-declare const dateSub: (date: OperandInput, interval: OperandInput, unit: OperandInput) => FunctionNode;
+declare const dateSub: (date: OperandInput$3, interval: OperandInput$3, unit: OperandInput$3) => FunctionNode;
 /**
  * Returns the difference between two dates in days.
  * @param date1 - The end date.
  * @param date2 - The start date.
  * @returns A FunctionNode representing the DATE_DIFF SQL function.
  */
-declare const dateDiff: (date1: OperandInput, date2: OperandInput) => FunctionNode;
+declare const dateDiff: (date1: OperandInput$3, date2: OperandInput$3) => FunctionNode;
 /**
  * Converts a date or datetime value to a formatted string.
  * @param date - The date or datetime value to format.
  * @param format - The format string (dialect-specific).
  * @returns A FunctionNode representing the DATE_FORMAT SQL function.
  */
-declare const dateFormat: (date: OperandInput, format: OperandInput) => FunctionNode;
+declare const dateFormat: (date: OperandInput$3, format: OperandInput$3) => FunctionNode;
 /**
  * Returns the current Unix timestamp (seconds since 1970-01-01 00:00:00 UTC).
  * @returns A FunctionNode representing the UNIX_TIMESTAMP SQL function.
@@ -4929,32 +5164,106 @@ declare const unixTimestamp: () => FunctionNode;
  * @param timestamp - Unix timestamp in seconds.
  * @returns A FunctionNode representing the FROM_UNIXTIME SQL function.
  */
-declare const fromUnixTime: (timestamp: OperandInput) => FunctionNode;
+declare const fromUnixTime: (timestamp: OperandInput$3) => FunctionNode;
 /**
  * Returns the last day of the month for a given date.
  * @param date - The date value.
  * @returns A FunctionNode representing the END_OF_MONTH SQL function.
  */
-declare const endOfMonth: (date: OperandInput) => FunctionNode;
+declare const endOfMonth: (date: OperandInput$3) => FunctionNode;
 /**
  * Returns the index of the weekday for a given date (1 = Sunday, 2 = Monday, etc.).
  * @param date - The date value.
  * @returns A FunctionNode representing the DAY_OF_WEEK SQL function.
  */
-declare const dayOfWeek: (date: OperandInput) => FunctionNode;
+declare const dayOfWeek: (date: OperandInput$3) => FunctionNode;
 /**
  * Returns the week number of the year for a given date.
  * @param date - The date value.
  * @returns A FunctionNode representing the WEEK_OF_YEAR SQL function.
  */
-declare const weekOfYear: (date: OperandInput) => FunctionNode;
+declare const weekOfYear: (date: OperandInput$3) => FunctionNode;
 /**
  * Truncates a date or datetime value to a specified precision (e.g., first day of the month/year).
  * @param part - The truncation precision (e.g., 'YEAR', 'MONTH', 'DAY').
  * @param date - The date or datetime value to truncate.
  * @returns A FunctionNode representing the DATE_TRUNC SQL function.
  */
-declare const dateTrunc: (part: OperandInput, date: OperandInput) => FunctionNode;
+declare const dateTrunc: (part: OperandInput$3, date: OperandInput$3) => FunctionNode;
+/**
+ * Returns the difference between two timestamps as an interval.
+ * @param timestamp - The end timestamp.
+ * @param baseTimestamp - The start timestamp (optional, defaults to current time).
+ * @returns A FunctionNode representing the AGE SQL function.
+ */
+declare const age: (timestamp: OperandInput$3, baseTimestamp?: OperandInput$3) => FunctionNode;
+/**
+ * Extracts the hour from a date or datetime value.
+ * @param date - The date or datetime value.
+ * @returns A FunctionNode representing the HOUR SQL function.
+ */
+declare const hour: (date: OperandInput$3) => FunctionNode;
+/**
+ * Extracts the minute from a date or datetime value.
+ * @param date - The date or datetime value.
+ * @returns A FunctionNode representing the MINUTE SQL function.
+ */
+declare const minute: (date: OperandInput$3) => FunctionNode;
+/**
+ * Extracts the second from a date or datetime value.
+ * @param date - The date or datetime value.
+ * @returns A FunctionNode representing the SECOND SQL function.
+ */
+declare const second: (date: OperandInput$3) => FunctionNode;
+/**
+ * Extracts the quarter from a date or datetime value (1-4).
+ * @param date - The date or datetime value.
+ * @returns A FunctionNode representing the QUARTER SQL function.
+ */
+declare const quarter: (date: OperandInput$3) => FunctionNode;
+
+type OperandInput$2 = OperandNode | ColumnDef | string | number | boolean | null;
+/**
+ * Returns the first non-null value in a list.
+ * @param args - The list of values to check.
+ * @returns A FunctionNode representing the COALESCE SQL function.
+ */
+declare const coalesce: (...args: OperandInput$2[]) => FunctionNode;
+/**
+ * Returns null if the two arguments are equal, otherwise returns the first argument.
+ * @param val1 - The first value.
+ * @param val2 - The second value.
+ * @returns A FunctionNode representing the NULLIF SQL function.
+ */
+declare const nullif: (val1: OperandInput$2, val2: OperandInput$2) => FunctionNode;
+/**
+ * Returns the largest value in a list.
+ * @param args - The list of values to compare.
+ * @returns A FunctionNode representing the GREATEST SQL function.
+ */
+declare const greatest: (...args: OperandInput$2[]) => FunctionNode;
+/**
+ * Returns the smallest value in a list.
+ * @param args - The list of values to compare.
+ * @returns A FunctionNode representing the LEAST SQL function.
+ */
+declare const least: (...args: OperandInput$2[]) => FunctionNode;
+/**
+ * Returns the first argument if it is not null, otherwise returns the second argument.
+ * @param val - The value to check.
+ * @param defaultValue - The default value to return if val is null.
+ * @returns A FunctionNode representing the COALESCE SQL function.
+ */
+declare const ifNull: (val: OperandInput$2, defaultValue: OperandInput$2) => FunctionNode;
+
+type OperandInput$1 = OperandNode | ColumnDef | string | number | boolean | null;
+declare const jsonLength: (target: OperandInput$1, path?: OperandInput$1) => FunctionNode;
+declare const jsonSet: (target: OperandInput$1, path: OperandInput$1, value: OperandInput$1) => FunctionNode;
+declare const jsonArrayAgg: (value: OperandInput$1) => FunctionNode;
+declare const jsonContains: (target: OperandInput$1, candidate: OperandInput$1, path?: OperandInput$1) => FunctionNode;
+
+type OperandInput = OperandNode | ColumnDef | string | number | boolean | null;
+declare const arrayAppend: (array: OperandInput, value: OperandInput) => FunctionNode;
 
 /**
  * Browser-compatible implementation of AsyncLocalStorage.
@@ -5062,6 +5371,7 @@ declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandV
     visitCaseExpression(node: CaseExpressionNode): string;
     visitWindowFunction(node: WindowFunctionNode): string;
     visitCast(node: CastExpressionNode): string;
+    visitCollate(node: CollateExpressionNode): string;
     visitAliasRef(node: AliasRefNode): string;
     /**
      * Prints a binary expression to TypeScript code
@@ -5143,6 +5453,7 @@ declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandV
      */
     private printWindowFunctionOperand;
     private printCastOperand;
+    private printCollateOperand;
     /**
      * Converts method chain lines to inline format
      * @param lines - Method chain lines
@@ -5157,6 +5468,36 @@ declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandV
     private mapOp;
 }
 
+/**
+ * Metadata stored on entity instances for ORM internal use
+ * @typeParam TTable - Table definition type
+ */
+interface EntityMeta<TTable extends TableDef> {
+    /** Entity context */
+    ctx: EntityContext;
+    /** Table definition */
+    table: TTable;
+    /** Relations that should be loaded lazily */
+    lazyRelations: (keyof RelationMap<TTable>)[];
+    /** Include options for lazy relations */
+    lazyRelationOptions: Map<string, RelationIncludeOptions>;
+    /** Cache for relation promises */
+    relationCache: Map<string, Promise<unknown>>;
+    /** Hydration data for relations */
+    relationHydration: Map<string, Map<string, unknown>>;
+    /** Relation wrapper instances */
+    relationWrappers: Map<string, unknown>;
+}
+
+/**
+ * Caches relation loader results across entities of the same type.
+ * @template T - The cache type
+ * @param meta - The entity metadata
+ * @param relationName - The relation name
+ * @param factory - The factory function to create the cache
+ * @returns Promise with the cached relation data
+ */
+declare const relationLoaderCache: <T extends Map<string, unknown>>(meta: EntityMeta<TableDef>, relationName: string, factory: () => Promise<T>) => Promise<T>;
 /**
  * Creates an entity proxy with lazy loading capabilities.
  * @template TTable - The table type
@@ -5167,7 +5508,7 @@ declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandV
  * @param lazyRelations - Optional lazy relations
  * @returns The entity instance
  */
-declare const createEntityProxy: <TTable extends TableDef, TLazy extends keyof RelationMap<TTable> = keyof RelationMap<TTable>>(ctx: EntityContext, table: TTable, row: Record<string, unknown>, lazyRelations?: TLazy[]) => EntityInstance<TTable>;
+declare const createEntityProxy: <TTable extends TableDef, TLazy extends keyof RelationMap<TTable> = keyof RelationMap<TTable>>(ctx: EntityContext, table: TTable, row: Record<string, unknown>, lazyRelations?: TLazy[], lazyRelationOptions?: Map<string, RelationIncludeOptions>) => EntityInstance<TTable>;
 /**
  * Creates an entity instance from a database row.
  * @template TTable - The table type
@@ -5178,7 +5519,7 @@ declare const createEntityProxy: <TTable extends TableDef, TLazy extends keyof R
  * @param lazyRelations - Optional lazy relations
  * @returns The entity instance
  */
-declare const createEntityFromRow: <TTable extends TableDef, TResult extends EntityInstance<TTable> = EntityInstance<TTable>>(ctx: EntityContext, table: TTable, row: Record<string, unknown>, lazyRelations?: (keyof RelationMap<TTable>)[]) => TResult;
+declare const createEntityFromRow: <TTable extends TableDef, TResult extends EntityInstance<TTable> = EntityInstance<TTable>>(ctx: EntityContext, table: TTable, row: Record<string, unknown>, lazyRelations?: (keyof RelationMap<TTable>)[], lazyRelationOptions?: Map<string, RelationIncludeOptions>) => TResult;
 
 /**
  * An array of database rows, each represented as a record of string keys to unknown values.
@@ -5192,7 +5533,7 @@ type Rows$3 = Record<string, unknown>[];
  * @param relation - The has-many relation definition.
  * @returns A promise resolving to a map of root keys to arrays of related rows.
  */
-declare const loadHasManyRelation: (ctx: EntityContext, rootTable: TableDef, _relationName: string, relation: HasManyRelation) => Promise<Map<string, Rows$3>>;
+declare const loadHasManyRelation: (ctx: EntityContext, rootTable: TableDef, relationName: string, relation: HasManyRelation, options?: RelationIncludeOptions) => Promise<Map<string, Rows$3>>;
 /**
  * Loads related entities for a has-one relation in batch.
  * @param ctx - The entity context.
@@ -5201,7 +5542,7 @@ declare const loadHasManyRelation: (ctx: EntityContext, rootTable: TableDef, _re
  * @param relation - The has-one relation definition.
  * @returns A promise resolving to a map of root keys to single related rows.
  */
-declare const loadHasOneRelation: (ctx: EntityContext, rootTable: TableDef, _relationName: string, relation: HasOneRelation) => Promise<Map<string, Record<string, unknown>>>;
+declare const loadHasOneRelation: (ctx: EntityContext, rootTable: TableDef, relationName: string, relation: HasOneRelation, options?: RelationIncludeOptions) => Promise<Map<string, Record<string, unknown>>>;
 /**
  * Loads related entities for a belongs-to relation in batch.
  * @param ctx - The entity context.
@@ -5210,7 +5551,7 @@ declare const loadHasOneRelation: (ctx: EntityContext, rootTable: TableDef, _rel
  * @param relation - The belongs-to relation definition.
  * @returns A promise resolving to a map of foreign keys to single related rows.
  */
-declare const loadBelongsToRelation: (ctx: EntityContext, rootTable: TableDef, _relationName: string, relation: BelongsToRelation) => Promise<Map<string, Record<string, unknown>>>;
+declare const loadBelongsToRelation: (ctx: EntityContext, rootTable: TableDef, relationName: string, relation: BelongsToRelation, options?: RelationIncludeOptions) => Promise<Map<string, Record<string, unknown>>>;
 /**
  * Loads related entities for a belongs-to-many relation in batch, including pivot data.
  * @param ctx - The entity context.
@@ -5219,26 +5560,7 @@ declare const loadBelongsToRelation: (ctx: EntityContext, rootTable: TableDef, _
  * @param relation - The belongs-to-many relation definition.
  * @returns A promise resolving to a map of root keys to arrays of related rows with pivot data.
  */
-declare const loadBelongsToManyRelation: (ctx: EntityContext, rootTable: TableDef, _relationName: string, relation: BelongsToManyRelation) => Promise<Map<string, Rows$3>>;
-
-/**
- * Metadata stored on entity instances for ORM internal use
- * @typeParam TTable - Table definition type
- */
-interface EntityMeta<TTable extends TableDef> {
-    /** Entity context */
-    ctx: EntityContext;
-    /** Table definition */
-    table: TTable;
-    /** Relations that should be loaded lazily */
-    lazyRelations: (keyof RelationMap<TTable>)[];
-    /** Cache for relation promises */
-    relationCache: Map<string, Promise<unknown>>;
-    /** Hydration data for relations */
-    relationHydration: Map<string, Map<string, unknown>>;
-    /** Relation wrapper instances */
-    relationWrappers: Map<string, unknown>;
-}
+declare const loadBelongsToManyRelation: (ctx: EntityContext, rootTable: TableDef, relationName: string, relation: BelongsToManyRelation, options?: RelationIncludeOptions) => Promise<Map<string, Rows$3>>;
 
 type Rows$2 = Record<string, unknown>[];
 /**
@@ -5282,6 +5604,14 @@ declare class DefaultHasManyCollection<TChild> implements HasManyCollection<TChi
      * @returns Array of child entities
      */
     getItems(): TChild[];
+    /**
+     * Array-compatible length for testing frameworks.
+     */
+    get length(): number;
+    /**
+     * Enables iteration over the collection like an array.
+     */
+    [Symbol.iterator](): Iterator<TChild>;
     /**
      * Adds a new child entity to the collection.
      * @param data - Partial data for the new entity
@@ -5312,7 +5642,13 @@ declare class DefaultHasManyCollection<TChild> implements HasManyCollection<TChi
 }
 
 type Rows$1 = Record<string, unknown>;
-declare class DefaultBelongsToReference<TParent> implements BelongsToReference<TParent> {
+/**
+ * Default implementation of a belongs-to reference.
+ * Manages a reference to a parent entity from a child entity through a foreign key.
+ *
+ * @template TParent The type of the parent entity.
+ */
+declare class DefaultBelongsToReference<TParent extends object> implements BelongsToReferenceApi<TParent> {
     private readonly ctx;
     private readonly meta;
     private readonly root;
@@ -5324,6 +5660,17 @@ declare class DefaultBelongsToReference<TParent> implements BelongsToReference<T
     private readonly targetKey;
     private loaded;
     private current;
+    /**
+     * @param ctx The entity context for tracking changes.
+     * @param meta Metadata for the child entity.
+     * @param root The child entity instance (carrying the foreign key).
+     * @param relationName The name of the relation.
+     * @param relation Relation definition.
+     * @param rootTable Table definition of the child entity.
+     * @param loader Function to load the parent entity.
+     * @param createEntity Function to create entity instances from rows.
+     * @param targetKey The primary key of the target (parent) table.
+     */
     constructor(ctx: EntityContext, meta: EntityMeta<TableDef>, root: unknown, relationName: string, relation: BelongsToRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows$1>>, createEntity: (row: Record<string, unknown>) => TParent, targetKey: string);
     load(): Promise<TParent | null>;
     get(): TParent | null;
@@ -5334,6 +5681,13 @@ declare class DefaultBelongsToReference<TParent> implements BelongsToReference<T
 }
 
 type Rows = Record<string, unknown>[];
+/**
+ * Default implementation of a many-to-many collection.
+ * Manages the relationship between two entities through a pivot table.
+ * Supports lazy loading, attaching/detaching entities, and syncing by IDs.
+ *
+ * @template TTarget The type of the target entities in the collection.
+ */
 declare class DefaultManyToManyCollection<TTarget> implements ManyToManyCollection<TTarget> {
     private readonly ctx;
     private readonly meta;
@@ -5346,11 +5700,53 @@ declare class DefaultManyToManyCollection<TTarget> implements ManyToManyCollecti
     private readonly localKey;
     private loaded;
     private items;
+    /**
+     * @param ctx The entity context for tracking changes.
+     * @param meta Metadata for the root entity.
+     * @param root The root entity instance.
+     * @param relationName The name of the relation.
+     * @param relation Relation definition.
+     * @param rootTable Table definition of the root entity.
+     * @param loader Function to load the collection items.
+     * @param createEntity Function to create entity instances from rows.
+     * @param localKey The local key used for joining.
+     */
     constructor(ctx: EntityContext, meta: EntityMeta<TableDef>, root: unknown, relationName: string, relation: BelongsToManyRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows>>, createEntity: (row: Record<string, unknown>) => TTarget, localKey: string);
+    /**
+     * Loads the collection items if not already loaded.
+     * @returns A promise that resolves to the array of target entities.
+     */
     load(): Promise<TTarget[]>;
+    /**
+     * Returns the currently loaded items.
+     * @returns Array of target entities.
+     */
     getItems(): TTarget[];
+    /**
+     * Array-compatible length for testing frameworks.
+     */
+    get length(): number;
+    /**
+     * Enables iteration over the collection like an array.
+     */
+    [Symbol.iterator](): Iterator<TTarget>;
+    /**
+     * Attaches an entity to the collection.
+     * Registers an 'attach' change in the entity context.
+     * @param target Entity instance or its primary key value.
+     */
     attach(target: TTarget | number | string): void;
+    /**
+     * Detaches an entity from the collection.
+     * Registers a 'detach' change in the entity context.
+     * @param target Entity instance or its primary key value.
+     */
     detach(target: TTarget | number | string): void;
+    /**
+     * Syncs the collection with a list of IDs.
+     * Attaches missing IDs and detaches IDs not in the list.
+     * @param ids Array of primary key values to sync with.
+     */
     syncByIds(ids: (number | string)[]): Promise<void>;
     private ensureEntity;
     private extractId;
@@ -5560,7 +5956,18 @@ declare const getTableDefFromEntity: <TTable extends TableDef = TableDef>(ctor:
  * @param ctor - The entity constructor.
  * @returns A select query builder for the entity.
  */
-declare const selectFromEntity: <TTable extends TableDef = TableDef>(ctor: EntityConstructor) => SelectQueryBuilder<unknown, TTable>;
+type NonFunctionKeys<T> = {
+    [K in keyof T]-?: T[K] extends (...args: unknown[]) => unknown ? never : K;
+}[keyof T];
+type RelationKeys<TEntity extends object> = Exclude<NonFunctionKeys<TEntity>, SelectableKeys<TEntity>> & string;
+type EntityTable<TEntity extends object> = Omit<TableDef<{
+    [K in SelectableKeys<TEntity>]: ColumnDef;
+}>, 'relations'> & {
+    relations: {
+        [K in RelationKeys<TEntity>]: NonNullable<TEntity[K]> extends HasManyCollection<infer TChild> ? HasManyRelation<EntityTable<NonNullable<TChild> & object>> : NonNullable<TEntity[K]> extends ManyToManyCollection<infer TTarget> ? BelongsToManyRelation<EntityTable<NonNullable<TTarget> & object>> : NonNullable<TEntity[K]> extends HasOneReference<infer TChild> ? HasOneRelation<EntityTable<NonNullable<TChild> & object>> : NonNullable<TEntity[K]> extends BelongsToReference<infer TParent> ? BelongsToRelation<EntityTable<NonNullable<TParent> & object>> : NonNullable<TEntity[K]> extends object ? BelongsToRelation<EntityTable<NonNullable<TEntity[K]> & object>> : never;
+    };
+};
+declare const selectFromEntity: <TEntity extends object>(ctor: EntityConstructor<TEntity>) => SelectQueryBuilder<unknown, EntityTable<TEntity>>;
 /**
  * Public API: opt-in ergonomic entity reference (decorator-level).
  *
@@ -5626,6 +6033,11 @@ interface PostgresClientLike {
         rows: Array<Record<string, unknown>>;
     }>;
 }
+/**
+ * Creates a database executor for PostgreSQL.
+ * @param client A PostgreSQL client or pool instance.
+ * @returns A DbExecutor implementation for Postgres.
+ */
 declare function createPostgresExecutor(client: PostgresClientLike): DbExecutor;
 
 interface MysqlClientLike {
@@ -5634,6 +6046,11 @@ interface MysqlClientLike {
     commit?(): Promise<void>;
     rollback?(): Promise<void>;
 }
+/**
+ * Creates a database executor for MySQL.
+ * @param client A MySQL client instance.
+ * @returns A DbExecutor implementation for MySQL.
+ */
 declare function createMysqlExecutor(client: MysqlClientLike): DbExecutor;
 
 interface SqliteClientLike {
@@ -5643,6 +6060,11 @@ interface SqliteClientLike {
     commitTransaction?(): Promise<void>;
     rollbackTransaction?(): Promise<void>;
 }
+/**
+ * Creates a database executor for SQLite.
+ * @param client A SQLite client instance.
+ * @returns A DbExecutor implementation for SQLite.
+ */
 declare function createSqliteExecutor(client: SqliteClientLike): DbExecutor;
 
 interface MssqlClientLike {
@@ -5653,6 +6075,11 @@ interface MssqlClientLike {
     commit?(): Promise<void>;
     rollback?(): Promise<void>;
 }
+/**
+ * Creates a database executor for Microsoft SQL Server.
+ * @param client A SQL Server client instance.
+ * @returns A DbExecutor implementation for MSSQL.
+ */
 declare function createMssqlExecutor(client: MssqlClientLike): DbExecutor;
 interface TediousColumn {
     metadata: {
@@ -5712,4 +6139,4 @@ type PooledExecutorFactoryOptions<TConn> = {
  */
 declare function createPooledExecutorFactory<TConn>(opts: PooledExecutorFactoryOptions<TConn>): DbExecutorFactory;
 
-export { type AliasRefNode, type AnyDomainEvent, type ArithmeticExpressionNode, type TableRef as AstTableRef, AsyncLocalStorage, BelongsTo, BelongsToMany, type BelongsToManyOptions, type BelongsToManyRelation, type BelongsToOptions, type BelongsToReference, type BelongsToRelation, type BetweenExpressionNode, type BinaryExpressionNode, type CascadeMode, type CaseExpressionNode, type CastExpressionNode, type CheckConstraint, Column, type ColumnDef, type ColumnDiff, type ColumnInput, type ColumnNode, type ColumnOptions, type ColumnRef, type ColumnToTs, type ColumnType, type CreateTediousClientOptions, type DatabaseCheck, type DatabaseColumn, type DatabaseIndex, type DatabaseSchema, type DatabaseTable, type DbExecutor, type DbExecutorFactory, DefaultBelongsToReference, DefaultHasManyCollection, DefaultManyToManyCollection, type DefaultValue, DeleteQueryBuilder, type DialectName, type DomainEvent, DomainEventBus, type DomainEventHandler, Entity, type EntityContext, type EntityInstance, type EntityOptions, EntityStatus, type ExecutionContext, type ExistsExpressionNode, type ExpressionNode, type ExpressionVisitor, type ForeignKeyReference, type FunctionNode, type GroupConcatOptions, type HasDomainEvents, HasMany, type HasManyCollection, type HasManyOptions, type HasManyRelation, HasOne, type HasOneOptions, type HasOneReference, type HasOneRelation, type HydrationContext, type HydrationMetadata, type HydrationPivotPlan, type HydrationPlan, type HydrationRelationPlan, type InExpressionNode, type InExpressionRight, type IndexColumn, type IndexDef, type InferRow, type InitialHandlers, InsertQueryBuilder, type IntrospectOptions, type JsonPathNode, type Jsonify, type JsonifyScalar, type LiteralNode, type LiteralValue, type LogicalExpressionNode, type ManyToManyCollection, type MssqlClientLike, MySqlDialect, type MysqlClientLike, type NullExpressionNode, type OperandNode, type OperandVisitor, Orm, type OrmDomainEvent, type OrmInterceptor, type OrmOptions, OrmSession, type OrmSessionOptions, Pool, type PoolAdapter, type PoolLease, type PoolOptions, type PooledConnectionAdapter, type PostgresClientLike, PostgresDialect, PrimaryKey, type QueryLogEntry, type QueryLogger, type QueryResult, type RawDefaultValue, type ReferentialAction, type RelationChange, type RelationChangeEntry, type RelationDef, type RelationKey, RelationKinds, type RelationMap, type RelationTargetTable, type RelationType, type RenderColumnOptions, STANDARD_COLUMN_TYPES, type SaveGraphInputPayload, type SaveGraphInputScalar, type SaveGraphJsonScalar, type ScalarSubqueryNode, type SchemaChange, type SchemaChangeKind, type SchemaDiffOptions, type SchemaGenerateResult, type SchemaIntrospector, type SchemaPlan, SelectQueryBuilder, type SelectQueryInput, type SimpleQueryRunner, SqlServerDialect, type SqliteClientLike, SqliteDialect, type StandardColumnType, type SynchronizeOptions, type TableDef, type TableHooks, type TableOptions, type TableRef$1 as TableRef, type TediousColumn, type TediousConnectionLike, type TediousModule, type TediousRequest, type TediousRequestCtor, type TediousTypes, type TrackedEntity, TypeScriptGenerator, UpdateQueryBuilder, type ValueOperandInput, type WindowFunctionNode, abs, acos, add, addDomainEvent, aliasRef, and, ascii, asin, atan, atan2, avg, belongsTo, belongsToMany, between, bootstrapEntities, caseWhen, cast, ceil, ceiling, char, charLength, clearExpressionDispatchers, clearOperandDispatchers, col, columnOperand, concat, concatWs, correlateBy, cos, cot, count, countAll, createEntityFromRow, createEntityProxy, createExecutorFromQueryRunner, createMssqlExecutor, createMysqlExecutor, createPooledExecutorFactory, createPostgresExecutor, createQueryLoggingExecutor, createSqliteExecutor, createTediousExecutor, createTediousMssqlClient, currentDate, currentTime, dateAdd, dateDiff, dateFormat, dateSub, dateTrunc, day, dayOfWeek, defineTable, degrees, denseRank, diffSchema, div, endOfMonth, entityRef, eq, esel, executeHydrated, executeHydratedWithContexts, exists, exp, extract, firstValue, floor, fromUnixTime, generateCreateTableSql, generateSchemaSql, getColumn, getDecoratorMetadata, getSchemaIntrospector, getTableDefFromEntity, groupConcat, gt, gte, hasMany, hasOne, hydrateRows, inList, inSubquery, instr, introspectSchema, isCaseExpressionNode, isCastExpressionNode, isExpressionSelectionNode, isFunctionNode, isNotNull, isNull, isOperandNode, isValueOperandInput, isWindowFunctionNode, jsonPath, jsonify, lag, lastValue, lead, left, length, like, ln, loadBelongsToManyRelation, loadBelongsToRelation, loadHasManyRelation, loadHasOneRelation, locate, log, log10, logBase, lower, lpad, lt, lte, ltrim, max, min, mod, month, mul, neq, normalizeColumnType, notBetween, notExists, notInList, notInSubquery, notLike, now, ntile, or, outerRef, pi, position, pow, power, radians, rand, random, rank, registerExpressionDispatcher, registerOperandDispatcher, registerSchemaIntrospector, renderColumnDefinition, renderTypeWithArgs, repeat, replace, right, round, rowNumber, rowsToQueryResult, rpad, rtrim, sel, selectFromEntity, sign, sin, space, sqrt, sub, substr, sum, synchronizeSchema, tableRef, tan, toColumnRef, toTableRef, trim, trunc, truncate, unixTimestamp, upper, utcNow, valueToOperand, visitExpression, visitOperand, weekOfYear, windowFunction, year };
+export { type AliasRefNode, type AnyDomainEvent, type ArithmeticExpressionNode, type TableRef as AstTableRef, AsyncLocalStorage, BelongsTo, BelongsToMany, type BelongsToManyOptions, type BelongsToManyRelation, type BelongsToOptions, type BelongsToReference, type BelongsToReferenceApi, type BelongsToRelation, type BetweenExpressionNode, type BinaryExpressionNode, type BitwiseExpressionNode, type CascadeMode, type CaseExpressionNode, type CastExpressionNode, type CheckConstraint, type CollateExpressionNode, Column, type ColumnDef, type ColumnDiff, type ColumnInput, type ColumnNode, type ColumnOptions, type ColumnRef, type ColumnToTs, type ColumnType, type CreateTediousClientOptions, type DatabaseCheck, type DatabaseColumn, type DatabaseIndex, type DatabaseSchema, type DatabaseTable, type DbExecutor, type DbExecutorFactory, DefaultBelongsToReference, DefaultHasManyCollection, DefaultManyToManyCollection, type DefaultValue, DeleteQueryBuilder, type DialectName, type DomainEvent, DomainEventBus, type DomainEventHandler, Entity, type EntityContext, type EntityInstance, type EntityOptions, EntityStatus, type ExecutionContext, type ExistsExpressionNode, type ExpressionNode, type ExpressionVisitor, type ForeignKeyReference, type FunctionNode, type GroupConcatOptions, type HasDomainEvents, HasMany, type HasManyCollection, type HasManyOptions, type HasManyRelation, HasOne, type HasOneOptions, type HasOneReference, type HasOneReferenceApi, type HasOneRelation, type HydrationContext, type HydrationMetadata, type HydrationPivotPlan, type HydrationPlan, type HydrationRelationPlan, type InExpressionNode, type InExpressionRight, type IndexColumn, type IndexDef, type InferRow, type InitialHandlers, InsertQueryBuilder, type IntrospectOptions, type JsonPathNode, type Jsonify, type JsonifyScalar, type LiteralNode, type LiteralValue, type LogicalExpressionNode, type ManyToManyCollection, type MssqlClientLike, MySqlDialect, type MysqlClientLike, type NullExpressionNode, type OperandNode, type OperandVisitor, Orm, type OrmDomainEvent, type OrmInterceptor, type OrmOptions, OrmSession, type OrmSessionOptions, Pool, type PoolAdapter, type PoolLease, type PoolOptions, type PooledConnectionAdapter, type PostgresClientLike, PostgresDialect, PrimaryKey, type Primitive, type QueryLogEntry, type QueryLogger, type QueryResult, type RawDefaultValue, type ReferentialAction, type RelationChange, type RelationChangeEntry, type RelationDef, type RelationKey, RelationKinds, type RelationMap, type RelationTargetTable, type RelationType, type RenderColumnOptions, STANDARD_COLUMN_TYPES, type SaveGraphInputPayload, type SaveGraphInputScalar, type SaveGraphJsonScalar, type ScalarSubqueryNode, type SchemaChange, type SchemaChangeKind, type SchemaDiffOptions, type SchemaGenerateResult, type SchemaIntrospector, type SchemaPlan, SelectQueryBuilder, type SelectQueryInput, type SelectableKeys, type SimpleQueryRunner, SqlServerDialect, type SqliteClientLike, SqliteDialect, type StandardColumnType, type SynchronizeOptions, type TableDef, type TableHooks, type TableOptions, type TableRef$1 as TableRef, type TediousColumn, type TediousConnectionLike, type TediousModule, type TediousRequest, type TediousRequestCtor, type TediousTypes, type TrackedEntity, TypeScriptGenerator, UpdateQueryBuilder, type ValueOperandInput, type WindowFunctionNode, abs, acos, add, addDomainEvent, age, aliasRef, and, arrayAppend, ascii, asin, atan, atan2, avg, belongsTo, belongsToMany, between, bitAnd, bitLength, bitOr, bitXor, bootstrapEntities, caseWhen, cast, cbrt, ceil, ceiling, char, charLength, chr, clearExpressionDispatchers, clearOperandDispatchers, coalesce, col, collate, columnOperand, concat, concatWs, correlateBy, cos, cot, count, countAll, createEntityFromRow, createEntityProxy, createExecutorFromQueryRunner, createMssqlExecutor, createMysqlExecutor, createPooledExecutorFactory, createPostgresExecutor, createQueryLoggingExecutor, createSqliteExecutor, createTediousExecutor, createTediousMssqlClient, currentDate, currentTime, dateAdd, dateDiff, dateFormat, dateSub, dateTrunc, day, dayOfWeek, defineTable, degrees, denseRank, diffSchema, div, endOfMonth, entityRef, eq, esel, executeHydrated, executeHydratedWithContexts, exists, exp, extract, firstValue, floor, fromUnixTime, generateCreateTableSql, generateSchemaSql, getColumn, getDecoratorMetadata, getSchemaIntrospector, getTableDefFromEntity, greatest, groupConcat, gt, gte, hasMany, hasOne, hour, hydrateRows, ifNull, inList, inSubquery, initcap, instr, introspectSchema, isCaseExpressionNode, isCastExpressionNode, isCollateExpressionNode, isExpressionSelectionNode, isFunctionNode, isNotNull, isNull, isOperandNode, isValueOperandInput, isWindowFunctionNode, jsonArrayAgg, jsonContains, jsonLength, jsonPath, jsonSet, jsonify, lag, lastValue, lead, least, left, length, like, ln, loadBelongsToManyRelation, loadBelongsToRelation, loadHasManyRelation, loadHasOneRelation, localTime, localTimestamp, locate, log, log10, log2, logBase, lower, lpad, lt, lte, ltrim, max, md5, min, minute, mod, month, mul, neq, normalizeColumnType, notBetween, notExists, notInList, notInSubquery, notLike, now, ntile, nullif, octetLength, or, outerRef, pi, position, pow, power, quarter, radians, rand, random, rank, registerExpressionDispatcher, registerOperandDispatcher, registerSchemaIntrospector, relationLoaderCache, renderColumnDefinition, renderTypeWithArgs, repeat, replace, reverse, right, round, rowNumber, rowsToQueryResult, rpad, rtrim, second, sel, selectFromEntity, sha1, sha2, shiftLeft, shiftRight, sign, sin, space, sqrt, stddev, sub, substr, sum, synchronizeSchema, tableRef, tan, toColumnRef, toTableRef, trim, trunc, truncate, unixTimestamp, upper, utcNow, valueToOperand, variance, visitExpression, visitOperand, weekOfYear, windowFunction, year };