metal-orm 1.1.8 → 1.1.10

package/dist/index.d.cts

@@ -212,6 +212,12 @@ declare const RelationKinds: {
     readonly BelongsTo: "BELONGS_TO";
     /** Many-to-many relationship with pivot metadata */
     readonly BelongsToMany: "BELONGS_TO_MANY";
+    /** Polymorphic inverse (child side) */
+    readonly MorphTo: "MORPH_TO";
+    /** Polymorphic one-to-one (parent side) */
+    readonly MorphOne: "MORPH_ONE";
+    /** Polymorphic one-to-many (parent side) */
+    readonly MorphMany: "MORPH_MANY";
 };
 /**
  * Type representing the supported relationship kinds
@@ -263,10 +269,48 @@ interface BelongsToManyRelation<TTarget extends TableDef = TableDef, TPivot exte
     defaultPivotColumns?: string[];
     cascade?: CascadeMode;
 }
+/**
+ * Polymorphic inverse relationship (child side).
+ * The child row stores a type + id pair that can point to any of the listed targets.
+ */
+interface MorphToRelation<TTargets extends Record<string, TableDef> = Record<string, TableDef>> {
+    type: typeof RelationKinds.MorphTo;
+    typeField: string;
+    idField: string;
+    targets: TTargets;
+    targetKey?: string;
+    cascade?: CascadeMode;
+}
+/**
+ * Polymorphic one-to-one relationship (parent side).
+ */
+interface MorphOneRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.MorphOne;
+    target: TTarget;
+    morphName: string;
+    typeField: string;
+    idField: string;
+    typeValue: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
+/**
+ * Polymorphic one-to-many relationship (parent side).
+ */
+interface MorphManyRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.MorphMany;
+    target: TTarget;
+    morphName: string;
+    typeField: string;
+    idField: string;
+    typeValue: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
 /**
  * Union type representing any supported relationship definition
  */
-type RelationDef = HasManyRelation | HasOneRelation | BelongsToRelation | BelongsToManyRelation;
+type RelationDef = HasManyRelation | HasOneRelation | BelongsToRelation | BelongsToManyRelation | MorphToRelation | MorphOneRelation | MorphManyRelation;
 /**
  * Creates a one-to-many relationship definition
  * @param target - Target table of the relationship
@@ -317,6 +361,31 @@ declare const belongsToMany: <TTarget extends TableDef, TPivot extends TableDef
     defaultPivotColumns?: string[];
     cascade?: CascadeMode;
 }) => BelongsToManyRelation<TTarget, TPivot>;
+declare const isSingleTargetRelation: (rel: RelationDef) => rel is Exclude<RelationDef, MorphToRelation>;
+declare const isMorphRelation: (rel: RelationDef) => rel is MorphToRelation | MorphOneRelation | MorphManyRelation;
+declare const morphTo: <TTargets extends Record<string, TableDef>>(opts: {
+    typeField: string;
+    idField: string;
+    targets: TTargets;
+    targetKey?: string;
+    cascade?: CascadeMode;
+}) => MorphToRelation<TTargets>;
+declare const morphOne: <TTarget extends TableDef>(target: TTarget, opts: {
+    as: string;
+    typeValue: string;
+    localKey?: string;
+    typeField?: string;
+    idField?: string;
+    cascade?: CascadeMode;
+}) => MorphOneRelation<TTarget>;
+declare const morphMany: <TTarget extends TableDef>(target: TTarget, opts: {
+    as: string;
+    typeValue: string;
+    localKey?: string;
+    typeField?: string;
+    idField?: string;
+    cascade?: CascadeMode;
+}) => MorphManyRelation<TTarget>;
 
 interface IndexColumn {
     column: string;
@@ -458,7 +527,7 @@ declare function getColumn<T extends TableDef>(table: T, key: string): ColumnDef
 /**
  * Resolves a relation definition to its target table type.
  */
-type RelationTargetTable<TRel extends RelationDef> = TRel extends HasManyRelation<infer TTarget> ? TTarget : TRel extends HasOneRelation<infer TTarget> ? TTarget : TRel extends BelongsToRelation<infer TTarget> ? TTarget : TRel extends BelongsToManyRelation<infer TTarget, TableDef> ? TTarget : never;
+type RelationTargetTable<TRel extends RelationDef> = TRel extends HasManyRelation<infer TTarget> ? TTarget : TRel extends HasOneRelation<infer TTarget> ? TTarget : TRel extends BelongsToRelation<infer TTarget> ? TTarget : TRel extends BelongsToManyRelation<infer TTarget, TableDef> ? TTarget : TRel extends MorphOneRelation<infer TTarget> ? TTarget : TRel extends MorphManyRelation<infer TTarget> ? TTarget : TRel extends MorphToRelation ? never : never;
 type JsonValue = string | number | boolean | null | JsonArray | JsonObject;
 type JsonArray = Array<JsonValue>;
 interface JsonObject {
@@ -479,7 +548,7 @@ type InferRow<TTable extends TableDef> = {
 };
 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, infer TPivot> ? (InferRow<TTarget> & {
     _pivot?: InferRow<TPivot>;
-})[] : never;
+})[] : T extends MorphOneRelation<infer TTarget> ? InferRow<TTarget> | null : T extends MorphManyRelation<infer TTarget> ? InferRow<TTarget>[] : T extends MorphToRelation ? Record<string, unknown> | null : never;
 /**
  * Maps relation names to the expected row results
  */
@@ -490,7 +559,7 @@ type RelationWrapper$1<TRel extends RelationDef> = TRel extends HasManyRelation<
     _pivot?: InferRow<TPivot>;
 }> & ReadonlyArray<EntityInstance<TTarget> & {
     _pivot?: InferRow<TPivot>;
-}> : TRel extends BelongsToRelation<infer TTarget> ? BelongsToReference<EntityInstance<TTarget>> : never;
+}> : TRel extends BelongsToRelation<infer TTarget> ? BelongsToReference<EntityInstance<TTarget>> : TRel extends MorphOneRelation<infer TTarget> ? HasOneReference<EntityInstance<TTarget>> : TRel extends MorphManyRelation<infer TTarget> ? HasManyCollection<EntityInstance<TTarget>> & ReadonlyArray<EntityInstance<TTarget>> : TRel extends MorphToRelation ? BelongsToReference<EntityInstance<TableDef>> : never;
 interface HasManyCollection<TChild> {
     length: number;
     [Symbol.iterator](): Iterator<TChild>;
@@ -849,6 +918,14 @@ interface LogicalExpressionNode {
     /** Operands to combine */
     operands: ExpressionNode[];
 }
+/**
+ * AST node representing a unary NOT expression
+ */
+interface NotExpressionNode {
+    type: 'NotExpression';
+    /** Expression to negate */
+    operand: ExpressionNode;
+}
 /**
  * AST node representing a null check expression
  */
@@ -895,10 +972,25 @@ interface BetweenExpressionNode {
     /** Upper bound */
     upper: OperandNode;
 }
+/**
+ * AST node representing an IS DISTINCT FROM / IS NOT DISTINCT FROM expression
+ */
+interface IsDistinctExpressionNode {
+    type: 'IsDistinctExpression';
+    /** The operand on the left side. */
+    left: OperandNode;
+    /**
+     * `'IS DISTINCT FROM'`     → true when values are different, even if one is NULL.
+     * `'IS NOT DISTINCT FROM'` → true when values are equal, treating NULL = NULL.
+     */
+    operator: 'IS DISTINCT FROM' | 'IS NOT DISTINCT FROM';
+    /** The operand on the right side. */
+    right: OperandNode;
+}
 /**
  * Union type representing any supported expression node
  */
-type ExpressionNode = BinaryExpressionNode | LogicalExpressionNode | NullExpressionNode | InExpressionNode | ExistsExpressionNode | BetweenExpressionNode | ArithmeticExpressionNode | BitwiseExpressionNode;
+type ExpressionNode = BinaryExpressionNode | LogicalExpressionNode | NotExpressionNode | NullExpressionNode | InExpressionNode | ExistsExpressionNode | BetweenExpressionNode | ArithmeticExpressionNode | BitwiseExpressionNode | IsDistinctExpressionNode;
 
 type LiteralValue = LiteralNode['value'];
 type ValueOperandInput = OperandNode | LiteralValue;
@@ -1068,6 +1160,19 @@ declare const and: (...operands: ExpressionNode[]) => LogicalExpressionNode;
  * );
  */
 declare const or: (...operands: ExpressionNode[]) => LogicalExpressionNode;
