alepha 0.15.0 → 0.15.1

package/dist/orm/index.d.ts

@@ -1,4 +1,4 @@
-import { n as __reExport, t as __exportAll } from "./chunk-DtkW-qnP.js";
+import { n as __reExport, t as __exportAll } from "./chunk-DH6iiROE.js";
 import * as alepha34 from "alepha";
 import { Alepha, AlephaError, KIND, Page, Page as Page$1, PageQuery, PageQuery as PageQuery$1, Primitive, Service, Static, StaticEncode, TBigInt, TInteger, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOptional, TPage, TSchema, TString, TStringOptions, TUnion, TUnsafe, pageQuerySchema, pageSchema } from "alepha";
 import { DateTime, DateTimeProvider } from "alepha/datetime";
@@ -6,7 +6,7 @@ import * as drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
 import { LockConfig, LockStrength, PgColumn, PgColumnBuilderBase, PgDatabase, PgInsertValue, PgSchema, PgSelectBase, PgSequenceOptions, PgTableExtraConfigValue, PgTableWithColumns, PgTransaction, UpdateDeleteAction } from "drizzle-orm/pg-core";
 import * as drizzle_orm0 from "drizzle-orm";
 import { BuildColumns, BuildExtraConfigColumns, SQL, SQLWrapper, sql } from "drizzle-orm";
-import * as alepha_logger3 from "alepha/logger";
+import * as alepha_logger4 from "alepha/logger";
 import * as alepha_lock0 from "alepha/lock";
 import * as pg$1 from "drizzle-orm/sqlite-core";
 import { SQLiteColumnBuilderBase } from "drizzle-orm/sqlite-core";