+/**
+ * Creates a unary NOT expression (`NOT (expr)`).
+ *
+ * @param operand - Expression to negate.
+ * @returns A `NotExpressionNode`.
+ *
+ * @example
+ * not(or(
+ *   eq(users.status, 'inactive'),
+ *   eq(users.role, 'guest')
+ * ));
+ */
+declare const not: (operand: ExpressionNode) => NotExpressionNode;
 /**
  * Creates an IS NULL check (`left IS NULL`).
  *
@@ -1308,6 +1413,66 @@ declare const notExists: (subquery: SelectQueryNode) => ExistsExpressionNode;
  * collate(users.email, 'nocase');
  */
 declare const collate: (expression: OperandNode | ColumnRef | string | number | boolean | null, collation: string) => CollateExpressionNode;
+/**
+ * Creates an `IS DISTINCT FROM` expression.
+ *
+ * Unlike `neq(a, b)`, this comparison is **null-safe**:
+ * returns `true` when values are different **including** when one
+ * (or both) is `NULL`. Never returns `NULL`.
+ *
+ * | left  | right | neq   | isDistinctFrom |
+ * |-------|-------|-------|----------------|
+ * | 1     | 2     | true  | true           |
+ * | 1     | 1     | false | false          |
+ * | NULL  | 1     | NULL  | **true**       |
+ * | NULL  | NULL  | NULL  | **false**      |
+ *
+ * Compilation by dialect:
+ * - PostgreSQL / SQLite / MSSQL → `left IS DISTINCT FROM right`
+ * - MySQL                       → `NOT (left <=> right)`
+ *
+ * @param left - The left operand.
+ * @param right - The right operand.
+ * @returns An `IsDistinctExpressionNode`.
+ *
+ * @example
+ * ```ts
+ * // Find users whose email has changed compared to backup
+ * where(isDistinctFrom(users.columns.email, backup.columns.email))
+ * ```
+ */
+declare const isDistinctFrom: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | LiteralValue) => IsDistinctExpressionNode;
+/**
+ * Creates an `IS NOT DISTINCT FROM` expression.
+ *
+ * The inverse of `isDistinctFrom`. Equivalent to a **null-safe** equality:
+ * returns `true` when values are equal **including** when both
+ * are `NULL`. Never returns `NULL`.
+ *
+ * | left  | right | eq    | isNotDistinctFrom |
+ * |-------|-------|-------|------------------|
+ * | 1     | 1     | true  | true             |
+ * | 1     | 2     | false | false            |
+ * | NULL  | 1     | NULL  | **false**        |
+ * | NULL  | NULL  | NULL  | **true**         |
+ *
+ * Compilation by dialect:
+ * - PostgreSQL / SQLite / MSSQL → `left IS NOT DISTINCT FROM right`
+ * - MySQL                       → `left <=> right`
+ *
+ * @param left - The left operand.
+ * @param right - The right operand.
+ * @returns An `IsDistinctExpressionNode`.
+ *
+ * @example
+ * ```ts
+ * // Rows where deletedAt is NULL or equal to a specific date
+ * where(isNotDistinctFrom(orders.columns.deletedAt, null))
+ * // → WHERE "orders"."deletedAt" IS NOT DISTINCT FROM NULL
+ * // equivalent to: WHERE deletedAt IS NULL  (but works with any value)
+ * ```
+ */
+declare const isNotDistinctFrom: (left: OperandNode | ColumnRef, right: OperandNode | ColumnRef | LiteralValue) => IsDistinctExpressionNode;
 
 /**
  * Creates a ROW_NUMBER window function.
@@ -1454,12 +1619,14 @@ declare const variance: (col: ColumnRef | ColumnNode) => TypedExpression<number>
 interface ExpressionVisitor<R> {
     visitBinaryExpression?(node: BinaryExpressionNode): R;
     visitLogicalExpression?(node: LogicalExpressionNode): R;
+    visitNotExpression?(node: NotExpressionNode): R;
     visitNullExpression?(node: NullExpressionNode): R;
     visitInExpression?(node: InExpressionNode): R;
     visitExistsExpression?(node: ExistsExpressionNode): R;
     visitBetweenExpression?(node: BetweenExpressionNode): R;
     visitArithmeticExpression?(node: ArithmeticExpressionNode): R;
     visitBitwiseExpression?(node: BitwiseExpressionNode): R;
+    visitIsDistinctExpression?(node: IsDistinctExpressionNode): R;
     otherwise?(node: ExpressionNode): R;
 }
 /**
@@ -2777,11 +2944,16 @@ interface DbExecutor {
     readonly capabilities: {
         /** True if begin/commit/rollback are real and should be used to provide atomicity. */
         transactions: boolean;
+        /** True if savepoint/release/rollback-to-savepoint are implemented. */
+        savepoints?: boolean;
     };
     executeSql(sql: string, params?: unknown[]): Promise<ExecutionPayload>;
     beginTransaction(): Promise<void>;
     commitTransaction(): Promise<void>;
     rollbackTransaction(): Promise<void>;
+    savepoint?(name: string): Promise<void>;
+    releaseSavepoint?(name: string): Promise<void>;
+    rollbackToSavepoint?(name: string): Promise<void>;
     /** Release any underlying resources (connections, pool leases, etc). Must be idempotent. */
     dispose(): Promise<void>;
 }
@@ -2798,6 +2970,9 @@ interface SimpleQueryRunner {
     beginTransaction?(): Promise<void>;
     commitTransaction?(): Promise<void>;
     rollbackTransaction?(): Promise<void>;
+    savepoint?(name: string): Promise<void>;
+    releaseSavepoint?(name: string): Promise<void>;
+    rollbackToSavepoint?(name: string): Promise<void>;
     /** Optional: release resources (connection close, pool lease release, etc). */
     dispose?(): Promise<void>;
 }
@@ -2943,10 +3118,50 @@ interface BelongsToManyRelationMetadata extends BaseRelationMetadata {
     /** Optional default pivot columns */
     defaultPivotColumns?: string[];
 }