@@ -73,119 +73,119 @@ declare const updateSchema: <T extends TObject>(schema: T) => TObjectUpdate<T>;
  * ```
  */
 declare const $entity: {
-  <TSchema$1 extends TObject>(options: EntityPrimitiveOptions<TSchema$1>): EntityPrimitive<TSchema$1>;
+  <TSchema extends TObject>(options: EntityPrimitiveOptions<TSchema>): EntityPrimitive<TSchema>;
   [KIND]: typeof EntityPrimitive;
 };
 interface EntityPrimitiveOptions<T extends TObject, Keys = keyof Static<T>> {
   /**
-       * The database table name that will be created for this entity.
-       * If not provided, name will be inferred from the $repository variable name.
-       */
+   * The database table name that will be created for this entity.
+   * If not provided, name will be inferred from the $repository variable name.
+   */
   name: string;
   /**
-       * TypeBox schema defining the table structure and column types.
-       */
+   * TypeBox schema defining the table structure and column types.
+   */
   schema: T;
   /**
-       * Database indexes to create for query optimization.
-       */
+   * Database indexes to create for query optimization.
+   */
   indexes?: (Keys | {
     /**
-             * Single column to index.
-             */
+     * Single column to index.
+     */
     column: Keys;
     /**
-             * Whether this should be a unique index (enforces uniqueness constraint).
-             */
+     * Whether this should be a unique index (enforces uniqueness constraint).
+     */
     unique?: boolean;
     /**
-             * Custom name for the index. If not provided, generates name automatically.
-             */
+     * Custom name for the index. If not provided, generates name automatically.
+     */
     name?: string;
   } | {
     /**
-             * Multiple columns for composite index (order matters for query optimization).
-             */
+     * Multiple columns for composite index (order matters for query optimization).
+     */
     columns: Keys[];
     /**
-             * Whether this should be a unique index (enforces uniqueness constraint).
-             */
+     * Whether this should be a unique index (enforces uniqueness constraint).
+     */
     unique?: boolean;
     /**
-             * Custom name for the index. If not provided, generates name automatically.
-             */
+     * Custom name for the index. If not provided, generates name automatically.
+     */
     name?: string;
   })[];
   /**
-       * Foreign key constraints to maintain referential integrity.
-       */
+   * Foreign key constraints to maintain referential integrity.
+   */
   foreignKeys?: Array<{
     /**
-             * Optional name for the foreign key constraint.
-             */
+     * Optional name for the foreign key constraint.
+     */
     name?: string;
     /**
-             * Local columns that reference the foreign table.
-             */
+     * Local columns that reference the foreign table.
+     */
     columns: Array<keyof Static<T>>;
     /**
-             * Referenced columns in the foreign table.
-             * Must be EntityColumn references from other entities.
-             */
+     * Referenced columns in the foreign table.
+     * Must be EntityColumn references from other entities.
+     */
     foreignColumns: Array<() => EntityColumn<any>>;
   }>;
   /**
-       * Additional table constraints for data validation.
-       *
-       * Constraints enforce business rules at the database level, providing
-       * an additional layer of data integrity beyond application validation.
-       *
-       * **Constraint Types**:
-       * - **Unique constraints**: Prevent duplicate values across columns
-       * - **Check constraints**: Enforce custom validation rules with SQL expressions
-       *
-       * @example
-       * ```ts
-       * constraints: [
-       *   {
-       *     name: "unique_user_email",
-       *     columns: ["email"],
-       *     unique: true
-       *   },
-       *   {
-       *     name: "valid_age_range",
-       *     columns: ["age"],
-       *     check: sql`age >= 0 AND age <= 150`
-       *   },
-       *   {
-       *     name: "unique_user_username_per_tenant",
-       *     columns: ["tenantId", "username"],
-       *     unique: true
-       *   }
-       * ]
-       * ```
-       */
+   * Additional table constraints for data validation.
+   *
+   * Constraints enforce business rules at the database level, providing
+   * an additional layer of data integrity beyond application validation.
+   *
+   * **Constraint Types**:
+   * - **Unique constraints**: Prevent duplicate values across columns
+   * - **Check constraints**: Enforce custom validation rules with SQL expressions
+   *
+   * @example
+   * ```ts
+   * constraints: [
+   *   {
+   *     name: "unique_user_email",
+   *     columns: ["email"],
+   *     unique: true
+   *   },
+   *   {
+   *     name: "valid_age_range",
+   *     columns: ["age"],
+   *     check: sql`age >= 0 AND age <= 150`
+   *   },
+   *   {
+   *     name: "unique_user_username_per_tenant",
+   *     columns: ["tenantId", "username"],
+   *     unique: true
+   *   }
+   * ]
+   * ```
+   */
   constraints?: Array<{
     /**
-             * Columns involved in this constraint.
-             */
+     * Columns involved in this constraint.
+     */
     columns: Array<keyof Static<T>>;
     /**
-             * Optional name for the constraint.
-             */
+     * Optional name for the constraint.
+     */
     name?: string;
     /**
-             * Whether this is a unique constraint.
-             */
+     * Whether this is a unique constraint.
+     */
     unique?: boolean | {};
     /**
-             * SQL expression for check constraint validation.
-             */
+     * SQL expression for check constraint validation.
+     */
     check?: SQL;
   }>;
   /**
-       * Advanced Drizzle ORM configuration for complex table setups.
-       */
+   * Advanced Drizzle ORM configuration for complex table setups.
+   */
   config?: (self: BuildExtraConfigColumns<string, FromSchema<T>, "pg">) => PgTableExtraConfigValue[];
 }
 declare class EntityPrimitive<T extends TObject = TObject> {
@@ -242,8 +242,8 @@ type PgSymbols = {
   [PG_REF]: PgRefOptions;
   [PG_ENUM]: PgEnumOptions;
   /**
-       * @deprecated Use `PG_IDENTITY` instead.
-       */
+   * @deprecated Use `PG_IDENTITY` instead.
+   */
   [PG_SERIAL]: {};
 };
 type PgSymbolKeys = keyof PgSymbols;
@@ -306,416 +306,416 @@ declare class DbEntityNotFoundError extends DbError {
 //#region ../../src/orm/interfaces/FilterOperators.d.ts
 interface FilterOperators<TValue> {
   /**
-       * Test that two values are equal.
-       *
-       * Remember that the SQL standard dictates that
-       * two NULL values are not equal, so if you want to test
-       * whether a value is null, you may want to use
-       * `isNull` instead.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select cars made by Ford
-       * db.select().from(cars)
-       *   .where(eq(cars.make, 'Ford'))
-       * ```
-       *
-       * @see isNull for a way to test equality to NULL.
-       */
+   * Test that two values are equal.
+   *
+   * Remember that the SQL standard dictates that
+   * two NULL values are not equal, so if you want to test
+   * whether a value is null, you may want to use
+   * `isNull` instead.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made by Ford
+   * db.select().from(cars)
+   *   .where(eq(cars.make, 'Ford'))
+   * ```
+   *
+   * @see isNull for a way to test equality to NULL.
+   */
   eq?: TValue;
   /**
-       * Test that two values are not equal.
-       *
-       * Remember that the SQL standard dictates that
-       * two NULL values are not equal, so if you want to test
-       * whether a value is not null, you may want to use
-       * `isNotNull` instead.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select cars not made by Ford
-       * db.select().from(cars)
-       *   .where(ne(cars.make, 'Ford'))
-       * ```
-       *
-       * @see isNotNull for a way to test whether a value is not null.
-       */
+   * Test that two values are not equal.
+   *
+   * Remember that the SQL standard dictates that
+   * two NULL values are not equal, so if you want to test
+   * whether a value is not null, you may want to use
+   * `isNotNull` instead.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars not made by Ford
+   * db.select().from(cars)
+   *   .where(ne(cars.make, 'Ford'))
+   * ```
+   *
+   * @see isNotNull for a way to test whether a value is not null.
+   */
   ne?: TValue;
   /**
-       * Test that the first expression passed is greater than
-       * the second expression.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select cars made after 2000.
-       * db.select().from(cars)
-       *   .where(gt(cars.year, 2000))
-       * ```
-       *
-       * @see gte for greater-than-or-equal
-       */
+   * Test that the first expression passed is greater than
+   * the second expression.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made after 2000.
+   * db.select().from(cars)
+   *   .where(gt(cars.year, 2000))
+   * ```
+   *
+   * @see gte for greater-than-or-equal
+   */
   gt?: TValue;
   /**
-       * Test that the first expression passed is greater than
-       * or equal to the second expression. Use `gt` to
-       * test whether an expression is strictly greater
-       * than another.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select cars made on or after 2000.
-       * db.select().from(cars)
-       *   .where(gte(cars.year, 2000))
-       * ```
-       *
-       * @see gt for a strictly greater-than condition
-       */
+   * Test that the first expression passed is greater than
+   * or equal to the second expression. Use `gt` to
+   * test whether an expression is strictly greater
+   * than another.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made on or after 2000.
+   * db.select().from(cars)
+   *   .where(gte(cars.year, 2000))
+   * ```
+   *
+   * @see gt for a strictly greater-than condition
+   */
   gte?: TValue;
   /**
-       * Test that the first expression passed is less than
-       * the second expression.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select cars made before 2000.
-       * db.select().from(cars)
-       *   .where(lt(cars.year, 2000))
-       * ```
-       *
-       * @see lte for greater-than-or-equal
-       */
+   * Test that the first expression passed is less than
+   * the second expression.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made before 2000.
+   * db.select().from(cars)
+   *   .where(lt(cars.year, 2000))
+   * ```
+   *
+   * @see lte for greater-than-or-equal
+   */
   lt?: TValue;
   /**
-       * Test that the first expression passed is less than
-       * or equal to the second expression.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select cars made before 2000.
-       * db.select().from(cars)
-       *   .where(lte(cars.year, 2000))
-       * ```
-       *
-       * @see lt for a strictly less-than condition
-       */
+   * Test that the first expression passed is less than
+   * or equal to the second expression.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made before 2000.
+   * db.select().from(cars)
+   *   .where(lte(cars.year, 2000))
+   * ```
+   *
+   * @see lt for a strictly less-than condition
+   */
   lte?: TValue;
   /**
-       * Test whether the first parameter, a column or expression,
-       * has a value from a list passed as the second argument.
-       *
-       * ## Throws
-       *
-       * The argument passed in the second array can't be empty:
-       * if an empty is provided, this method will throw.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select cars made by Ford or GM.
-       * db.select().from(cars)
-       *   .where(inArray(cars.make, ['Ford', 'GM']))
-       * ```
-       *
-       * @see notInArray for the inverse of this test
-       */
+   * Test whether the first parameter, a column or expression,
+   * has a value from a list passed as the second argument.
+   *
+   * ## Throws
+   *
+   * The argument passed in the second array can't be empty:
+   * if an empty is provided, this method will throw.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made by Ford or GM.
+   * db.select().from(cars)
+   *   .where(inArray(cars.make, ['Ford', 'GM']))
+   * ```
+   *
+   * @see notInArray for the inverse of this test
+   */
   inArray?: TValue[];
   /**
-       * Test whether the first parameter, a column or expression,
-       * has a value that is not present in a list passed as the
-       * second argument.
-       *
-       * ## Throws
-       *
-       * The argument passed in the second array can't be empty:
-       * if an empty is provided, this method will throw.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select cars made by any company except Ford or GM.
-       * db.select().from(cars)
-       *   .where(notInArray(cars.make, ['Ford', 'GM']))
-       * ```
-       *
-       * @see inArray for the inverse of this test
-       */
+   * Test whether the first parameter, a column or expression,
+   * has a value that is not present in a list passed as the
+   * second argument.
+   *
+   * ## Throws
+   *
+   * The argument passed in the second array can't be empty:
+   * if an empty is provided, this method will throw.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made by any company except Ford or GM.
+   * db.select().from(cars)
+   *   .where(notInArray(cars.make, ['Ford', 'GM']))
+   * ```
+   *
+   * @see inArray for the inverse of this test
+   */
   notInArray?: TValue[];
   /**
-       * Test whether an expression is not NULL. By the SQL standard,
-       * NULL is neither equal nor not equal to itself, so
-       * it's recommended to use `isNull` and `notIsNull` for
-       * comparisons to NULL.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select cars that have been discontinued.
-       * db.select().from(cars)
-       *   .where(isNotNull(cars.discontinuedAt))
-       * ```
-       *
-       * @see isNull for the inverse of this test
-       */
+   * Test whether an expression is not NULL. By the SQL standard,
+   * NULL is neither equal nor not equal to itself, so
+   * it's recommended to use `isNull` and `notIsNull` for
+   * comparisons to NULL.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars that have been discontinued.
+   * db.select().from(cars)
+   *   .where(isNotNull(cars.discontinuedAt))
+   * ```
+   *
+   * @see isNull for the inverse of this test
+   */
   isNotNull?: true;
   /**
-       * Test whether an expression is NULL. By the SQL standard,
-       * NULL is neither equal nor not equal to itself, so
-       * it's recommended to use `isNull` and `notIsNull` for
-       * comparisons to NULL.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select cars that have no discontinuedAt date.
-       * db.select().from(cars)
-       *   .where(isNull(cars.discontinuedAt))
-       * ```
-       *
-       * @see isNotNull for the inverse of this test
-       */
+   * Test whether an expression is NULL. By the SQL standard,
+   * NULL is neither equal nor not equal to itself, so
+   * it's recommended to use `isNull` and `notIsNull` for
+   * comparisons to NULL.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars that have no discontinuedAt date.
+   * db.select().from(cars)
+   *   .where(isNull(cars.discontinuedAt))
+   * ```
+   *
+   * @see isNotNull for the inverse of this test
+   */
   isNull?: true;
   /**
-       * Test whether an expression is between two values. This
-       * is an easier way to express range tests, which would be
-       * expressed mathematically as `x <= a <= y` but in SQL
-       * would have to be like `a >= x AND a <= y`.
-       *
-       * Between is inclusive of the endpoints: if `column`
-       * is equal to `min` or `max`, it will be TRUE.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select cars made between 1990 and 2000
-       * db.select().from(cars)
-       *   .where(between(cars.year, 1990, 2000))
-       * ```
-       *
-       * @see notBetween for the inverse of this test
-       */
+   * Test whether an expression is between two values. This
+   * is an easier way to express range tests, which would be
+   * expressed mathematically as `x <= a <= y` but in SQL
+   * would have to be like `a >= x AND a <= y`.
+   *
+   * Between is inclusive of the endpoints: if `column`
+   * is equal to `min` or `max`, it will be TRUE.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars made between 1990 and 2000
+   * db.select().from(cars)
+   *   .where(between(cars.year, 1990, 2000))
+   * ```
+   *
+   * @see notBetween for the inverse of this test
+   */
   between?: [number, number];
   /**
-       * Test whether an expression is not between two values.
-       *
-       * This, like `between`, includes its endpoints, so if
-       * the `column` is equal to `min` or `max`, in this case
-       * it will evaluate to FALSE.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Exclude cars made in the 1970s
-       * db.select().from(cars)
-       *   .where(notBetween(cars.year, 1970, 1979))
-       * ```
-       *
-       * @see between for the inverse of this test
-       */
+   * Test whether an expression is not between two values.
+   *
+   * This, like `between`, includes its endpoints, so if
+   * the `column` is equal to `min` or `max`, in this case
+   * it will evaluate to FALSE.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Exclude cars made in the 1970s
+   * db.select().from(cars)
+   *   .where(notBetween(cars.year, 1970, 1979))
+   * ```
+   *
+   * @see between for the inverse of this test
+   */
   notBetween?: [number, number];
   /**
-       * Compare a column to a pattern, which can include `%` and `_`
-       * characters to match multiple variations. Including `%`
-       * in the pattern matches zero or more characters, and including
-       * `_` will match a single character.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select all cars with 'Turbo' in their names.
-       * db.select().from(cars)
-       *   .where(like(cars.name, '%Turbo%'))
-       * ```
-       *
-       * @see ilike for a case-insensitive version of this condition
-       */
+   * Compare a column to a pattern, which can include `%` and `_`
+   * characters to match multiple variations. Including `%`
+   * in the pattern matches zero or more characters, and including
+   * `_` will match a single character.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select all cars with 'Turbo' in their names.
+   * db.select().from(cars)
+   *   .where(like(cars.name, '%Turbo%'))
+   * ```
+   *
+   * @see ilike for a case-insensitive version of this condition
+   */
   like?: string;
   /**
-       * The inverse of like - this tests that a given column
-       * does not match a pattern, which can include `%` and `_`
-       * characters to match multiple variations. Including `%`
-       * in the pattern matches zero or more characters, and including
-       * `_` will match a single character.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select all cars that don't have "ROver" in their name.
-       * db.select().from(cars)
-       *   .where(notLike(cars.name, '%Rover%'))
-       * ```
-       *
-       * @see like for the inverse condition
-       * @see notIlike for a case-insensitive version of this condition
-       */
+   * The inverse of like - this tests that a given column
+   * does not match a pattern, which can include `%` and `_`
+   * characters to match multiple variations. Including `%`
+   * in the pattern matches zero or more characters, and including
+   * `_` will match a single character.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select all cars that don't have "ROver" in their name.
+   * db.select().from(cars)
+   *   .where(notLike(cars.name, '%Rover%'))
+   * ```
+   *
+   * @see like for the inverse condition
+   * @see notIlike for a case-insensitive version of this condition
+   */
   notLike?: string;
   /**
-       * Case-insensitively compare a column to a pattern,
-       * which can include `%` and `_`
-       * characters to match multiple variations. Including `%`
-       * in the pattern matches zero or more characters, and including
-       * `_` will match a single character.
-       *
-       * Unlike like, this performs a case-insensitive comparison.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select all cars with 'Turbo' in their names.
-       * db.select().from(cars)
-       *   .where(ilike(cars.name, '%Turbo%'))
-       * ```
-       *
-       * @see like for a case-sensitive version of this condition
-       */
+   * Case-insensitively compare a column to a pattern,
+   * which can include `%` and `_`
+   * characters to match multiple variations. Including `%`
+   * in the pattern matches zero or more characters, and including
+   * `_` will match a single character.
+   *
+   * Unlike like, this performs a case-insensitive comparison.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select all cars with 'Turbo' in their names.
+   * db.select().from(cars)
+   *   .where(ilike(cars.name, '%Turbo%'))
+   * ```
+   *
+   * @see like for a case-sensitive version of this condition
+   */
   ilike?: string;
   /**
-       * The inverse of ilike - this case-insensitively tests that a given column
-       * does not match a pattern, which can include `%` and `_`
-       * characters to match multiple variations. Including `%`
-       * in the pattern matches zero or more characters, and including
-       * `_` will match a single character.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select all cars that don't have "Rover" in their name.
-       * db.select().from(cars)
-       *   .where(notLike(cars.name, '%Rover%'))
-       * ```
-       *
-       * @see ilike for the inverse condition
-       * @see notLike for a case-sensitive version of this condition
-       */
+   * The inverse of ilike - this case-insensitively tests that a given column
+   * does not match a pattern, which can include `%` and `_`
+   * characters to match multiple variations. Including `%`
+   * in the pattern matches zero or more characters, and including
+   * `_` will match a single character.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select all cars that don't have "Rover" in their name.
+   * db.select().from(cars)
+   *   .where(notLike(cars.name, '%Rover%'))
+   * ```
+   *
+   * @see ilike for the inverse condition
+   * @see notLike for a case-sensitive version of this condition
+   */
   notIlike?: string;
   /**
-       * Syntactic sugar for case-insensitive substring matching.
-       * Automatically wraps the value with `%` wildcards on both sides.
-       *
-       * Equivalent to: `ilike: '%value%'`
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select all cars with "Turbo" anywhere in their name.
-       * db.select().from(cars)
-       *   .where({ name: { contains: 'Turbo' } })
-       * // Same as: .where(ilike(cars.name, '%Turbo%'))
-       * ```
-       *
-       * @see ilike for manual pattern matching
-       * @see startsWith for prefix matching
-       * @see endsWith for suffix matching
-       */
+   * Syntactic sugar for case-insensitive substring matching.
+   * Automatically wraps the value with `%` wildcards on both sides.
+   *
+   * Equivalent to: `ilike: '%value%'`
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select all cars with "Turbo" anywhere in their name.
+   * db.select().from(cars)
+   *   .where({ name: { contains: 'Turbo' } })
+   * // Same as: .where(ilike(cars.name, '%Turbo%'))
+   * ```
+   *
+   * @see ilike for manual pattern matching
+   * @see startsWith for prefix matching
+   * @see endsWith for suffix matching
+   */
   contains?: string;
   /**
-       * Syntactic sugar for case-insensitive prefix matching.
-       * Automatically appends a `%` wildcard to the end of the value.
-       *
-       * Equivalent to: `ilike: 'value%'`
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select all cars whose names start with "Ford".
-       * db.select().from(cars)
-       *   .where({ name: { startsWith: 'Ford' } })
-       * // Same as: .where(ilike(cars.name, 'Ford%'))
-       * ```
-       *
-       * @see ilike for manual pattern matching
-       * @see contains for substring matching
-       * @see endsWith for suffix matching
-       */
+   * Syntactic sugar for case-insensitive prefix matching.
+   * Automatically appends a `%` wildcard to the end of the value.
+   *
+   * Equivalent to: `ilike: 'value%'`
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select all cars whose names start with "Ford".
+   * db.select().from(cars)
+   *   .where({ name: { startsWith: 'Ford' } })
+   * // Same as: .where(ilike(cars.name, 'Ford%'))
+   * ```
+   *
+   * @see ilike for manual pattern matching
+   * @see contains for substring matching
+   * @see endsWith for suffix matching
+   */
   startsWith?: string;
   /**
-       * Syntactic sugar for case-insensitive suffix matching.
-       * Automatically prepends a `%` wildcard to the beginning of the value.
-       *
-       * Equivalent to: `ilike: '%value'`
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select all cars whose names end with "Turbo".
-       * db.select().from(cars)
-       *   .where({ name: { endsWith: 'Turbo' } })
-       * // Same as: .where(ilike(cars.name, '%Turbo'))
-       * ```
-       *
-       * @see ilike for manual pattern matching
-       * @see contains for substring matching
-       * @see startsWith for prefix matching
-       */
+   * Syntactic sugar for case-insensitive suffix matching.
+   * Automatically prepends a `%` wildcard to the beginning of the value.
+   *
+   * Equivalent to: `ilike: '%value'`
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select all cars whose names end with "Turbo".
+   * db.select().from(cars)
+   *   .where({ name: { endsWith: 'Turbo' } })
+   * // Same as: .where(ilike(cars.name, '%Turbo'))
+   * ```
+   *
+   * @see ilike for manual pattern matching
+   * @see contains for substring matching
+   * @see startsWith for prefix matching
+   */
   endsWith?: string;
   /**
-       * Test that a column or expression contains all elements of
-       * the list passed as the second argument.
-       *
-       * ## Throws
-       *
-       * The argument passed in the second array can't be empty:
-       * if an empty is provided, this method will throw.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select posts where its tags contain "Typescript" and "ORM".
-       * db.select().from(posts)
-       *   .where(arrayContains(posts.tags, ['Typescript', 'ORM']))
-       * ```
-       *
-       * @see arrayContained to find if an array contains all elements of a column or expression
-       * @see arrayOverlaps to find if a column or expression contains any elements of an array
-       */
+   * Test that a column or expression contains all elements of
+   * the list passed as the second argument.
+   *
+   * ## Throws
+   *
+   * The argument passed in the second array can't be empty:
+   * if an empty is provided, this method will throw.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select posts where its tags contain "Typescript" and "ORM".
+   * db.select().from(posts)
+   *   .where(arrayContains(posts.tags, ['Typescript', 'ORM']))
+   * ```
+   *
+   * @see arrayContained to find if an array contains all elements of a column or expression
+   * @see arrayOverlaps to find if a column or expression contains any elements of an array
+   */
   arrayContains?: TValue;
   /**
-       * Test that the list passed as the second argument contains
-       * all elements of a column or expression.
-       *
-       * ## Throws
-       *
-       * The argument passed in the second array can't be empty:
-       * if an empty is provided, this method will throw.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select posts where its tags contain "Typescript", "ORM" or both,
-       * // but filtering posts that have additional tags.
-       * db.select().from(posts)
-       *   .where(arrayContained(posts.tags, ['Typescript', 'ORM']))
-       * ```
-       *
-       * @see arrayContains to find if a column or expression contains all elements of an array
-       * @see arrayOverlaps to find if a column or expression contains any elements of an array
-       */
+   * Test that the list passed as the second argument contains
+   * all elements of a column or expression.
+   *
+   * ## Throws
+   *
+   * The argument passed in the second array can't be empty:
+   * if an empty is provided, this method will throw.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select posts where its tags contain "Typescript", "ORM" or both,
+   * // but filtering posts that have additional tags.
+   * db.select().from(posts)
+   *   .where(arrayContained(posts.tags, ['Typescript', 'ORM']))
+   * ```
+   *
+   * @see arrayContains to find if a column or expression contains all elements of an array
+   * @see arrayOverlaps to find if a column or expression contains any elements of an array
+   */
   arrayContained?: TValue;
   /**
-       * Test that a column or expression contains any elements of
-       * the list passed as the second argument.
-       *
-       * ## Throws
-       *
-       * The argument passed in the second array can't be empty:
-       * if an empty is provided, this method will throw.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select posts where its tags contain "Typescript", "ORM" or both.
-       * db.select().from(posts)
-       *   .where(arrayOverlaps(posts.tags, ['Typescript', 'ORM']))
-       * ```
-       *
-       * @see arrayContains to find if a column or expression contains all elements of an array
-       * @see arrayContained to find if an array contains all elements of a column or expression
-       */
+   * Test that a column or expression contains any elements of
+   * the list passed as the second argument.
+   *
+   * ## Throws
+   *
+   * The argument passed in the second array can't be empty:
+   * if an empty is provided, this method will throw.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select posts where its tags contain "Typescript", "ORM" or both.
+   * db.select().from(posts)
+   *   .where(arrayOverlaps(posts.tags, ['Typescript', 'ORM']))
+   * ```
+   *
+   * @see arrayContains to find if a column or expression contains all elements of an array
+   * @see arrayContained to find if an array contains all elements of a column or expression
+   */
   arrayOverlaps?: TValue;
 }
 //#endregion
@@ -774,71 +774,71 @@ type PgQueryWhereOrSQL<T extends TObject, Relations extends PgRelationMap<TObjec
 type PgQueryWhereOperators<T extends TObject> = { [Key in keyof Static<T>]?: FilterOperators<Static<T>[Key]> | Static<T>[Key] };
 type PgQueryWhereConditions<T extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = {
   /**
-       * Combine a list of conditions with the `and` operator. Conditions
-       * that are equal `undefined` are automatically ignored.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * db.select().from(cars)
-       *   .where(
-       *     and(
-       *       eq(cars.make, 'Volvo'),
-       *       eq(cars.year, 1950),
-       *     )
-       *   )
-       * ```
-       */
+   * Combine a list of conditions with the `and` operator. Conditions
+   * that are equal `undefined` are automatically ignored.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * db.select().from(cars)
+   *   .where(
+   *     and(
+   *       eq(cars.make, 'Volvo'),
+   *       eq(cars.year, 1950),
+   *     )
+   *   )
+   * ```
+   */
   and?: Array<PgQueryWhereOrSQL<T, Relations>>;
   /**
-       * Combine a list of conditions with the `or` operator. Conditions
-       * that are equal `undefined` are automatically ignored.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * db.select().from(cars)
-       *   .where(
-       *     or(
-       *       eq(cars.make, 'GM'),
-       *       eq(cars.make, 'Ford'),
-       *     )
-       *   )
-       * ```
-       */
+   * Combine a list of conditions with the `or` operator. Conditions
+   * that are equal `undefined` are automatically ignored.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * db.select().from(cars)
+   *   .where(
+   *     or(
+   *       eq(cars.make, 'GM'),
+   *       eq(cars.make, 'Ford'),
+   *     )
+   *   )
+   * ```
+   */
   or?: Array<PgQueryWhereOrSQL<T, Relations>>;
   /**
-       * Negate the meaning of an expression using the `not` keyword.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Select cars _not_ made by GM or Ford.
-       * db.select().from(cars)
-       *   .where(not(inArray(cars.make, ['GM', 'Ford'])))
-       * ```
-       */
+   * Negate the meaning of an expression using the `not` keyword.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Select cars _not_ made by GM or Ford.
+   * db.select().from(cars)
+   *   .where(not(inArray(cars.make, ['GM', 'Ford'])))
+   * ```
+   */
   not?: PgQueryWhereOrSQL<T, Relations>;
   /**
-       * Test whether a subquery evaluates to have any rows.
-       *
-       * ## Examples
-       *
-       * ```ts
-       * // Users whose `homeCity` column has a match in a cities
-       * // table.
-       * db
-       *   .select()
-       *   .from(users)
-       *   .where(
-       *     exists(db.select()
-       *       .from(cities)
-       *       .where(eq(users.homeCity, cities.id))),
-       *   );
-       * ```
-       *
-       * @see notExists for the inverse of this test
-       */
+   * Test whether a subquery evaluates to have any rows.
+   *
+   * ## Examples
+   *
+   * ```ts
+   * // Users whose `homeCity` column has a match in a cities
+   * // table.
+   * db
+   *   .select()
+   *   .from(users)
+   *   .where(
+   *     exists(db.select()
+   *       .from(cities)
+   *       .where(eq(users.homeCity, cities.id))),
+   *   );
+   * ```
+   *
+   * @see notExists for the inverse of this test
+   */
   exists?: SQLWrapper;
 };
 type PgQueryWhereRelations<Relations extends PgRelationMap<TObject> | undefined = undefined> = Relations extends PgRelationMap<TObject> ? { [K in keyof Relations]?: PgQueryWhere<Relations[K]["join"]["schema"], Relations[K]["with"]> } : {};
@@ -947,81 +947,81 @@ interface PgAttrField {
 declare class DatabaseTypeProvider {
   readonly attr: <T extends TSchema, Attr extends PgSymbolKeys>(type: T, attr: Attr, value?: PgSymbols[Attr]) => PgAttr<T, Attr>;
   /**
-       * Creates a primary key with an identity column.
-       */
+   * Creates a primary key with an identity column.
+   */
   readonly identityPrimaryKey: (identity?: PgIdentityOptions, options?: TNumberOptions) => PgAttr<PgAttr<PgAttr<TInteger, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
   /**
-       * Creates a primary key with a big identity column. (default)
-       */
+   * Creates a primary key with a big identity column. (default)
+   */
   readonly bigIdentityPrimaryKey: (identity?: PgIdentityOptions, options?: TNumberOptions) => PgAttr<PgAttr<PgAttr<TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
   /**
-       * Creates a primary key with a UUID column.
-       */
+   * Creates a primary key with a UUID column.
+   */
   readonly uuidPrimaryKey: () => PgAttr<PgAttr<TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
   /**
-       * Creates a primary key for a given type. Supports:
-       * - `t.integer()` -> PG INT (default)
-       * - `t.bigint()` -> PG BIGINT
-       * - `t.uuid()` -> PG UUID
-       */
+   * Creates a primary key for a given type. Supports:
+   * - `t.integer()` -> PG INT (default)
+   * - `t.bigint()` -> PG BIGINT
+   * - `t.uuid()` -> PG UUID
+   */
   primaryKey(): PgAttr<PgAttr<TInteger, PgPrimaryKey>, PgDefault>;
   primaryKey(type: TString, options?: TStringOptions): PgAttr<PgAttr<TString, PgPrimaryKey>, PgDefault>;
   primaryKey(type: TInteger, options?: TNumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TInteger, PgPrimaryKey>, PgDefault>;
   primaryKey(type: TNumber, options?: TNumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TNumber, PgPrimaryKey>, PgDefault>;
   primaryKey(type: TBigInt, options?: TNumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TBigInt, PgPrimaryKey>, PgDefault>;
   /**
-       * Wrap a schema with "default" attribute.
-       * This is used to set a default value for a column in the database.
-       */
+   * Wrap a schema with "default" attribute.
+   * This is used to set a default value for a column in the database.
+   */
   readonly default: <T extends TSchema>(type: T, value?: Static<T>) => PgAttr<T, PgDefault>;
   /**
-       * Creates a column 'version'.
-       *
-       * This is used to track the version of a row in the database.
-       *
-       * You can use it for optimistic concurrency control (OCC) with {@link RepositoryPrimitive#save}.
-       *
-       * @see {@link RepositoryPrimitive#save}
-       * @see {@link PgVersionMismatchError}
-       */
+   * Creates a column 'version'.
+   *
+   * This is used to track the version of a row in the database.
+   *
+   * You can use it for optimistic concurrency control (OCC) with {@link RepositoryPrimitive#save}.
+   *
+   * @see {@link RepositoryPrimitive#save}
+   * @see {@link PgVersionMismatchError}
+   */
   readonly version: (options?: TNumberOptions) => PgAttr<PgAttr<TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
   /**
-       * Creates a column Created At. So just a datetime column with a default value of the current timestamp.
-       */
+   * Creates a column Created At. So just a datetime column with a default value of the current timestamp.
+   */
   readonly createdAt: (options?: TStringOptions) => PgAttr<PgAttr<TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
   /**
-       * Creates a column Updated At. Like createdAt, but it is updated on every update of the row.
-       */
+   * Creates a column Updated At. Like createdAt, but it is updated on every update of the row.
+   */
   readonly updatedAt: (options?: TStringOptions) => PgAttr<PgAttr<TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
   /**
-       * Creates a column Deleted At for soft delete functionality.
-       * This is used to mark rows as deleted without actually removing them from the database.
-       * The column is nullable - NULL means not deleted, timestamp means deleted.
-       */
+   * Creates a column Deleted At for soft delete functionality.
+   * This is used to mark rows as deleted without actually removing them from the database.
+   * The column is nullable - NULL means not deleted, timestamp means deleted.
+   */
   readonly deletedAt: (options?: TStringOptions) => PgAttr<alepha34.TOptional<TString>, typeof PG_DELETED_AT>;
   /**
-       * Creates a Postgres ENUM type.
-       *
-       * > By default, `t.enum()` is mapped to a TEXT column in Postgres.
-       * > Using this method, you can create a real ENUM type in the database.
-       *
-       * @example
-       * ```ts
-       * const statusEnum = pg.enum(["pending", "active", "archived"], { name: "status_enum" });
-       * ```
-       */
+   * Creates a Postgres ENUM type.
+   *
+   * > By default, `t.enum()` is mapped to a TEXT column in Postgres.
+   * > Using this method, you can create a real ENUM type in the database.
+   *
+   * @example
+   * ```ts
+   * const statusEnum = pg.enum(["pending", "active", "archived"], { name: "status_enum" });
+   * ```
+   */
   readonly enum: <T extends string[]>(values: [...T], pgEnumOptions?: PgEnumOptions, typeOptions?: TStringOptions) => PgAttr<TUnsafe<T[number]>, typeof PG_ENUM>;
   /**
-       * Creates a reference to another table or schema. Basically a foreign key.
-       */
+   * Creates a reference to another table or schema. Basically a foreign key.
+   */
   readonly ref: <T extends TSchema>(type: T, ref: () => any, actions?: {
     onUpdate?: UpdateDeleteAction$1;
     onDelete?: UpdateDeleteAction$1;
   }) => PgAttr<T, PgRef>;
   /**
-       * Creates a page schema for a given object schema.
-       * It's used by {@link Repository#paginate} method.
-       */
+   * Creates a page schema for a given object schema.
+   * It's used by {@link Repository#paginate} method.
+   */
   readonly page: <T extends TObject>(resource: T, options?: TObjectOptions) => TPage<T>;
 }
 /**
@@ -1063,8 +1063,8 @@ declare const $sequence: {
 };
 interface SequencePrimitiveOptions extends PgSequenceOptions {
   /**
-       * The name of the sequence. If not provided, the property key will be used.
-       */
+   * The name of the sequence. If not provided, the property key will be used.
+   */
   name?: string;
   provider?: DatabaseProvider;
 }
@@ -1104,72 +1104,72 @@ interface TableConfigBuilders<TConfig> {
  */
 declare abstract class ModelBuilder {
   /**
-       * Build a table from an entity primitive.
-       */
+   * Build a table from an entity primitive.
+   */
   abstract buildTable(entity: EntityPrimitive, options: {
     tables: Map<string, unknown>;
     enums: Map<string, unknown>;
     schema: string;
   }): void;
   /**
-       * Build a sequence from a sequence primitive.
-       */
+   * Build a sequence from a sequence primitive.
+   */
   abstract buildSequence(sequence: SequencePrimitive, options: {
     sequences: Map<string, unknown>;
     schema: string;
   }): void;
   /**
-       * Convert camelCase to snake_case for column names.
-       */
+   * Convert camelCase to snake_case for column names.
+   */
   protected toColumnName(str: string): string;
   /**
-       * Build the table configuration function for any database.
-       * This includes indexes, foreign keys, constraints, and custom config.
-       *
-       * @param entity - The entity primitive
-       * @param builders - Database-specific builder functions
-       * @param tableResolver - Function to resolve entity references to table columns
-       * @param customConfigHandler - Optional handler for custom config
-       */
+   * Build the table configuration function for any database.
+   * This includes indexes, foreign keys, constraints, and custom config.
+   *
+   * @param entity - The entity primitive
+   * @param builders - Database-specific builder functions
+   * @param tableResolver - Function to resolve entity references to table columns
+   * @param customConfigHandler - Optional handler for custom config
+   */
   protected buildTableConfig<TConfig, TSelf>(entity: EntityPrimitive, builders: TableConfigBuilders<TConfig>, tableResolver?: (entityName: string) => any, customConfigHandler?: (config: any, self: TSelf) => TConfig[]): ((self: TSelf) => TConfig[]) | undefined;
 }
 //#endregion
 //#region ../../src/orm/providers/DrizzleKitProvider.d.ts
 declare class DrizzleKitProvider {
-  protected readonly log: alepha_logger3.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected readonly alepha: Alepha;
   /**
-       * Synchronize database with current schema definitions.
-       *
-       * In development mode, it will generate and execute migrations based on the current state.
-       * In testing mode, it will generate migrations from scratch without applying them.
-       *
-       * Does nothing in production mode, you must handle migrations manually.
-       */
+   * Synchronize database with current schema definitions.
+   *
+   * In development mode, it will generate and execute migrations based on the current state.
+   * In testing mode, it will generate migrations from scratch without applying them.
+   *
+   * Does nothing in production mode, you must handle migrations manually.
+   */
   synchronize(provider: DatabaseProvider): Promise<void>;
   /**
-       * Mostly used for testing purposes. You can generate SQL migration statements without executing them.
-       */
+   * Mostly used for testing purposes. You can generate SQL migration statements without executing them.
+   */
   generateMigration(provider: DatabaseProvider, prevSnapshot?: any): Promise<{
     statements: string[];
     models: Record<string, unknown>;
     snapshot?: any;
   }>;
   /**
-       * Load all tables, enums, sequences, etc. from the provider's repositories.
-       */
+   * Load all tables, enums, sequences, etc. from the provider's repositories.
+   */
   getModels(provider: DatabaseProvider): Record<string, unknown>;
   /**
-       * Load the migration snapshot from the database.
-       */
+   * Load the migration snapshot from the database.
+   */
   protected loadDevMigrations(provider: DatabaseProvider): Promise<DevMigrations | undefined>;
   protected saveDevMigrations(provider: DatabaseProvider, curr: Record<string, any>, devMigrations?: DevMigrations): Promise<void>;
   protected executeStatements(statements: string[], provider: DatabaseProvider, catchErrors?: boolean): Promise<void>;
   protected createSchemaIfNotExists(provider: DatabaseProvider, schemaName: string): Promise<void>;
   /**
-       * Try to load the official Drizzle Kit API.
-       * If not available, fallback to the local kit import.
-       */
+   * Try to load the official Drizzle Kit API.
+   * If not available, fallback to the local kit import.
+   */
   importDrizzleKit(): typeof DrizzleKit;
 }
 declare const devMigrationsSchema: alepha34.TObject<{
@@ -1184,7 +1184,7 @@ type DevMigrations = Static<typeof devMigrationsSchema>;
 type SQLLike = SQLWrapper | string;
 declare abstract class DatabaseProvider {
   protected readonly alepha: Alepha;
-  protected readonly log: alepha_logger3.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected abstract readonly builder: ModelBuilder;
   protected abstract readonly kit: DrizzleKitProvider;
   abstract readonly db: PgDatabase<any>;
@@ -1202,39 +1202,39 @@ declare abstract class DatabaseProvider {
   abstract execute(statement: SQLLike): Promise<Record<string, unknown>[]>;
   run<T extends TObject>(statement: SQLLike, schema: T): Promise<Array<Static<T>>>;
   /**
-       * Get migrations folder path - can be overridden
-       */
+   * Get migrations folder path - can be overridden
+   */
   protected getMigrationsFolder(): string;
   /**
-       * Base migration orchestration - handles environment logic
-       */
+   * Base migration orchestration - handles environment logic
+   */
   migrate(): Promise<void>;
   /**
-       * Production: run migrations from folder
-       */
+   * Production: run migrations from folder
+   */
   protected runProductionMigration(migrationsFolder: string): Promise<void>;
   /**
-       * Test: always synchronize
-       */
+   * Test: always synchronize
+   */
   protected runTestMigration(): Promise<void>;
   /**
-       * Development: default to synchronize (can be overridden)
-       */
+   * Development: default to synchronize (can be overridden)
+   */
   protected runDevelopmentMigration(migrationsFolder: string): Promise<void>;
   /**
-       * Common synchronization with error handling
-       */
+   * Common synchronization with error handling
+   */
   protected synchronizeSchema(): Promise<void>;
   /**
-       * Provider-specific migration execution
-       * MUST be implemented by each provider
-       */
+   * Provider-specific migration execution
+   * MUST be implemented by each provider
+   */
   protected abstract executeMigrations(migrationsFolder: string): Promise<void>;
   /**
-       * For testing purposes, generate a unique schema name.
-       * The schema name will be generated based on the current date and time.
-       * It will be in the format of `test_YYYYMMDD_HHMMSS_randomSuffix`.
-       */
+   * For testing purposes, generate a unique schema name.
+   * The schema name will be generated based on the current date and time.
+   * It will be in the format of `test_YYYYMMDD_HHMMSS_randomSuffix`.
+   */
   protected generateTestSchemaName(): string;
 }
 //#endregion
@@ -1242,8 +1242,8 @@ declare abstract class DatabaseProvider {
 declare class QueryManager {
   protected readonly alepha: Alepha;
   /**
-       * Convert a query object to a SQL query.
-       */
+   * Convert a query object to a SQL query.
+   */
   toSQL(query: PgQueryWhereOrSQL<TObject>, options: {
     schema: TObject;
     col: (key: string) => PgColumn;
@@ -1251,22 +1251,22 @@ declare class QueryManager {
     dialect: "postgresql" | "sqlite";
   }): SQL | undefined;
   /**
-       * Check if an object has any filter operator properties.
-       */
+   * Check if an object has any filter operator properties.
+   */
   protected hasFilterOperatorProperties(obj: any): boolean;
   /**
-       * Map a filter operator to a SQL query.
-       */
+   * Map a filter operator to a SQL query.
+   */
   mapOperatorToSql(operator: FilterOperators<any> | any, column: PgColumn, columnSchema?: TObject, columnName?: string, dialect?: "postgresql" | "sqlite"): SQL | undefined;
   /**
-       * Parse pagination sort string to orderBy format.
-       * Format: "firstName,-lastName" -> [{ column: "firstName", direction: "asc" }, { column: "lastName", direction: "desc" }]
-       * - Columns separated by comma
-       * - Prefix with '-' for DESC direction
-       *
-       * @param sort Pagination sort string
-       * @returns OrderBy array or single object
-       */
+   * Parse pagination sort string to orderBy format.
+   * Format: "firstName,-lastName" -> [{ column: "firstName", direction: "asc" }, { column: "lastName", direction: "desc" }]
+   * - Columns separated by comma
+   * - Prefix with '-' for DESC direction
+   *
+   * @param sort Pagination sort string
+   * @returns OrderBy array or single object
+   */
   parsePaginationSort(sort: string): Array<{
     column: string;
     direction: "asc" | "desc";
@@ -1275,30 +1275,30 @@ declare class QueryManager {
     direction: "asc" | "desc";
   };
   /**
-       * Normalize orderBy parameter to array format.
-       * Supports 3 modes:
-       * 1. String: "name" -> [{ column: "name", direction: "asc" }]
-       * 2. Object: { column: "name", direction: "desc" } -> [{ column: "name", direction: "desc" }]
-       * 3. Array: [{ column: "name" }, { column: "age", direction: "desc" }] -> normalized array
-       *
-       * @param orderBy The orderBy parameter
-       * @returns Normalized array of order by clauses
-       */
+   * Normalize orderBy parameter to array format.
+   * Supports 3 modes:
+   * 1. String: "name" -> [{ column: "name", direction: "asc" }]
+   * 2. Object: { column: "name", direction: "desc" } -> [{ column: "name", direction: "desc" }]
+   * 3. Array: [{ column: "name" }, { column: "age", direction: "desc" }] -> normalized array
+   *
+   * @param orderBy The orderBy parameter
+   * @returns Normalized array of order by clauses
+   */
   normalizeOrderBy(orderBy: any): Array<{
     column: string;
     direction: "asc" | "desc";
   }>;
   /**
-       * Create a pagination object.
-       *
-       * @deprecated Use `createPagination` from alepha instead.
-       * This method now delegates to the framework-level helper.
-       *
-       * @param entities The entities to paginate.
-       * @param limit The limit of the pagination.
-       * @param offset The offset of the pagination.
-       * @param sort Optional sort metadata to include in response.
-       */
+   * Create a pagination object.
+   *
+   * @deprecated Use `createPagination` from alepha instead.
+   * This method now delegates to the framework-level helper.
+   *
+   * @param entities The entities to paginate.
+   * @param limit The limit of the pagination.
+   * @param offset The offset of the pagination.
+   * @param sort Optional sort metadata to include in response.
+   */
   createPagination<T>(entities: T[], limit?: number, offset?: number, sort?: Array<{
     column: string;
     direction: "asc" | "desc";
@@ -1315,20 +1315,20 @@ interface PgJoin {
 //#region ../../src/orm/services/PgRelationManager.d.ts
 declare class PgRelationManager {
   /**
-       * Recursively build joins for the query builder based on the relations map
-       */
+   * Recursively build joins for the query builder based on the relations map
+   */
   buildJoins(provider: DatabaseProvider, builder: PgSelectBase<any, any, any>, joins: Array<PgJoin>, withRelations: PgRelationMap<TObject>, table: PgTableWithColumns<any>, parentKey?: string): void;
   /**
-       * Map a row with its joined relations based on the joins definition
-       */
+   * Map a row with its joined relations based on the joins definition
+   */
   mapRowWithJoins(record: Record<string, unknown>, row: Record<string, unknown>, schema: TObject, joins: PgJoin[], parentKey?: string): Record<string, unknown>;
   /**
-       * Check if all values in an object are null (indicates a left join with no match)
-       */
+   * Check if all values in an object are null (indicates a left join with no match)
+   */
   private isAllNull;
   /**
-       * Build a schema that includes all join properties recursively
-       */
+   * Build a schema that includes all join properties recursively
+   */
   buildSchemaWithJoins(baseSchema: TObject, joins: PgJoin[], parentPath?: string): TObject;
 }
 //#endregion
@@ -1336,217 +1336,218 @@ declare class PgRelationManager {
 declare abstract class Repository<T extends TObject> {
   readonly entity: EntityPrimitive<T>;
   readonly provider: DatabaseProvider;
-  protected readonly log: alepha_logger3.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected readonly relationManager: PgRelationManager;
   protected readonly queryManager: QueryManager;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly alepha: Alepha;
+  static of<T extends TObject>(entity: EntityPrimitive<T>, provider?: typeof DatabaseProvider): new () => Repository<T>;
   constructor(entity: EntityPrimitive<T>, provider?: typeof DatabaseProvider);
   /**
-       * Represents the primary key of the table.
-       * - Key is the name of the primary key column.
-       * - Type is the type (TypeBox) of the primary key column.
-       *
-       * ID is mandatory. If the table does not have a primary key, it will throw an error.
-       */
+   * Represents the primary key of the table.
+   * - Key is the name of the primary key column.
+   * - Type is the type (TypeBox) of the primary key column.
+   *
+   * ID is mandatory. If the table does not have a primary key, it will throw an error.
+   */
   get id(): {
     type: TSchema;
     key: keyof T["properties"];
     col: PgColumn;
   };
   /**
-       * Get Drizzle table object.
-       */
+   * Get Drizzle table object.
+   */
   get table(): PgTableWithColumns<SchemaToTableConfig<T>>;
   /**
-       * Get SQL table name. (from Drizzle table object)
-       */
+   * Get SQL table name. (from Drizzle table object)
+   */
   get tableName(): string;
   /**
-       * Getter for the database connection from the database provider.
-       */
+   * Getter for the database connection from the database provider.
+   */
   protected get db(): PgDatabase<any>;
   /**
-       * Execute a SQL query.
-       *
-       * This method allows executing raw SQL queries against the database.
-       * This is by far the easiest way to run custom queries that are not covered by the repository's built-in methods!
-       *
-       * You must use the `sql` tagged template function from Drizzle ORM to create the query. https://orm.drizzle.team/docs/sql
-       *
-       * @example
-       * ```ts
-       * class App {
-       *   repository = $repository({ ... });
-       *   async getAdults() {
-       *     const users = repository.table; // Drizzle table object
-       *     await repository.query(sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
-       *     // or better
-       *     await repository.query((users) => sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
-       *   }
-       * }
-       * ```
-       */
+   * Execute a SQL query.
+   *
+   * This method allows executing raw SQL queries against the database.
+   * This is by far the easiest way to run custom queries that are not covered by the repository's built-in methods!
+   *
+   * You must use the `sql` tagged template function from Drizzle ORM to create the query. https://orm.drizzle.team/docs/sql
+   *
+   * @example
+   * ```ts
+   * class App {
+   *   repository = $repository({ ... });
+   *   async getAdults() {
+   *     const users = repository.table; // Drizzle table object
+   *     await repository.query(sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
+   *     // or better
+   *     await repository.query((users) => sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
+   *   }
+   * }
+   * ```
+   */
   query<R extends TObject = T>(query: SQLLike | ((table: PgTableWithColumns<SchemaToTableConfig<T>>, db: PgDatabase<any>) => SQLLike), schema?: R): Promise<Static<R>[]>;
   /**
-       * Map raw database fields to entity fields. (handles column name differences)
-       */
+   * Map raw database fields to entity fields. (handles column name differences)
+   */
   protected mapRawFieldsToEntity(row: Record<string, unknown>): any;
   /**
-       * Get a Drizzle column from the table by his name.
-       */
+   * Get a Drizzle column from the table by his name.
+   */
   protected col(name: keyof StaticEncode<T>): PgColumn;
   /**
-       * Run a transaction.
-       */
+   * Run a transaction.
+   */
   transaction<T>(transaction: (tx: PgTransaction<any, Record<string, any>, any>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
   /**
-       * Start a SELECT query on the table.
-       */
+   * Start a SELECT query on the table.
+   */
   protected rawSelect(opts?: StatementOptions): drizzle_orm_pg_core0.PgSelectBase<string, Record<string, PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
     [x: string]: unknown;
   }[], {
     [x: string]: PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>;
   }>;
   /**
-       * Start a SELECT DISTINCT query on the table.
-       */
+   * Start a SELECT DISTINCT query on the table.
+   */
   protected rawSelectDistinct(opts?: StatementOptions, columns?: (keyof Static<T>)[]): drizzle_orm_pg_core0.PgSelectBase<string, Record<string, any>, "partial", Record<string, "not-null">, false, never, {
     [x: string]: any;
   }[], {
     [x: string]: any;
   }>;
   /**
-       * Start an INSERT query on the table.
-       */
+   * Start an INSERT query on the table.
+   */
   protected rawInsert(opts?: StatementOptions): drizzle_orm_pg_core0.PgInsertBuilder<PgTableWithColumns<SchemaToTableConfig<T>>, any, false>;
   /**
-       * Start an UPDATE query on the table.
-       */
+   * Start an UPDATE query on the table.
+   */
   protected rawUpdate(opts?: StatementOptions): drizzle_orm_pg_core0.PgUpdateBuilder<PgTableWithColumns<SchemaToTableConfig<T>>, any>;
   /**
-       * Start a DELETE query on the table.
-       */
+   * Start a DELETE query on the table.
+   */
   protected rawDelete(opts?: StatementOptions): drizzle_orm_pg_core0.PgDeleteBase<PgTableWithColumns<SchemaToTableConfig<T>>, any, undefined, undefined, false, never>;
   /**
-       * Create a Drizzle `select` query based on a JSON query object.
-       *
-       * > This method is the base for `find`, `findOne`, `findById`, and `paginate`.
-       */
+   * Create a Drizzle `select` query based on a JSON query object.
+   *
+   * > This method is the base for `find`, `findOne`, `findById`, and `paginate`.
+   */
   findMany<R extends PgRelationMap<T>>(query?: PgQueryRelations<T, R>, opts?: StatementOptions): Promise<PgStatic<T, R>[]>;
   /**
-       * Find a single entity.
-       */
+   * Find a single entity.
+   */
   findOne<R extends PgRelationMap<T>>(query: Pick<PgQueryRelations<T, R>, "with" | "where">, opts?: StatementOptions): Promise<PgStatic<T, R>>;
   /**
-       * Find entities with pagination.
-       *
-       * It uses the same parameters as `find()`, but adds pagination metadata to the response.
-       *
-       * > Pagination CAN also do a count query to get the total number of elements.
-       */
+   * Find entities with pagination.
+   *
+   * It uses the same parameters as `find()`, but adds pagination metadata to the response.
+   *
+   * > Pagination CAN also do a count query to get the total number of elements.
+   */
   paginate<R extends PgRelationMap<T>>(pagination?: PageQuery$1, query?: PgQueryRelations<T, R>, opts?: StatementOptions & {
     count?: boolean;
   }): Promise<Page$1<PgStatic<T, R>>>;
   /**
-       * Find an entity by ID.
-       *
-       * This is a convenience method for `findOne` with a where clause on the primary key.
-       * If you need more complex queries, use `findOne` instead.
-       */
+   * Find an entity by ID.
+   *
+   * This is a convenience method for `findOne` with a where clause on the primary key.
+   * If you need more complex queries, use `findOne` instead.
+   */
   findById(id: string | number, opts?: StatementOptions): Promise<Static<T>>;
   /**
-       * Helper to create a type-safe query object.
-       */
+   * Helper to create a type-safe query object.
+   */
   createQuery(): PgQuery<T>;
   /**
-       * Helper to create a type-safe where clause.
-       */
+   * Helper to create a type-safe where clause.
+   */
   createQueryWhere(): PgQueryWhere<T>;
   /**
-       * Create an entity.
-       *
-       * @param data The entity to create.
-       * @param opts The options for creating the entity.
-       * @returns The ID of the created entity.
-       */
+   * Create an entity.
+   *
+   * @param data The entity to create.
+   * @param opts The options for creating the entity.
+   * @returns The ID of the created entity.
+   */
   create(data: Static<TObjectInsert<T>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
-       * Create many entities.
-       *
-       * Inserts are batched in chunks of 1000 to avoid hitting database limits.
-       *
-       * @param values The entities to create.
-       * @param opts The statement options.
-       * @returns The created entities.
-       */
+   * Create many entities.
+   *
+   * Inserts are batched in chunks of 1000 to avoid hitting database limits.
+   *
+   * @param values The entities to create.
+   * @param opts The statement options.
+   * @returns The created entities.
+   */
   createMany(values: Array<Static<TObjectInsert<T>>>, opts?: StatementOptions & {
     batchSize?: number;
   }): Promise<Static<T>[]>;
   /**
-       * Find an entity and update it.
-       */
+   * Find an entity and update it.
+   */
   updateOne(where: PgQueryWhereOrSQL<T>, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
-       * Save a given entity.
-       *
-       * @example
-       * ```ts
-       * const entity = await repository.findById(1);
-       * entity.name = "New Name"; // update a field
-       * delete entity.description; // delete a field
-       * await repository.save(entity);
-       * ```
-       *
-       * Difference with `updateById/updateOne`:
-       *
-       * - requires the entity to be fetched first (whole object is expected)
-       * - check pg.version() if present -> optimistic locking
-       * - validate entity against schema
-       * - undefined values will be set to null, not ignored!
-       *
-       * @see {@link DbVersionMismatchError}
-       */
+   * Save a given entity.
+   *
+   * @example
+   * ```ts
+   * const entity = await repository.findById(1);
+   * entity.name = "New Name"; // update a field
+   * delete entity.description; // delete a field
+   * await repository.save(entity);
+   * ```
+   *
+   * Difference with `updateById/updateOne`:
+   *
+   * - requires the entity to be fetched first (whole object is expected)
+   * - check pg.version() if present -> optimistic locking
+   * - validate entity against schema
+   * - undefined values will be set to null, not ignored!
+   *
+   * @see {@link DbVersionMismatchError}
+   */
   save(entity: Static<T>, opts?: StatementOptions): Promise<void>;
   /**
-       * Find an entity by ID and update it.
-       */
+   * Find an entity by ID and update it.
+   */
   updateById(id: string | number, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
-       * Find many entities and update all of them.
-       */
+   * Find many entities and update all of them.
+   */
   updateMany(where: PgQueryWhereOrSQL<T>, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
-       * Find many and delete all of them.
-       * @returns Array of deleted entity IDs
-       */
+   * Find many and delete all of them.
+   * @returns Array of deleted entity IDs
+   */
   deleteMany(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
-       * Delete all entities.
-       * @returns Array of deleted entity IDs
-       */
+   * Delete all entities.
+   * @returns Array of deleted entity IDs
+   */
   clear(opts?: StatementOptions): Promise<Array<number | string>>;
   /**
-       * Delete the given entity.
-       *
-       * You must fetch the entity first in order to delete it.
-       * @returns Array containing the deleted entity ID
-       */
+   * Delete the given entity.
+   *
+   * You must fetch the entity first in order to delete it.
+   * @returns Array containing the deleted entity ID
+   */
   destroy(entity: Static<T>, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
-       * Find an entity and delete it.
-       * @returns Array of deleted entity IDs (should contain at most one ID)
-       */
+   * Find an entity and delete it.
+   * @returns Array of deleted entity IDs (should contain at most one ID)
+   */
   deleteOne(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
-       * Find an entity by ID and delete it.
-       * @returns Array containing the deleted entity ID
-       * @throws DbEntityNotFoundError if the entity is not found
-       */
+   * Find an entity by ID and delete it.
+   * @returns Array containing the deleted entity ID
+   * @throws DbEntityNotFoundError if the entity is not found
+   */
   deleteById(id: string | number, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
-       * Count entities.
-       */
+   * Count entities.
+   */
   count(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<number>;
   protected conflictMessagePattern: string;
   protected handleError(error: unknown, message: string): DbError;
@@ -1555,31 +1556,31 @@ declare abstract class Repository<T extends TObject> {
   }): PgQueryWhereOrSQL<T>;
   protected deletedAt(): PgAttrField | undefined;
   /**
-       * Convert something to valid Pg Insert Value.
-       */
+   * Convert something to valid Pg Insert Value.
+   */
   protected cast(data: any, insert: boolean): PgInsertValue<PgTableWithColumns<SchemaToTableConfig<T>>>;
   /**
-       * Transform a row from the database into a clean entity.
-       */
+   * Transform a row from the database into a clean entity.
+   */
   protected clean<T extends TObject>(row: Record<string, unknown>, schema: T): Static<T>;
   /**
-       * Clean a row with joins recursively
-       */
+   * Clean a row with joins recursively
+   */
   protected cleanWithJoins<T extends TObject>(row: Record<string, unknown>, schema: T, joins: PgJoin[], parentPath?: string): Static<T>;
   /**
-       * Convert a where clause to SQL.
-       */
+   * Convert a where clause to SQL.
+   */
   protected toSQL(where: PgQueryWhereOrSQL<T>, joins?: PgJoin[]): SQL | undefined;
   /**
-       * Get the where clause for an ID.
-       *
-       * @param id The ID to get the where clause for.
-       * @returns The where clause for the ID.
-       */
+   * Get the where clause for an ID.
+   *
+   * @param id The ID to get the where clause for.
+   * @returns The where clause for the ID.
+   */
   protected getWhereId(id: string | number): PgQueryWhere<T>;
   /**
-       * Find a primary key in the schema.
-       */
+   * Find a primary key in the schema.
+   */
   protected getPrimaryKey(schema: TObject): {
     key: string;
     col: PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>;
@@ -1591,23 +1592,23 @@ declare abstract class Repository<T extends TObject> {
  */
 interface StatementOptions {
   /**
-       * Transaction to use.
-       */
+   * Transaction to use.
+   */
   tx?: PgTransaction<any, Record<string, any>>;
   /**
-       * Lock strength.
-       */
+   * Lock strength.
+   */
   for?: LockStrength | {
     config: LockConfig;
     strength: LockStrength;
   };
   /**
-       * If true, ignore soft delete.
-       */
+   * If true, ignore soft delete.
+   */
   force?: boolean;
   /**
-       * Force the current time.
-       */
+   * Force the current time.
+   */
   now?: DateTime | string;
 }
 //#endregion
@@ -1636,104 +1637,104 @@ declare const $repository: <T extends TObject>(entity: EntityPrimitive<T>) => Re
 declare const $transaction: <T extends any[], R>(opts: TransactionPrimitiveOptions<T, R>) => alepha_retry0.RetryPrimitiveFn<(...args: T) => Promise<R>>;
 interface TransactionPrimitiveOptions<T extends any[], R> {
   /**
-       * Transaction handler function that contains all database operations to be executed atomically.
-       *
-       * This function:
-       * - Receives a transaction object as the first parameter
-       * - Should pass the transaction to all repository operations via `{ tx }` option
-       * - All operations within are automatically rolled back if any error occurs
-       * - Has access to the full Alepha dependency injection container
-       * - Will be automatically retried if a `PgVersionMismatchError` occurs
-       *
-       * **Transaction Guidelines**:
-       * - Keep transactions as short as possible to minimize lock contention
-       * - Always pass the `tx` parameter to repository operations
-       * - Handle expected business errors gracefully
-       * - Log important operations for debugging and audit trails
-       * - Consider the impact of long-running transactions on performance
-       *
-       * **Error Handling**:
-       * - Throwing any error will automatically roll back the transaction
-       * - `PgVersionMismatchError` triggers automatic retry logic
-       * - Other database errors will be propagated after rollback
-       * - Use try-catch within the handler for business-specific error handling
-       *
-       * @param tx - The PostgreSQL transaction object to use for all database operations
-       * @param ...args - Additional arguments passed to the transaction function
-       * @returns Promise resolving to the transaction result
-       *
-       * @example
-       * ```ts
-       * handler: async (tx, orderId: string, newStatus: string) => {
-       *   // Get the current order (with transaction)
-       *   const order = await this.orders.findById(orderId, { tx });
-       *
-       *   // Validate business rules
-       *   if (!this.isValidStatusTransition(order.status, newStatus)) {
-       *     throw new Error(`Invalid status transition: ${order.status} -> ${newStatus}`);
-       *   }
-       *
-       *   // Update order status (with transaction)
-       *   const updatedOrder = await this.orders.updateById(
-       *     orderId,
-       *     { status: newStatus },
-       *     { tx }
-       *   );
-       *
-       *   // Create audit log (with transaction)
-       *   await this.auditLogs.create({
-       *     id: generateUUID(),
-       *     entityId: orderId,
-       *     action: 'status_change',
-       *     oldValue: order.status,
-       *     newValue: newStatus,
-       *     timestamp: new Date().toISOString()
-       *   }, { tx });
-       *
-       *   return updatedOrder;
-       * }
-       * ```
-       */
+   * Transaction handler function that contains all database operations to be executed atomically.
+   *
+   * This function:
+   * - Receives a transaction object as the first parameter
+   * - Should pass the transaction to all repository operations via `{ tx }` option
+   * - All operations within are automatically rolled back if any error occurs
+   * - Has access to the full Alepha dependency injection container
+   * - Will be automatically retried if a `PgVersionMismatchError` occurs
+   *
+   * **Transaction Guidelines**:
+   * - Keep transactions as short as possible to minimize lock contention
+   * - Always pass the `tx` parameter to repository operations
+   * - Handle expected business errors gracefully
+   * - Log important operations for debugging and audit trails
+   * - Consider the impact of long-running transactions on performance
+   *
+   * **Error Handling**:
+   * - Throwing any error will automatically roll back the transaction
+   * - `PgVersionMismatchError` triggers automatic retry logic
+   * - Other database errors will be propagated after rollback
+   * - Use try-catch within the handler for business-specific error handling
+   *
+   * @param tx - The PostgreSQL transaction object to use for all database operations
+   * @param ...args - Additional arguments passed to the transaction function
+   * @returns Promise resolving to the transaction result
+   *
+   * @example
+   * ```ts
+   * handler: async (tx, orderId: string, newStatus: string) => {
+   *   // Get the current order (with transaction)
+   *   const order = await this.orders.findById(orderId, { tx });
+   *
+   *   // Validate business rules
+   *   if (!this.isValidStatusTransition(order.status, newStatus)) {
+   *     throw new Error(`Invalid status transition: ${order.status} -> ${newStatus}`);
+   *   }
+   *
+   *   // Update order status (with transaction)
+   *   const updatedOrder = await this.orders.updateById(
+   *     orderId,
+   *     { status: newStatus },
+   *     { tx }
+   *   );
+   *
+   *   // Create audit log (with transaction)
+   *   await this.auditLogs.create({
+   *     id: generateUUID(),
+   *     entityId: orderId,
+   *     action: 'status_change',
+   *     oldValue: order.status,
+   *     newValue: newStatus,
+   *     timestamp: new Date().toISOString()
+   *   }, { tx });
+   *
+   *   return updatedOrder;
+   * }
+   * ```
+   */
   handler: (tx: PgTransaction<any, any, any>, ...args: T) => Promise<R>;
   /**
-       * PostgreSQL transaction configuration options.
-       *
-       * This allows you to customize transaction behavior including:
-       * - **Isolation Level**: Controls visibility of concurrent transaction changes
-       * - **Access Mode**: Whether the transaction is read-only or read-write
-       * - **Deferrable**: For serializable transactions, allows deferring to avoid conflicts
-       *
-       * **Isolation Levels**:
-       * - **read_uncommitted**: Lowest isolation, allows dirty reads (rarely used)
-       * - **read_committed**: Default level, prevents dirty reads
-       * - **repeatable_read**: Prevents dirty and non-repeatable reads
-       * - **serializable**: Highest isolation, full ACID compliance
-       *
-       * **Access Modes**:
-       * - **read_write**: Default, allows both read and write operations
-       * - **read_only**: Only allows read operations, can provide performance benefits
-       *
-       * **When to Use Different Isolation Levels**:
-       * - **read_committed**: Most common operations, good balance of consistency and performance
-       * - **repeatable_read**: When you need consistent reads throughout the transaction
-       * - **serializable**: Critical financial operations, when absolute consistency is required
-       *
-       * @example
-       * ```ts
-       * config: {
-       *   isolationLevel: 'serializable',  // Highest consistency for financial operations
-       *   accessMode: 'read_write'
-       * }
-       * ```
-       *
-       * @example
-       * ```ts
-       * config: {
-       *   isolationLevel: 'read_committed', // Default level for most operations
-       *   accessMode: 'read_only'          // Performance optimization for read-only operations
-       * }
-       * ```
-       */
+   * PostgreSQL transaction configuration options.
+   *
+   * This allows you to customize transaction behavior including:
+   * - **Isolation Level**: Controls visibility of concurrent transaction changes
+   * - **Access Mode**: Whether the transaction is read-only or read-write
+   * - **Deferrable**: For serializable transactions, allows deferring to avoid conflicts
+   *
+   * **Isolation Levels**:
+   * - **read_uncommitted**: Lowest isolation, allows dirty reads (rarely used)
+   * - **read_committed**: Default level, prevents dirty reads
+   * - **repeatable_read**: Prevents dirty and non-repeatable reads
+   * - **serializable**: Highest isolation, full ACID compliance
+   *
+   * **Access Modes**:
+   * - **read_write**: Default, allows both read and write operations
+   * - **read_only**: Only allows read operations, can provide performance benefits
+   *
+   * **When to Use Different Isolation Levels**:
+   * - **read_committed**: Most common operations, good balance of consistency and performance
+   * - **repeatable_read**: When you need consistent reads throughout the transaction
+   * - **serializable**: Critical financial operations, when absolute consistency is required
+   *
+   * @example
+   * ```ts
+   * config: {
+   *   isolationLevel: 'serializable',  // Highest consistency for financial operations
+   *   accessMode: 'read_write'
+   * }
+   * ```
+   *
+   * @example
+   * ```ts
+   * config: {
+   *   isolationLevel: 'read_committed', // Default level for most operations
+   *   accessMode: 'read_only'          // Performance optimization for read-only operations
+   * }
+   * ```
+   */
   config?: PgTransactionConfig;
 }
 type TransactionContext = PgTransaction<any, any, any>;
@@ -1750,8 +1751,8 @@ declare class SqliteModelBuilder extends ModelBuilder {
     schema: string;
   }): void;
   /**
-       * Get SQLite-specific config builder for the table.
-       */
+   * Get SQLite-specific config builder for the table.
+   */
   protected getTableConfig(entity: EntityPrimitive, tables: Map<string, unknown>): ((self: BuildColumns<string, any, "sqlite">) => any) | undefined;
   schemaToSqliteColumns: <T extends TObject>(tableName: string, schema: T, enums: Map<string, unknown>, tables: Map<string, unknown>) => SchemaToSqliteBuilder<T>;
   mapFieldToSqliteColumn: (tableName: string, fieldName: string, value: TSchema, enums: Map<string, any>) => pg$1.SQLiteIntegerBuilderInitial<string> | pg$1.SQLiteNumericBuilderInitial<string> | pg$1.SQLiteTextBuilderInitial<string, [string, ...string[]], number | undefined> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
@@ -1938,7 +1939,7 @@ interface D1ExecResult {
  */
 declare class CloudflareD1Provider extends DatabaseProvider {
   protected readonly kit: DrizzleKitProvider;
-  protected readonly log: alepha_logger3.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected readonly builder: SqliteModelBuilder;
   protected readonly env: {
     DATABASE_URL: string;
@@ -1954,14 +1955,14 @@ declare class CloudflareD1Provider extends DatabaseProvider {
   protected readonly onStart: alepha34.HookPrimitive<"start">;
   protected executeMigrations(migrationsFolder: string): Promise<void>;
   /**
-       * Override development migration to skip sync (not supported on D1).
-       * D1 requires proper migrations to be applied.
-       */
+   * Override development migration to skip sync (not supported on D1).
+   * D1 requires proper migrations to be applied.
+   */
   protected runDevelopmentMigration(migrationsFolder: string): Promise<void>;
   /**
-       * Override test migration to run migrations instead of sync.
-       * D1 doesn't support schema synchronization.
-       */
+   * Override test migration to run migrations instead of sync.
+   * D1 doesn't support schema synchronization.
+   */
   protected runTestMigration(): Promise<void>;
 }
 //#endregion
@@ -2001,17 +2002,17 @@ declare class PostgresModelBuilder extends ModelBuilder {
     schema: string;
   }): void;
   /**
-       * Get PostgreSQL-specific config builder for the table.
-       */
+   * Get PostgreSQL-specific config builder for the table.
+   */
   protected getTableConfig(entity: EntityPrimitive, tables: Map<string, unknown>): ((self: BuildExtraConfigColumns<string, any, "pg">) => PgTableExtraConfigValue[]) | undefined;
   schemaToPgColumns: <T extends TObject>(tableName: string, schema: T, nsp: PgSchema, enums: Map<string, unknown>, tables: Map<string, unknown>) => FromSchema<T>;
   mapFieldToColumn: (tableName: string, fieldName: string, value: TSchema, nsp: PgSchema, enums: Map<string, any>) => any;
   /**
-       * Map a string to a PG column.
-       *
-       * @param key The key of the field.
-       * @param value The value of the field.
-       */
+   * Map a string to a PG column.
+   *
+   * @param key The key of the field.
+   * @param value The value of the field.
+   */
   mapStringToColumn: (key: string, value: TSchema) => drizzle_orm_pg_core0.PgUUIDBuilderInitial<string> | drizzle_orm_pg_core0.PgCustomColumnBuilder<{
     name: string;
     dataType: "custom";
@@ -2028,16 +2029,16 @@ declare module "alepha" {
 }
 declare const envSchema$1: alepha34.TObject<{
   /**
-       * Main configuration for database connection.
-       * Accept a string in the format of a Postgres connection URL.
-       * Example: postgres://user:password@localhost:5432/database
-       * or
-       * Example: postgres://user:password@localhost:5432/database?sslmode=require
-       */
+   * Main configuration for database connection.
+   * Accept a string in the format of a Postgres connection URL.
+   * Example: postgres://user:password@localhost:5432/database
+   * or
+   * Example: postgres://user:password@localhost:5432/database?sslmode=require
+   */
   DATABASE_URL: alepha34.TOptional<alepha34.TString>;
   /**
-       * In addition to the DATABASE_URL, you can specify the postgres schema name.
-       */
+   * In addition to the DATABASE_URL, you can specify the postgres schema name.
+   */
   POSTGRES_SCHEMA: alepha34.TOptional<alepha34.TString>;
 }>;
 /**
@@ -2059,7 +2060,7 @@ declare const envSchema$1: alepha34.TObject<{
  * ```
  */
 declare class BunPostgresProvider extends DatabaseProvider {
-  protected readonly log: alepha_logger3.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected readonly env: {
     DATABASE_URL?: string | undefined;
     POSTGRES_SCHEMA?: string | undefined;
@@ -2071,21 +2072,21 @@ declare class BunPostgresProvider extends DatabaseProvider {
   readonly dialect = "postgresql";
   get name(): string;
   /**
-       * In testing mode, the schema name will be generated and deleted after the test.
-       */
+   * In testing mode, the schema name will be generated and deleted after the test.
+   */
   protected schemaForTesting: string | undefined;
   get url(): string;
   /**
-       * Execute a SQL statement.
-       */
+   * Execute a SQL statement.
+   */
   execute(statement: SQLLike): Promise<Array<Record<string, unknown>>>;
   /**
-       * Get Postgres schema used by this provider.
-       */
+   * Get Postgres schema used by this provider.
+   */
   get schema(): string;
   /**
-       * Get the Drizzle Postgres database instance.
-       */
+   * Get the Drizzle Postgres database instance.
+   */
   get db(): PgDatabase<any>;
   protected executeMigrations(migrationsFolder: string): Promise<void>;
   protected readonly onStart: alepha34.HookPrimitive<"start">;
@@ -2134,7 +2135,7 @@ declare module "alepha" {
  */
 declare class BunSqliteProvider extends DatabaseProvider {
   protected readonly kit: DrizzleKitProvider;
-  protected readonly log: alepha_logger3.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected readonly env: {
     DATABASE_URL?: string | undefined;
   };
@@ -2160,23 +2161,23 @@ declare module "alepha" {
 }
 declare const envSchema: alepha34.TObject<{
   /**
-       * Main configuration for database connection.
-       * Accept a string in the format of a Postgres connection URL.
-       * Example: postgres://user:password@localhost:5432/database
-       * or
-       * Example: postgres://user:password@localhost:5432/database?sslmode=require
-       */
+   * Main configuration for database connection.
+   * Accept a string in the format of a Postgres connection URL.
+   * Example: postgres://user:password@localhost:5432/database
+   * or
+   * Example: postgres://user:password@localhost:5432/database?sslmode=require
+   */
   DATABASE_URL: alepha34.TOptional<alepha34.TString>;
   /**
-       * In addition to the DATABASE_URL, you can specify the postgres schema name.
-       *
-       * It will monkey patch drizzle tables.
-       */
+   * In addition to the DATABASE_URL, you can specify the postgres schema name.
+   *
+   * It will monkey patch drizzle tables.
+   */
   POSTGRES_SCHEMA: alepha34.TOptional<alepha34.TString>;
 }>;
 declare class NodePostgresProvider extends DatabaseProvider {
   static readonly SSL_MODES: readonly ["require", "allow", "prefer", "verify-full"];
-  protected readonly log: alepha_logger3.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected readonly env: {
     DATABASE_URL?: string | undefined;
     POSTGRES_SCHEMA?: string | undefined;
@@ -2188,21 +2189,21 @@ declare class NodePostgresProvider extends DatabaseProvider {
   readonly dialect = "postgresql";
   get name(): string;
   /**
-       * In testing mode, the schema name will be generated and deleted after the test.
-       */
+   * In testing mode, the schema name will be generated and deleted after the test.
+   */
   protected schemaForTesting: string | undefined;
   get url(): string;
   /**
-       * Execute a SQL statement.
-       */
+   * Execute a SQL statement.
+   */
   execute(statement: SQLLike): Promise<Array<Record<string, unknown>>>;
   /**
-       * Get Postgres schema used by this provider.
-       */
+   * Get Postgres schema used by this provider.
+   */
   get schema(): string;
   /**
-       * Get the Drizzle Postgres database instance.
-       */
+   * Get the Drizzle Postgres database instance.
+   */
   get db(): PostgresJsDatabase;
   protected executeMigrations(migrationsFolder: string): Promise<void>;
   protected readonly onStart: alepha34.HookPrimitive<"start">;
@@ -2211,8 +2212,8 @@ declare class NodePostgresProvider extends DatabaseProvider {
   close(): Promise<void>;
   protected migrateLock: alepha_lock0.LockPrimitive<() => Promise<void>>;
   /**
-       * Map the DATABASE_URL to postgres client options.
-       */
+   * Map the DATABASE_URL to postgres client options.
+   */
   protected getClientOptions(): postgres.Options<any>;
   protected ssl(url: URL): "require" | "allow" | "prefer" | "verify-full" | undefined;
 }
@@ -2238,7 +2239,7 @@ declare module "alepha" {
  */
 declare class NodeSqliteProvider extends DatabaseProvider {
   protected readonly kit: DrizzleKitProvider;
-  protected readonly log: alepha_logger3.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected readonly env: {
     DATABASE_URL?: string | undefined;
   };
@@ -2261,31 +2262,31 @@ declare namespace index_d_exports {
 declare module "alepha" {
   interface Hooks {
     /**
-             * Fires before creating an entity in the repository.
-             */
+     * Fires before creating an entity in the repository.
+     */
     "repository:create:before": {
       tableName: string;
       data: any;
     };
     /**
-             * Fires after creating an entity in the repository.
-             */
+     * Fires after creating an entity in the repository.
+     */
     "repository:create:after": {
       tableName: string;
       data: any;
       entity: any;
     };
     /**
-             * Fires before updating entities in the repository.
-             */
+     * Fires before updating entities in the repository.
+     */
     "repository:update:before": {
       tableName: string;
       where: any;
       data: any;
     };
     /**
-             * Fires after updating entities in the repository.
-             */
+     * Fires after updating entities in the repository.
+     */
     "repository:update:after": {
       tableName: string;
       where: any;
@@ -2293,30 +2294,30 @@ declare module "alepha" {
       entities: any[];
     };
     /**
-             * Fires before deleting entities from the repository.
-             */
+     * Fires before deleting entities from the repository.
+     */
     "repository:delete:before": {
       tableName: string;
       where: any;
     };
     /**
-             * Fires after deleting entities from the repository.
-             */
+     * Fires after deleting entities from the repository.
+     */
     "repository:delete:after": {
       tableName: string;
       where: any;
       ids: Array<string | number>;
     };
     /**
-             * Fires before reading entities from the repository.
-             */
+     * Fires before reading entities from the repository.
+     */
     "repository:read:before": {
       tableName: string;
       query: any;
     };
     /**
-             * Fires after reading entities from the repository.
-             */
+     * Fires after reading entities from the repository.
+     */
     "repository:read:after": {
       tableName: string;
       query: any;