+/**
+ * Metadata for morph-to (polymorphic inverse) relations.
+ */
+interface MorphToRelationMetadata {
+    propertyKey: string;
+    kind: typeof RelationKinds.MorphTo;
+    typeField: string;
+    idField: string;
+    targets: Record<string, EntityOrTableTargetResolver>;
+    targetKey?: string;
+    cascade?: CascadeMode;
+}
+/**
+ * Metadata for morph-one (polymorphic one-to-one, parent side) relations.
+ */
+interface MorphOneRelationMetadata {
+    propertyKey: string;
+    kind: typeof RelationKinds.MorphOne;
+    target: EntityOrTableTargetResolver;
+    morphName: string;
+    typeField?: string;
+    idField?: string;
+    typeValue: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
+/**
+ * Metadata for morph-many (polymorphic one-to-many, parent side) relations.
+ */
+interface MorphManyRelationMetadata {
+    propertyKey: string;
+    kind: typeof RelationKinds.MorphMany;
+    target: EntityOrTableTargetResolver;
+    morphName: string;
+    typeField?: string;
+    idField?: string;
+    typeValue: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
 /**
  * Union type for all relation metadata.
  */
-type RelationMetadata = HasManyRelationMetadata | HasOneRelationMetadata | BelongsToRelationMetadata | BelongsToManyRelationMetadata;
+type RelationMetadata = HasManyRelationMetadata | HasOneRelationMetadata | BelongsToRelationMetadata | BelongsToManyRelationMetadata | MorphToRelationMetadata | MorphOneRelationMetadata | MorphManyRelationMetadata;
 
 /**
  * Entity status enum representing the lifecycle state of an entity
@@ -4017,6 +4232,9 @@ declare class RelationChangeProcessor {
      */
     private resolvePrimaryKeyValue;
     private buildPivotPayload;
+    private handleMorphOneChange;
+    private handleMorphManyChange;
+    private handleMorphToChange;
 }
 
 /**
@@ -4191,6 +4409,9 @@ declare class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Enti
     readonly tenantId?: string | number;
     private readonly interceptors;
     private saveGraphDefaults?;
+    private transactionDepth;
+    private savepointCounter;
+    private rollbackOnly;
     /**
      * Creates a new OrmSession instance.
      * @param opts - Session options
@@ -4417,6 +4638,9 @@ declare class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Enti
      * @returns Combined options with per-call values taking precedence
      */
     private resolveSaveGraphOptions;
+    private assertSavepointSupport;
+    private nextSavepointName;
+    private throwIfRollbackOnly;
 }
 
 type WhereHasOptions = {
@@ -4430,6 +4654,23 @@ interface PaginatedResult<T> {
     pageSize: number;
 }
 
+type CursorPageOptions = {
+    first?: number;
+    after?: string;
+    last?: number;
+    before?: string;
+};
+type CursorPageInfo = {
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor: string | null;
+    endCursor: string | null;
+};
+type CursorPageResult<T> = {
+    items: T[];
+    pageInfo: CursorPageInfo;
+};
+
 /**
  * Facet para gerenciar estado de cache no SelectQueryBuilder
  * Segue o padrão de facets existente no projeto
@@ -4927,7 +5168,35 @@ declare class SelectQueryBuilder<T = EntityInstance<TableDef>, TTable extends Ta
         pageSize: number;
     }): Promise<PaginatedResult<T>>;
     /**
-     * Executes the query and returns an array of values for a single column.
+     * Executes the query using cursor-based (keyset) pagination.
+     * Requires a stable ORDER BY on selected, non-null columns.
+     * Cursor pagination currently supports simple column references only and
+     * the cursor token is opaque: it must be reused with the same ORDER BY signature.
+     *
+     * @param session - ORM session context
+     * @param options - Cursor pagination options (`first`/`after` or `last`/`before`)
+     * @returns Promise of cursor-paginated result with items and pageInfo
+     * @example
+     * const page1 = await selectFrom(users)
+     *   .orderBy(users.columns.createdAt, 'DESC')
+     *   .orderBy(users.columns.id, 'DESC')
+     *   .executeCursor(session, { first: 20 });
+     *
+     * // Next page
+     * const page2 = await selectFrom(users)
+     *   .orderBy(users.columns.createdAt, 'DESC')
+     *   .orderBy(users.columns.id, 'DESC')
+     *   .executeCursor(session, { first: 20, after: page1.pageInfo.endCursor });
+     *
+     * // Previous page from a known cursor
+     * const prevPage = await selectFrom(users)
+     *   .orderBy(users.columns.createdAt, 'DESC')
+     *   .orderBy(users.columns.id, 'DESC')
+     *   .executeCursor(session, { last: 20, before: page2.pageInfo.startCursor });
+     */
+    executeCursor(session: OrmSession, options: CursorPageOptions): Promise<CursorPageResult<T>>;
+    /**
+      * Executes the query and returns an array of values for a single column.
      * This is a convenience method to avoid manual `.map(r => r.column)`.
      *
      * @param column - The column name to extract
@@ -7003,6 +7272,7 @@ declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandV
     private isNamedSelection;
     visitBinaryExpression(binary: BinaryExpressionNode): string;
     visitLogicalExpression(logical: LogicalExpressionNode): string;
+    visitNotExpression(notExpr: NotExpressionNode): string;
     visitNullExpression(nullExpr: NullExpressionNode): string;
     visitInExpression(inExpr: InExpressionNode): string;
     visitExistsExpression(existsExpr: ExistsExpressionNode): string;
@@ -7030,6 +7300,7 @@ declare class TypeScriptGenerator implements ExpressionVisitor<string>, OperandV
      * @returns TypeScript code representation
      */
     private printLogicalExpression;
+    private printNotExpression;
     private printArithmeticExpression;
     /**
      * Prints an IN expression to TypeScript code
@@ -7185,7 +7456,7 @@ declare const createEntityFromRow: <TTable extends TableDef, TResult extends Ent
 /**
  * An array of database rows, each represented as a record of string keys to unknown values.
  */
-type Rows$3 = Record<string, unknown>[];
+type Rows$4 = Record<string, unknown>[];
 
 /**
  * Loads related entities for a has-many relation in batch.
@@ -7195,7 +7466,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, options?: RelationIncludeOptions) => Promise<Map<string, Rows$3>>;
+declare const loadHasManyRelation: (ctx: EntityContext, rootTable: TableDef, relationName: string, relation: HasManyRelation, options?: RelationIncludeOptions) => Promise<Map<string, Rows$4>>;
 
 /**
  * Loads related entities for a has-one relation in batch.
@@ -7225,9 +7496,15 @@ declare const loadBelongsToRelation: (ctx: EntityContext, rootTable: TableDef, r
  * @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, options?: RelationIncludeOptions) => Promise<Map<string, Rows$3>>;
+declare const loadBelongsToManyRelation: (ctx: EntityContext, rootTable: TableDef, relationName: string, relation: BelongsToManyRelation, options?: RelationIncludeOptions) => Promise<Map<string, Rows$4>>;
+
+declare const loadMorphOneRelation: (ctx: EntityContext, rootTable: TableDef, relationName: string, relation: MorphOneRelation, options?: RelationIncludeOptions) => Promise<Map<string, Record<string, unknown>>>;
+
+declare const loadMorphManyRelation: (ctx: EntityContext, rootTable: TableDef, relationName: string, relation: MorphManyRelation, options?: RelationIncludeOptions) => Promise<Map<string, Rows$4>>;
 
-type Rows$2 = Record<string, unknown>[];
+declare const loadMorphToRelation: (ctx: EntityContext, rootTable: TableDef, _relationName: string, relation: MorphToRelation) => Promise<Map<string, Record<string, unknown>>>;
+
+type Rows$3 = Record<string, unknown>[];
 /**
  * Default implementation of HasManyCollection for managing one-to-many relationships.
  * @template TChild - The type of child entities in the collection
@@ -7258,7 +7535,7 @@ declare class DefaultHasManyCollection<TChild> implements HasManyCollection<TChi
      * @param createEntity - Function to create entities from rows
      * @param localKey - The local key for the relation
      */
-    constructor(ctx: EntityContext, meta: EntityMeta<TableDef>, root: unknown, relationName: string, relation: HasManyRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows$2>>, createEntity: (row: Record<string, unknown>) => TChild, localKey: string);
+    constructor(ctx: EntityContext, meta: EntityMeta<TableDef>, root: unknown, relationName: string, relation: HasManyRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows$3>>, createEntity: (row: Record<string, unknown>) => TChild, localKey: string);
     /**
      * Loads the related entities if not already loaded.
      * @returns Promise resolving to the array of child entities
@@ -7306,7 +7583,7 @@ declare class DefaultHasManyCollection<TChild> implements HasManyCollection<TChi
     toJSON(): unknown[];
 }
 
-type Rows$1 = Record<string, unknown>;
+type Rows$2 = Record<string, unknown>;
 /**
  * Default implementation of a belongs-to reference.
  * Manages a reference to a parent entity from a child entity through a foreign key.
@@ -7336,7 +7613,7 @@ declare class DefaultBelongsToReference<TParent extends object> implements Belon
      * @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);
+    constructor(ctx: EntityContext, meta: EntityMeta<TableDef>, root: unknown, relationName: string, relation: BelongsToRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows$2>>, createEntity: (row: Record<string, unknown>) => TParent, targetKey: string);
     load(): Promise<TParent | null>;
     get(): TParent | null;
     set(data: Partial<TParent> | TParent | null): TParent | null;
@@ -7345,7 +7622,7 @@ declare class DefaultBelongsToReference<TParent extends object> implements Belon
     toJSON(): unknown;
 }
 
-type Rows = Record<string, unknown>[];
+type Rows$1 = Record<string, unknown>[];
 /**
  * Default implementation of a many-to-many collection.
  * Manages the relationship between two entities through a pivot table.
@@ -7376,7 +7653,7 @@ declare class DefaultManyToManyCollection<TTarget, TPivot extends object | undef
      * @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);
+    constructor(ctx: EntityContext, meta: EntityMeta<TableDef>, root: unknown, relationName: string, relation: BelongsToManyRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows$1>>, 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.
@@ -7422,6 +7699,82 @@ declare class DefaultManyToManyCollection<TTarget, TPivot extends object | undef
     toJSON(): unknown[];
 }
 
+type Row$1 = Record<string, unknown>;
+declare class DefaultMorphOneReference<TChild extends object> implements HasOneReferenceApi<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 current;
+    constructor(ctx: EntityContext, meta: EntityMeta<TableDef>, root: unknown, relationName: string, relation: MorphOneRelation, rootTable: TableDef, loader: () => Promise<Map<string, Row$1>>, createEntity: (row: Row$1) => TChild, localKey: string);
+    load(): Promise<TChild | null>;
+    get(): TChild | null;
+    set(data: Partial<TChild> | TChild | null): TChild | null;
+    toJSON(): unknown;
+    private detachCurrent;
+    private assignMorphKeys;
+    private get relationKey();
+    private populateFromHydrationCache;
+}
+
+type Rows = Record<string, unknown>[];
+declare class DefaultMorphManyCollection<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: EntityContext, meta: EntityMeta<TableDef>, root: unknown, relationName: string, relation: MorphManyRelation, rootTable: TableDef, loader: () => Promise<Map<string, Rows>>, createEntity: (row: Record<string, unknown>) => TChild, localKey: string);
+    load(): Promise<TChild[]>;
+    getItems(): TChild[];
+    get length(): number;
+    [Symbol.iterator](): Iterator<TChild>;
+    add(data: Partial<TChild>): TChild;
+    attach(entity: TChild): void;
+    remove(entity: TChild): void;
+    clear(): void;
+    private get relationKey();
+    private hydrateFromCache;
+    toJSON(): unknown[];
+}
+
+type Row = Record<string, unknown>;
+declare class DefaultMorphToReference<TParent extends object> implements BelongsToReferenceApi<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 resolveTargetTable;
+    private loaded;
+    private current;
+    constructor(ctx: EntityContext, meta: EntityMeta<TableDef>, root: unknown, relationName: string, relation: MorphToRelation, rootTable: TableDef, loader: () => Promise<Map<string, Row>>, createEntity: (table: TableDef, row: Row) => TParent, resolveTargetTable: (typeValue: string) => TableDef | undefined);
+    load(): Promise<TParent | null>;
+    get(): TParent | null;
+    set(data: Partial<TParent> | TParent | null): TParent | null;
+    toJSON(): unknown;
+    private detachCurrent;
+    private get relationKey();
+    private populateFromHydrationCache;
+}
+
 /**
  * Executes a hydrated query using the ORM session.
  * @template TTable - The table type
@@ -7485,7 +7838,7 @@ interface EntityOptions {
  * @param options - Configuration options for the entity.
  * @returns A class decorator that registers the entity metadata.
  */
-declare function Entity(options?: EntityOptions): <T extends EntityConstructor>(value: T, context: ClassDecoratorContext) => T;
+declare function Entity(options?: EntityOptions): <T extends EntityConstructor>(value: T, context?: ClassDecoratorContext) => T;
 
 /**
  * Options for defining a column in an entity.
@@ -7508,14 +7861,14 @@ type ColumnInput = ColumnOptions | ColumnDef;
  * @param definition - The column definition or options.
  * @returns A property decorator that registers the column metadata.
  */
-declare function Column(definition: ColumnInput): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+declare function Column(definition: ColumnInput): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 /**
  * Decorator to define a primary key column on an entity property.
  * Sets the primary flag to true and delegates to Column decorator.
  * @param definition - The column definition or options.
  * @returns A property decorator that registers the primary key column metadata.
  */
-declare function PrimaryKey(definition: ColumnInput): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+declare function PrimaryKey(definition: ColumnInput): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 
 interface BaseRelationOptions {
     target: EntityOrTableTargetResolver;
@@ -7559,25 +7912,77 @@ interface BelongsToManyOptions<TTarget extends EntityOrTableTarget = EntityOrTab
  * @param options - The relation options.
  * @returns A property decorator that registers the relation metadata.
  */
-declare function HasMany(options: HasManyOptions): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+declare function HasMany(options: HasManyOptions): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 /**
  * Decorator to define a HasOne relation on an entity property.
  * @param options - The relation options.
  * @returns A property decorator that registers the relation metadata.
  */
-declare function HasOne(options: HasOneOptions): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+declare function HasOne(options: HasOneOptions): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 /**
  * Decorator to define a BelongsTo relation on an entity property.
  * @param options - The relation options.
  * @returns A property decorator that registers the relation metadata.
  */
-declare function BelongsTo(options: BelongsToOptions): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+declare function BelongsTo(options: BelongsToOptions): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 /**
  * Decorator to define a BelongsToMany relation on an entity property.
  * @param options - The relation options.
  * @returns A property decorator that registers the relation metadata.
  */
-declare function BelongsToMany<TTarget extends EntityOrTableTarget = EntityOrTableTarget, TPivot extends EntityOrTableTarget = EntityOrTableTarget>(options: BelongsToManyOptions<TTarget, TPivot>): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+declare function BelongsToMany<TTarget extends EntityOrTableTarget = EntityOrTableTarget, TPivot extends EntityOrTableTarget = EntityOrTableTarget>(options: BelongsToManyOptions<TTarget, TPivot>): (targetOrValue: unknown, contextOrProperty: unknown) => void;
+/**
+ * Options for MorphTo relation.
+ */
+interface MorphToOptions {
+    typeField: string;
+    idField: string;
+    targets: Record<string, EntityOrTableTargetResolver>;
+    targetKey?: string;
+    cascade?: CascadeMode;
+}
+/**
+ * Options for MorphOne relation.
+ */
+interface MorphOneOptions {
+    target: EntityOrTableTargetResolver;
+    morphName: string;
+    typeValue: string;
+    typeField?: string;
+    idField?: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
+/**
+ * Options for MorphMany relation.
+ */
+interface MorphManyOptions {
+    target: EntityOrTableTargetResolver;
+    morphName: string;
+    typeValue: string;
+    typeField?: string;
+    idField?: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
+/**
+ * Decorator to define a MorphTo relation on an entity property.
+ * @param options - The relation options.
+ * @returns A property decorator that registers the relation metadata.
+ */
+declare function MorphTo(options: MorphToOptions): (targetOrValue: unknown, contextOrProperty: unknown) => void;
+/**
+ * Decorator to define a MorphOne relation on an entity property.
+ * @param options - The relation options.
+ * @returns A property decorator that registers the relation metadata.
+ */
+declare function MorphOne(options: MorphOneOptions): (targetOrValue: unknown, contextOrProperty: unknown) => void;
+/**
+ * Decorator to define a MorphMany relation on an entity property.
+ * @param options - The relation options.
+ * @returns A property decorator that registers the relation metadata.
+ */
+declare function MorphMany(options: MorphManyOptions): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 
 /**
  * Bootstraps all entities by building their table definitions and relations.
@@ -7685,31 +8090,31 @@ declare function Trim(options?: {
     trimStart?: boolean;
     trimEnd?: boolean;
     trimAll?: boolean;
-}): (_value: unknown, context: ClassFieldDecoratorContext) => void;
-declare function Lower(): (_value: unknown, context: ClassFieldDecoratorContext) => void;
-declare function Upper(): (_value: unknown, context: ClassFieldDecoratorContext) => void;
-declare function Capitalize(): (_value: unknown, context: ClassFieldDecoratorContext) => void;
-declare function Title(): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+}): (targetOrValue: unknown, contextOrProperty: unknown) => void;
+declare function Lower(): (targetOrValue: unknown, contextOrProperty: unknown) => void;
+declare function Upper(): (targetOrValue: unknown, contextOrProperty: unknown) => void;
+declare function Capitalize(): (targetOrValue: unknown, contextOrProperty: unknown) => void;
+declare function Title(): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 declare function Alphanumeric(options?: {
     allowSpaces?: boolean;
     allowUnderscores?: boolean;
     allowHyphens?: boolean;
-}): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+}): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 declare function Email(options?: {
     allowPlus?: boolean;
     requireTLD?: boolean;
-}): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+}): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 declare function Length(options: {
     min?: number;
     max?: number;
     exact?: number;
-}): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+}): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 declare function Pattern(options: {
     pattern: RegExp;
     flags?: string;
     errorMessage?: string;
     replacement?: string;
-}): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+}): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 
 /**
  * Decorator to validate a Brazilian CPF number
@@ -7719,7 +8124,7 @@ declare function Pattern(options: {
 declare function CPF(options?: {
     strict?: boolean;
     errorMessage?: string;
-}): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+}): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 /**
  * Decorator to validate a Brazilian CNPJ number
  * @param options - Validation options
@@ -7728,7 +8133,7 @@ declare function CPF(options?: {
 declare function CNPJ(options?: {
     strict?: boolean;
     errorMessage?: string;
-}): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+}): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 /**
  * Decorator to validate a Brazilian CEP number
  * @param options - Validation options
@@ -7737,7 +8142,7 @@ declare function CNPJ(options?: {
 declare function CEP(options?: {
     strict?: boolean;
     errorMessage?: string;
-}): (_value: unknown, context: ClassFieldDecoratorContext) => void;
+}): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 
 /**
  * Base interface for country-specific identifier validators
@@ -8012,6 +8417,9 @@ interface SqliteClientLike {
     beginTransaction?(): Promise<void>;
     commitTransaction?(): Promise<void>;
     rollbackTransaction?(): Promise<void>;
+    savepoint?(name: string): Promise<void>;
+    releaseSavepoint?(name: string): Promise<void>;
+    rollbackToSavepoint?(name: string): Promise<void>;
 }
 /**
  * Creates a database executor for SQLite.
@@ -8020,6 +8428,25 @@ interface SqliteClientLike {
  */
 declare function createSqliteExecutor(client: SqliteClientLike): DbExecutor;
 
+interface BetterSqlite3Statement {
+    reader: boolean;
+    all(...params: unknown[]): unknown[];
+    run(...params: unknown[]): {
+        changes: number;
+        lastInsertRowid: number | bigint;
+    };
+}
+interface BetterSqlite3ClientLike {
+    prepare(sql: string): BetterSqlite3Statement;
+    transaction<T extends (...args: any[]) => any>(fn: T): T;
+}
+/**
+ * Creates a database executor for better-sqlite3.
+ * @param client A better-sqlite3 database instance.
+ * @returns A DbExecutor implementation for better-sqlite3.
+ */
+declare function createBetterSqlite3Executor(client: BetterSqlite3ClientLike): DbExecutor;
+
 interface MssqlClientLike {
     query(sql: string, params?: unknown[]): Promise<{
         recordset?: Array<Record<string, unknown>>;
@@ -8078,6 +8505,9 @@ interface PooledConnectionAdapter<TConn> {
     beginTransaction(conn: TConn): Promise<void>;
     commitTransaction(conn: TConn): Promise<void>;
     rollbackTransaction(conn: TConn): Promise<void>;
+    savepoint?(conn: TConn, name: string): Promise<void>;
+    releaseSavepoint?(conn: TConn, name: string): Promise<void>;
+    rollbackToSavepoint?(conn: TConn, name: string): Promise<void>;
 }
 type PooledExecutorFactoryOptions<TConn> = {
     pool: Pool<TConn>;
@@ -8390,7 +8820,9 @@ type FilterValue = StringFilter | NumberFilter | BooleanFilter | DateFilter;
 interface ApplyFilterOptions<TTable extends TableDef> {
     relations?: {
         [K in keyof TTable['relations']]?: boolean | {
-            relations?: ApplyFilterOptions<TTable['relations'][K]['target']>['relations'];
+            relations?: TTable['relations'][K] extends {
+                target: infer TTarget extends TableDef;
+            } ? ApplyFilterOptions<TTarget>['relations'] : never;
         };
     };
 }
@@ -9748,7 +10180,7 @@ interface TreeDecoratorOptions {
  * }
  * ```
  */
-declare function Tree(options?: TreeDecoratorOptions): <T extends abstract new (...args: unknown[]) => object>(target: T, context: ClassDecoratorContext<T>) => T;
+declare function Tree(options?: TreeDecoratorOptions): <T extends abstract new (...args: unknown[]) => object>(target: T, context?: ClassDecoratorContext<T>) => T;
 /**
  * Decorator to mark a property as the parent relation in a tree entity.
  *
@@ -9758,7 +10190,7 @@ declare function Tree(options?: TreeDecoratorOptions): <T extends abstract new (
  * parent?: Category;
  * ```
  */
-declare function TreeParent(): <T, V>(_value: undefined, context: ClassFieldDecoratorContext<T, V>) => void;
+declare function TreeParent(): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 /**
  * Decorator to mark a property as the children relation in a tree entity.
  *
@@ -9768,7 +10200,7 @@ declare function TreeParent(): <T, V>(_value: undefined, context: ClassFieldDeco
  * children?: Category[];
  * ```
  */
-declare function TreeChildren(): <T, V>(_value: undefined, context: ClassFieldDecoratorContext<T, V>) => void;
+declare function TreeChildren(): (targetOrValue: unknown, contextOrProperty: unknown) => void;
 /**
  * Synchronizes tree metadata + self-relations for entities using @Tree decorators.
  * Safe to call multiple times (idempotent).
@@ -9850,4 +10282,137 @@ declare function setTreeBounds(entity: object, config: TreeConfig, lft: number,
  */
 declare function setTreeParentId(entity: object, config: TreeConfig, parentId: unknown): void;
 
-export { type AliasRefNode, Alphanumeric, type AnyDomainEvent, type ApiRouteDefinition, type ApplyFilterOptions, type ArithmeticExpressionNode, type TableRef as AstTableRef, AsyncLocalStorage, type AutoCorrectionResult, type AutoTransformResult, type AutoTransformableValidator, BelongsTo, BelongsToMany, type BelongsToManyOptions, type BelongsToManyRelation, type BelongsToOptions, type BelongsToReference, type BelongsToReferenceApi, type BelongsToRelation, type BetweenExpressionNode, BigIntTypeStrategy, type BinaryExpressionNode, BinaryTypeStrategy, type BitwiseExpressionNode, type BooleanFilter, BooleanTypeStrategy, CEP, CNPJ, CPF, type CacheCapabilities, type CacheInvalidator, type CacheOptions, type CacheProvider, type CacheReader, type CacheState, type CacheStrategy, type CacheWriter, type CallProcedureOptions, Capitalize, 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 ComponentOptions, type ComponentReference, type CompositeTransformer, ConflictBuilder, ConstructorMaterializationStrategy, type ValidationResult as CountryValidationResult, type CountryValidator, type CountryValidatorFactory, type CreateDto, type CreateTediousClientOptions, DEFAULT_TREE_CONFIG, type DatabaseCheck, type DatabaseColumn, type DatabaseIndex, type DatabaseSchema, type DatabaseTable, type DatabaseView, type DateFilter, DateTimeTypeStrategy, type DbExecutor, type DbExecutorFactory, DecimalTypeStrategy, type DecoratedEntityInstance, DefaultBelongsToReference, DefaultCacheStrategy, DefaultEntityMaterializer, DefaultHasManyCollection, DefaultManyToManyCollection, DefaultTypeStrategy, type DefaultValue, DeleteQueryBuilder, type DialectName, type DomainEvent, DomainEventBus, type DomainEventHandler, type Dto, type Duration, Email, Entity, type EntityContext, type EntityInstance, type EntityMaterializationStrategy, type EntityMaterializer, type EntityOptions, type PrimaryKey$1 as EntityPrimaryKey, EntityStatus, type ExecuteFilteredPagedOptions, type ExecutionContext, type ExecutionPayload, type ExistsExpressionNode, type ExpressionNode, type ExpressionVisitor, type FieldFilter, type FilterOperator, type FilterValue, type FindChildrenOptions, type FindPathOptions, 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, IntegerTypeStrategy, InterceptorPipeline, type IntrospectOptions, type InvalidationStrategy, type JsonArray, type JsonObject, type JsonPathNode, type JsonValue, type Jsonify, type JsonifyScalar, KeyvCacheAdapter, Length, type LiteralNode, type LiteralValue, type LogicalExpressionNode, Lower, type ManyToManyCollection, MemoryCacheAdapter, type MoveOptions, type MssqlClientLike, MySqlDialect, type MysqlClientLike, type NestedDtoOptions, type NestedSetBounds, type NestedSetRow, NestedSetStrategy, type NodeWithPk, type NullExpressionNode, type NumberFilter, type OpenApiComponent, type OpenApiDialect, type OpenApiDocument, type OpenApiDocumentInfo, type OpenApiDocumentOptions, type OpenApiOperation, type OpenApiParameter, type OpenApiParameterObject, type OpenApiResponseObject, type OpenApiSchema, type OpenApiType, type OperandNode, type OperandVisitor, Orm, type OrmCacheOptions, type OrmDomainEvent, type OrmInterceptor, type OrmOptions, OrmSession, type OrmSessionOptions, type PagedResponse, type PaginatedResult, type PaginationParams, type PatchGraphInputPayload, Pattern, Pool, type PoolAdapter, type PoolLease, type PoolOptions, type PooledConnectionAdapter, type PostgresClientLike, PostgresDialect, PrimaryKey, type Primitive, ProcedureCallBuilder, type ProcedureCallNode, type ProcedureDirection, type ProcedureExecutionResult, type ProcedureOutOptions, type ProcedureParamNode, type ProcedureRefNode, type PropertySanitizer, type PropertyTransformer, type PropertyValidator, PrototypeMaterializationStrategy, QueryCacheManager, type QueryContext, type QueryInterceptor, type QueryLogEntry, type QueryLogger, type QueryResult, type RawDefaultValue, type RecoverResult, RedisCacheAdapter, type ReferentialAction, type RelationChange, type RelationChangeEntry, type RelationDef, type RelationFilter, type RelationKey$1 as RelationKey, RelationKinds, type RelationMap, type RelationTargetTable, type RelationType, type RenderColumnOptions, STANDARD_COLUMN_TYPES, type SaveGraphInputPayload, type SaveGraphInputScalar, type SaveGraphJsonScalar, type SaveGraphSessionOptions, type ScalarSubqueryNode, type SchemaChange, type SchemaChangeKind, type SchemaDiffOptions, type SchemaGenerateResult, type SchemaIntrospector, type SchemaPlan, SelectQueryBuilder, type SelectQueryInput, type SelectableKeys, type SimpleQueryRunner, type SimpleWhereInput, type Simplify, SqlServerDialect, type SqliteClientLike, SqliteDialect, type StandardColumnType, type StringFilter, StringTypeStrategy, type SynchronizeOptions, type TableDef, type TableHooks, type TableOptions, type TableRef$1 as TableRef, TagIndex, type TargetType, type TediousColumn, type TediousConnectionLike, type TediousModule, type TediousRequest, type TediousRequestCtor, type TediousTypes, type ThreadedNode, Title, type ToJsonOptions, type TrackedEntity, type TransformContext, type TransformerConfig, type TransformerMetadata, Tree, TreeChildren, type TreeColumns, type TreeConfig, type TreeDecoratorOptions, type TreeInsertData, type TreeListEntry, type TreeListOptions, type TreeListSchemaOptions, TreeManager, type TreeManagerOptions, type TreeMetadata, type TreeMoveData, type TreeNode, type TreeNodeResult, type TreeNodeResultSchemaOptions, type TreeNodeSchemaOptions, TreeParent, type TreeQuery, type TreeScope, type TreeValidationResult, Trim, TypeMappingService, type TypeMappingStrategy, TypeScriptGenerator, type TypedExpression, type TypedLike, type UpdateDto, UpdateQueryBuilder, Upper, UuidTypeStrategy, type ValidationOptions, type ValidationResult$1 as ValidationResult, type ValidatorFactoryOptions, type ValueOperandInput, type WhereInput, type WindowFunctionNode, type WithRelations, abs, acos, add, addDomainEvent, addEntityRelation, addRelation, age, aliasRef, and, applyFilter, applyNullability, arrayAppend, asType, ascii, asin, atan, atan2, avg, belongsTo, belongsToMany, between, bitAnd, bitLength, bitOr, bitXor, bootstrapEntities, buildFilterExpression, buildScopeConditions, calculateRowDepths, calculateTotalPages, callProcedure, canonicalizeSchema, caseWhen, cast, cbrt, ceil, ceiling, char, charLength, chr, clearExpressionDispatchers, clearOperandDispatchers, coalesce, col, collate, columnOperand, columnToFilterSchema, columnToOpenApiSchema, columnTypeToOpenApiFormat, columnTypeToOpenApiType, computePaginationMetadata, computeSchemaHash, concat, concatWs, correlateBy, cos, cot, count, countAll, createApiComponentsSection, createDeterministicNamingState, createDtoToOpenApiSchema, createEntityFromRow, createEntityProxy, createExecutorFromQueryRunner, createMssqlExecutor, createMysqlExecutor, createPooledExecutorFactory, createPostgresExecutor, createQueryLoggingExecutor, createRef, createSqliteExecutor, createTediousExecutor, createTediousMssqlClient, createTreeManager, currentDate, currentTime, dateAdd, dateDiff, dateFormat, dateSub, dateTrunc, day, dayOfWeek, deepCloneSchema, defineTable, degrees, deleteFrom, denseRank, diffSchema, div, dtoToOpenApiSchema, endOfMonth, entityRef, entityRefs, eq, esel, exclude, executeFilteredPaged, executeHydrated, executeHydratedPlain, executeHydratedPlainWithContexts, executeHydratedWithContexts, executeProcedureAst, executeSchemaSql, executeSchemaSqlFor, exists, exp, extract, extractReusableSchemas, extractScopeValues, firstValue, floor, formatDuration, formatTreeList, fromUnixTime, generateComponentSchemas, generateCreateTableSql, generateOpenApiDocument, generateRelationComponents, generateSchemaSql, generateSchemaSqlFor, generateTreeComponents, getColumn, getColumnMap, getColumnType, getDateKind, getDecoratorMetadata, getDeterministicComponentName, getOpenApiVersionForDialect, getRegisteredValidators, getSchemaIntrospector, getTableDefFromEntity, getTreeBounds, getTreeColumns, getTreeConfig, getTreeMetadata, getTreeParentId, greatest, groupConcat, gt, gte, hasMany, hasNextPage as hasNextPageMeta, hasOne, hasPrevPage as hasPrevPageMeta, hasTreeBehavior, hasValidator, hour, hydrateRows, ifNull, inList, inSubquery, initcap, insertInto, instr, introspectSchema, isCaseExpressionNode, isCastExpressionNode, isCollateExpressionNode, isComponentReference, isExpressionSelectionNode, isFunctionNode, isNotNull, isNull, isNullableColumn, isOperandNode, isTableDef, isTreeConfig, isValidDuration, 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, mapFields, materializeAs, max, md5, mergeSchemas, min, minute, mod, month, mul, neq, nestedDtoToOpenApiSchema, nestedWhereInputToOpenApiSchema, normalizeColumnType, notBetween, notExists, notInList, notInSubquery, notLike, now, ntile, nullif, octetLength, or, outerRef, pagedResponseToOpenApiSchema, paginationParamsSchema, parameterToRef, parseDuration, payloadResultSets, pi, pick, position, pow, power, quarter, radians, rand, random, rank, registerExpressionDispatcher, registerOperandDispatcher, registerSchemaIntrospector, registerValidator, relationFilterToOpenApiSchema, relationLoaderCache, renderColumnDefinition, renderTypeWithArgs, repeat, replace, replaceWithRefs, resolveTreeConfig, resolveValidator, responseToRef, reverse, right, round, rowNumber, rowsToQueryResult, rpad, rtrim, schemaToJson, schemaToRef, second, sel, selectFrom, selectFromEntity, setRelations, setTreeBounds, setTreeMetadata, setTreeParentId, sha1, sha2, shiftLeft, shiftRight, sign, sin, space, sqrt, stddev, sub, substr, sum, syncTreeEntityMetadata, synchronizeSchema, tableRef, tan, threadResults, threadedNodeToOpenApiSchema, toColumnRef, toExecutionPayload, toPagedResponse, toPagedResponseBuilder, toPaginationParams, toResponse, toResponseBuilder, toTableRef, treeEntityRegistry, treeListEntryToOpenApiSchema, treeNodeResultToOpenApiSchema, treeNodeToOpenApiSchema, treeQuery, trim, trunc, truncate, typeMappingService, unixTimestamp, update, updateDtoToOpenApiSchema, updateDtoWithRelationsToOpenApiSchema, upper, utcNow, validateTreeTable, valueToOperand, variance, visitExpression, visitOperand, weekOfYear, whereInputToOpenApiSchema, whereInputWithRelationsToOpenApiSchema, windowFunction, withDefaults, withDefaultsBuilder, year };
+type BulkConcurrency = 'sequential' | number;
+interface BulkResult {
+    processedRows: number;
+    chunksExecuted: number;
+    returning: Record<string, unknown>[];
+    chunkTimings?: number[];
+    metadata?: BulkResultMetadata;
+}
+interface BulkResultMetadata {
+    strategy: 'individual' | 'batch' | 'whereIn';
+    dialect: string;
+    hasReturningSupport: boolean;
+}
+interface BulkBaseOptions {
+    chunkSize?: number;
+    concurrency?: BulkConcurrency;
+    transactional?: boolean;
+    timing?: boolean;
+    onChunkComplete?: (info: ChunkCompleteInfo) => void | Promise<void>;
+}
+interface ChunkCompleteInfo {
+    chunkIndex: number;
+    totalChunks: number;
+    rowsInChunk: number;
+    elapsedMs: number;
+}
+type InsertRow = Record<string, ValueOperandInput>;
+interface BulkInsertOptions extends BulkBaseOptions {
+    returning?: boolean | ColumnDef[];
+    onConflict?: UpsertClause;
+}
+interface BulkUpsertOptions extends BulkInsertOptions {
+    conflictColumns?: string[];
+    updateColumns?: string[];
+}
+type UpdateRow = Record<string, ValueOperandInput>;
+interface BulkUpdateOptions extends BulkBaseOptions {
+    by?: string | string[];
+    where?: ExpressionNode;
+    returning?: boolean | ColumnDef[];
+}
+interface BulkDeleteOptions extends BulkBaseOptions {
+    by?: string;
+    where?: ExpressionNode;
+}
+interface ChunkOutcome {
+    processedRows: number;
+    returning: Record<string, unknown>[];
+    elapsedMs: number;
+}
+
+interface BulkExecutionContext {
+    readonly session: OrmSession;
+    readonly executionContext: ExecutionContext;
+    readonly dialect: Dialect;
+    readonly supportsReturning: boolean;
+}
+
+interface BulkExecutorOptions extends BulkBaseOptions {
+    chunkSize?: number;
+    concurrency?: 'sequential' | number;
+    transactional?: boolean;
+    timing?: boolean;
+    onChunkComplete?: (info: {
+        chunkIndex: number;
+        totalChunks: number;
+        rowsInChunk: number;
+        elapsedMs: number;
+    }) => void | Promise<void>;
+}
+declare abstract class BulkBaseExecutor<TOptions extends BulkExecutorOptions> {
+    protected readonly session: OrmSession;
+    protected readonly table: TableDef;
+    protected readonly ctx: BulkExecutionContext;
+    protected readonly options: TOptions;
+    protected readonly chunks: unknown[][];
+    protected readonly totalChunks: number;
+    constructor(session: OrmSession, table: TableDef, rows: unknown[], options?: TOptions);
+    protected abstract executeChunk(chunk: unknown[], chunkIndex: number): Promise<ChunkOutcome>;
+    execute(): Promise<BulkResult>;
+}
+
+interface InsertExecutorOptions extends BulkExecutorOptions {
+    returning?: boolean | ColumnDef[];
+    onConflict?: UpsertClause;
+}
+declare class BulkInsertExecutor extends BulkBaseExecutor<InsertExecutorOptions> {
+    constructor(session: OrmSession, table: TableDef, rows: InsertRow[], options?: BulkInsertOptions);
+    protected executeChunk(chunk: InsertRow[], chunkIndex: number): Promise<ChunkOutcome>;
+}
+declare function bulkInsert<TTable extends TableDef>(session: OrmSession, table: TTable, rows: InsertRow[], options?: BulkInsertOptions): Promise<BulkResult>;
+
+interface UpdateExecutorOptions extends BulkExecutorOptions {
+    by?: string | string[];
+    where?: ExpressionNode;
+    returning?: boolean | ColumnDef[];
+}
+declare class BulkUpdateExecutor extends BulkBaseExecutor<UpdateExecutorOptions> {
+    private readonly byColumns;
+    constructor(session: OrmSession, table: TableDef, rows: UpdateRow[], options?: BulkUpdateOptions);
+    protected executeChunk(chunk: UpdateRow[], chunkIndex: number): Promise<ChunkOutcome>;
+}
+declare function bulkUpdate<TTable extends TableDef>(session: OrmSession, table: TTable, rows: UpdateRow[], options?: BulkUpdateOptions): Promise<BulkResult>;
+declare function bulkUpdateWhere<TTable extends TableDef>(session: OrmSession, table: TTable, ids: ValueOperandInput[], set: Record<string, ValueOperandInput>, options?: Omit<BulkUpdateOptions, 'by' | 'returning'> & {
+    by?: string;
+    returning?: boolean | ColumnDef[];
+}): Promise<BulkResult>;
+
+interface DeleteExecutorOptions extends BulkExecutorOptions {
+    by?: string;
+    where?: ExpressionNode;
+}
+declare class BulkDeleteExecutor extends BulkBaseExecutor<DeleteExecutorOptions> {
+    private readonly byColumnName;
+    constructor(session: OrmSession, table: TableDef, ids: ValueOperandInput[], options?: BulkDeleteOptions);
+    protected executeChunk(chunk: ValueOperandInput[], chunkIndex: number): Promise<ChunkOutcome>;
+}
+declare function bulkDelete<TTable extends TableDef>(session: OrmSession, table: TTable, ids: ValueOperandInput[], options?: BulkDeleteOptions): Promise<BulkResult>;
+declare function bulkDeleteWhere<TTable extends TableDef>(session: OrmSession, table: TTable, where: ExpressionNode, options?: Pick<BulkDeleteOptions, 'transactional'>): Promise<BulkResult>;
+
+interface UpsertExecutorOptions extends BulkExecutorOptions {
+    conflictColumns?: string[];
+    updateColumns?: string[];
+    returning?: boolean | ColumnDef[];
+}
+declare class BulkUpsertExecutor extends BulkBaseExecutor<UpsertExecutorOptions> {
+    private readonly conflictTargetNodes;
+    private readonly updateColumns;
+    constructor(session: OrmSession, table: TableDef, rows: InsertRow[], options?: BulkUpsertOptions);
+    protected executeChunk(chunk: InsertRow[], chunkIndex: number): Promise<ChunkOutcome>;
+}
+declare function bulkUpsert<TTable extends TableDef>(session: OrmSession, table: TTable, rows: InsertRow[], options?: BulkUpsertOptions): Promise<BulkResult>;
+
+export { type AliasRefNode, Alphanumeric, type AnyDomainEvent, type ApiRouteDefinition, type ApplyFilterOptions, type ArithmeticExpressionNode, type TableRef as AstTableRef, AsyncLocalStorage, type AutoCorrectionResult, type AutoTransformResult, type AutoTransformableValidator, BelongsTo, BelongsToMany, type BelongsToManyOptions, type BelongsToManyRelation, type BelongsToOptions, type BelongsToReference, type BelongsToReferenceApi, type BelongsToRelation, type BetterSqlite3ClientLike, type BetterSqlite3Statement, type BetweenExpressionNode, BigIntTypeStrategy, type BinaryExpressionNode, BinaryTypeStrategy, type BitwiseExpressionNode, type BooleanFilter, BooleanTypeStrategy, type BulkBaseOptions, type BulkConcurrency, BulkDeleteExecutor, type BulkDeleteOptions, BulkInsertExecutor, type BulkInsertOptions, type BulkResult, BulkUpdateExecutor, type BulkUpdateOptions, BulkUpsertExecutor, type BulkUpsertOptions, CEP, CNPJ, CPF, type CacheCapabilities, type CacheInvalidator, type CacheOptions, type CacheProvider, type CacheReader, type CacheState, type CacheStrategy, type CacheWriter, type CallProcedureOptions, Capitalize, type CascadeMode, type CaseExpressionNode, type CastExpressionNode, type CheckConstraint, type ChunkCompleteInfo, type ChunkOutcome, type CollateExpressionNode, Column, type ColumnDef, type ColumnDiff, type ColumnInput, type ColumnNode, type ColumnOptions, type ColumnRef, type ColumnToTs, type ColumnType, type ComponentOptions, type ComponentReference, type CompositeTransformer, ConflictBuilder, ConstructorMaterializationStrategy, type ValidationResult as CountryValidationResult, type CountryValidator, type CountryValidatorFactory, type CreateDto, type CreateTediousClientOptions, type CursorPageInfo, type CursorPageOptions, type CursorPageResult, DEFAULT_TREE_CONFIG, type DatabaseCheck, type DatabaseColumn, type DatabaseIndex, type DatabaseSchema, type DatabaseTable, type DatabaseView, type DateFilter, DateTimeTypeStrategy, type DbExecutor, type DbExecutorFactory, DecimalTypeStrategy, type DecoratedEntityInstance, DefaultBelongsToReference, DefaultCacheStrategy, DefaultEntityMaterializer, DefaultHasManyCollection, DefaultManyToManyCollection, DefaultMorphManyCollection, DefaultMorphOneReference, DefaultMorphToReference, DefaultTypeStrategy, type DefaultValue, DeleteQueryBuilder, type DialectName, type DomainEvent, DomainEventBus, type DomainEventHandler, type Dto, type Duration, Email, Entity, type EntityContext, type EntityInstance, type EntityMaterializationStrategy, type EntityMaterializer, type EntityOptions, type PrimaryKey$1 as EntityPrimaryKey, EntityStatus, type ExecuteFilteredPagedOptions, type ExecutionContext, type ExecutionPayload, type ExistsExpressionNode, type ExpressionNode, type ExpressionVisitor, type FieldFilter, type FilterOperator, type FilterValue, type FindChildrenOptions, type FindPathOptions, 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 InsertRow, IntegerTypeStrategy, InterceptorPipeline, type IntrospectOptions, type InvalidationStrategy, type IsDistinctExpressionNode, type JsonArray, type JsonObject, type JsonPathNode, type JsonValue, type Jsonify, type JsonifyScalar, KeyvCacheAdapter, Length, type LiteralNode, type LiteralValue, type LogicalExpressionNode, Lower, type ManyToManyCollection, MemoryCacheAdapter, MorphMany, type MorphManyOptions, type MorphManyRelation, MorphOne, type MorphOneOptions, type MorphOneRelation, MorphTo, type MorphToOptions, type MorphToRelation, type MoveOptions, type MssqlClientLike, MySqlDialect, type MysqlClientLike, type NestedDtoOptions, type NestedSetBounds, type NestedSetRow, NestedSetStrategy, type NodeWithPk, type NotExpressionNode, type NullExpressionNode, type NumberFilter, type OpenApiComponent, type OpenApiDialect, type OpenApiDocument, type OpenApiDocumentInfo, type OpenApiDocumentOptions, type OpenApiOperation, type OpenApiParameter, type OpenApiParameterObject, type OpenApiResponseObject, type OpenApiSchema, type OpenApiType, type OperandNode, type OperandVisitor, Orm, type OrmCacheOptions, type OrmDomainEvent, type OrmInterceptor, type OrmOptions, OrmSession, type OrmSessionOptions, type PagedResponse, type PaginatedResult, type PaginationParams, type PatchGraphInputPayload, Pattern, Pool, type PoolAdapter, type PoolLease, type PoolOptions, type PooledConnectionAdapter, type PostgresClientLike, PostgresDialect, PrimaryKey, type Primitive, ProcedureCallBuilder, type ProcedureCallNode, type ProcedureDirection, type ProcedureExecutionResult, type ProcedureOutOptions, type ProcedureParamNode, type ProcedureRefNode, type PropertySanitizer, type PropertyTransformer, type PropertyValidator, PrototypeMaterializationStrategy, QueryCacheManager, type QueryContext, type QueryInterceptor, type QueryLogEntry, type QueryLogger, type QueryResult, type RawDefaultValue, type RecoverResult, RedisCacheAdapter, type ReferentialAction, type RelationChange, type RelationChangeEntry, type RelationDef, type RelationFilter, type RelationKey$1 as RelationKey, RelationKinds, type RelationMap, type RelationTargetTable, type RelationType, type RenderColumnOptions, STANDARD_COLUMN_TYPES, type SaveGraphInputPayload, type SaveGraphInputScalar, type SaveGraphJsonScalar, type SaveGraphSessionOptions, type ScalarSubqueryNode, type SchemaChange, type SchemaChangeKind, type SchemaDiffOptions, type SchemaGenerateResult, type SchemaIntrospector, type SchemaPlan, SelectQueryBuilder, type SelectQueryInput, type SelectableKeys, type SimpleQueryRunner, type SimpleWhereInput, type Simplify, SqlServerDialect, type SqliteClientLike, SqliteDialect, type StandardColumnType, type StringFilter, StringTypeStrategy, type SynchronizeOptions, type TableDef, type TableHooks, type TableOptions, type TableRef$1 as TableRef, TagIndex, type TargetType, type TediousColumn, type TediousConnectionLike, type TediousModule, type TediousRequest, type TediousRequestCtor, type TediousTypes, type ThreadedNode, Title, type ToJsonOptions, type TrackedEntity, type TransformContext, type TransformerConfig, type TransformerMetadata, Tree, TreeChildren, type TreeColumns, type TreeConfig, type TreeDecoratorOptions, type TreeInsertData, type TreeListEntry, type TreeListOptions, type TreeListSchemaOptions, TreeManager, type TreeManagerOptions, type TreeMetadata, type TreeMoveData, type TreeNode, type TreeNodeResult, type TreeNodeResultSchemaOptions, type TreeNodeSchemaOptions, TreeParent, type TreeQuery, type TreeScope, type TreeValidationResult, Trim, TypeMappingService, type TypeMappingStrategy, TypeScriptGenerator, type TypedExpression, type TypedLike, type UpdateDto, UpdateQueryBuilder, type UpdateRow, Upper, UuidTypeStrategy, type ValidationOptions, type ValidationResult$1 as ValidationResult, type ValidatorFactoryOptions, type ValueOperandInput, type WhereInput, type WindowFunctionNode, type WithRelations, abs, acos, add, addDomainEvent, addEntityRelation, addRelation, age, aliasRef, and, applyFilter, applyNullability, arrayAppend, asType, ascii, asin, atan, atan2, avg, belongsTo, belongsToMany, between, bitAnd, bitLength, bitOr, bitXor, bootstrapEntities, buildFilterExpression, buildScopeConditions, bulkDelete, bulkDeleteWhere, bulkInsert, bulkUpdate, bulkUpdateWhere, bulkUpsert, calculateRowDepths, calculateTotalPages, callProcedure, canonicalizeSchema, caseWhen, cast, cbrt, ceil, ceiling, char, charLength, chr, clearExpressionDispatchers, clearOperandDispatchers, coalesce, col, collate, columnOperand, columnToFilterSchema, columnToOpenApiSchema, columnTypeToOpenApiFormat, columnTypeToOpenApiType, computePaginationMetadata, computeSchemaHash, concat, concatWs, correlateBy, cos, cot, count, countAll, createApiComponentsSection, createBetterSqlite3Executor, createDeterministicNamingState, createDtoToOpenApiSchema, createEntityFromRow, createEntityProxy, createExecutorFromQueryRunner, createMssqlExecutor, createMysqlExecutor, createPooledExecutorFactory, createPostgresExecutor, createQueryLoggingExecutor, createRef, createSqliteExecutor, createTediousExecutor, createTediousMssqlClient, createTreeManager, currentDate, currentTime, dateAdd, dateDiff, dateFormat, dateSub, dateTrunc, day, dayOfWeek, deepCloneSchema, defineTable, degrees, deleteFrom, denseRank, diffSchema, div, dtoToOpenApiSchema, endOfMonth, entityRef, entityRefs, eq, esel, exclude, executeFilteredPaged, executeHydrated, executeHydratedPlain, executeHydratedPlainWithContexts, executeHydratedWithContexts, executeProcedureAst, executeSchemaSql, executeSchemaSqlFor, exists, exp, extract, extractReusableSchemas, extractScopeValues, firstValue, floor, formatDuration, formatTreeList, fromUnixTime, generateComponentSchemas, generateCreateTableSql, generateOpenApiDocument, generateRelationComponents, generateSchemaSql, generateSchemaSqlFor, generateTreeComponents, getColumn, getColumnMap, getColumnType, getDateKind, getDecoratorMetadata, getDeterministicComponentName, getOpenApiVersionForDialect, getRegisteredValidators, getSchemaIntrospector, getTableDefFromEntity, getTreeBounds, getTreeColumns, getTreeConfig, getTreeMetadata, getTreeParentId, greatest, groupConcat, gt, gte, hasMany, hasNextPage as hasNextPageMeta, hasOne, hasPrevPage as hasPrevPageMeta, hasTreeBehavior, hasValidator, hour, hydrateRows, ifNull, inList, inSubquery, initcap, insertInto, instr, introspectSchema, isCaseExpressionNode, isCastExpressionNode, isCollateExpressionNode, isComponentReference, isDistinctFrom, isExpressionSelectionNode, isFunctionNode, isMorphRelation, isNotDistinctFrom, isNotNull, isNull, isNullableColumn, isOperandNode, isSingleTargetRelation, isTableDef, isTreeConfig, isValidDuration, isValueOperandInput, isWindowFunctionNode, jsonArrayAgg, jsonContains, jsonLength, jsonPath, jsonSet, jsonify, lag, lastValue, lead, least, left, length, like, ln, loadBelongsToManyRelation, loadBelongsToRelation, loadHasManyRelation, loadHasOneRelation, loadMorphManyRelation, loadMorphOneRelation, loadMorphToRelation, localTime, localTimestamp, locate, log, log10, log2, logBase, lower, lpad, lt, lte, ltrim, mapFields, materializeAs, max, md5, mergeSchemas, min, minute, mod, month, morphMany, morphOne, morphTo, mul, neq, nestedDtoToOpenApiSchema, nestedWhereInputToOpenApiSchema, normalizeColumnType, not, notBetween, notExists, notInList, notInSubquery, notLike, now, ntile, nullif, octetLength, or, outerRef, pagedResponseToOpenApiSchema, paginationParamsSchema, parameterToRef, parseDuration, payloadResultSets, pi, pick, position, pow, power, quarter, radians, rand, random, rank, registerExpressionDispatcher, registerOperandDispatcher, registerSchemaIntrospector, registerValidator, relationFilterToOpenApiSchema, relationLoaderCache, renderColumnDefinition, renderTypeWithArgs, repeat, replace, replaceWithRefs, resolveTreeConfig, resolveValidator, responseToRef, reverse, right, round, rowNumber, rowsToQueryResult, rpad, rtrim, schemaToJson, schemaToRef, second, sel, selectFrom, selectFromEntity, setRelations, setTreeBounds, setTreeMetadata, setTreeParentId, sha1, sha2, shiftLeft, shiftRight, sign, sin, space, sqrt, stddev, sub, substr, sum, syncTreeEntityMetadata, synchronizeSchema, tableRef, tan, threadResults, threadedNodeToOpenApiSchema, toColumnRef, toExecutionPayload, toPagedResponse, toPagedResponseBuilder, toPaginationParams, toResponse, toResponseBuilder, toTableRef, treeEntityRegistry, treeListEntryToOpenApiSchema, treeNodeResultToOpenApiSchema, treeNodeToOpenApiSchema, treeQuery, trim, trunc, truncate, typeMappingService, unixTimestamp, update, updateDtoToOpenApiSchema, updateDtoWithRelationsToOpenApiSchema, upper, utcNow, validateTreeTable, valueToOperand, variance, visitExpression, visitOperand, weekOfYear, whereInputToOpenApiSchema, whereInputWithRelationsToOpenApiSchema, windowFunction, withDefaults, withDefaultsBuilder, year };