alepha 0.15.0 → 0.15.2

package/dist/orm/index.d.ts

@@ -1,12 +1,12 @@
-import { n as __reExport, t as __exportAll } from "./chunk-DtkW-qnP.js";
-import * as alepha34 from "alepha";
+import { n as __reExport, t as __exportAll } from "./chunk-DH6iiROE.js";
+import * as alepha26 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";
 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";
@@ -18,12 +18,65 @@ import { BunSQLDatabase } from "drizzle-orm/bun-sql";
 import { BunSQLiteDatabase } from "drizzle-orm/bun-sqlite";
 import { DrizzleD1Database } from "drizzle-orm/d1";
 import { DatabaseSync } from "node:sqlite";
+import * as typebox0 from "typebox";
+import * as DrizzleKit from "drizzle-kit/api";
 import { UpdateDeleteAction as UpdateDeleteAction$1 } from "drizzle-orm/pg-core/foreign-keys";
 import { PgTransactionConfig } from "drizzle-orm/pg-core/session";
-import * as DrizzleKit from "drizzle-kit/api";
-import * as typebox1 from "typebox";
 export * from "drizzle-orm/pg-core";
 
+//#region ../../src/orm/constants/PG_SYMBOLS.d.ts
+declare const PG_DEFAULT: unique symbol;
+declare const PG_PRIMARY_KEY: unique symbol;
+declare const PG_CREATED_AT: unique symbol;
+declare const PG_UPDATED_AT: unique symbol;
+declare const PG_DELETED_AT: unique symbol;
+declare const PG_VERSION: unique symbol;
+declare const PG_IDENTITY: unique symbol;
+declare const PG_ENUM: unique symbol;
+declare const PG_REF: unique symbol;
+/**
+ * @deprecated Use `PG_IDENTITY` instead.
+ */
+declare const PG_SERIAL: unique symbol;
+type PgDefault = typeof PG_DEFAULT;
+type PgRef = typeof PG_REF;
+type PgPrimaryKey = typeof PG_PRIMARY_KEY;
+type PgSymbols = {
+  [PG_DEFAULT]: {};
+  [PG_PRIMARY_KEY]: {};
+  [PG_CREATED_AT]: {};
+  [PG_UPDATED_AT]: {};
+  [PG_DELETED_AT]: {};
+  [PG_VERSION]: {};
+  [PG_IDENTITY]: PgIdentityOptions;
+  [PG_REF]: PgRefOptions;
+  [PG_ENUM]: PgEnumOptions;
+  /**
+   * @deprecated Use `PG_IDENTITY` instead.
+   */
+  [PG_SERIAL]: {};
+};
+type PgSymbolKeys = keyof PgSymbols;
+type PgIdentityOptions = {
+  mode: "always" | "byDefault";
+} & PgSequenceOptions & {
+  name?: string;
+};
+interface PgEnumOptions {
+  name?: string;
+  description?: string;
+}
+interface PgRefOptions {
+  ref: () => {
+    name: string;
+    entity: EntityPrimitive;
+  };
+  actions?: {
+    onUpdate?: UpdateDeleteAction;
+    onDelete?: UpdateDeleteAction;
+  };
+}
+//#endregion
 //#region ../../src/orm/schemas/insertSchema.d.ts
 /**
  * Transforms a TObject schema for insert operations.
@@ -73,119 +126,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> {
@@ -214,57 +267,382 @@ type EntityColumn<T extends TObject> = {
 };
 type EntityColumns<T extends TObject> = { [key in keyof T["properties"]]: EntityColumn<T> };
 //#endregion
-//#region ../../src/orm/constants/PG_SYMBOLS.d.ts
-declare const PG_DEFAULT: unique symbol;
-declare const PG_PRIMARY_KEY: unique symbol;
-declare const PG_CREATED_AT: unique symbol;
-declare const PG_UPDATED_AT: unique symbol;
-declare const PG_DELETED_AT: unique symbol;
-declare const PG_VERSION: unique symbol;
-declare const PG_IDENTITY: unique symbol;
-declare const PG_ENUM: unique symbol;
-declare const PG_REF: unique symbol;
+//#region ../../src/orm/services/ModelBuilder.d.ts
+/**
+ * Database-specific table configuration functions
+ */
+interface TableConfigBuilders<TConfig> {
+  index: (name: string) => {
+    on: (...columns: any[]) => TConfig;
+  };
+  uniqueIndex: (name: string) => {
+    on: (...columns: any[]) => TConfig;
+  };
+  unique: (name: string) => {
+    on: (...columns: any[]) => TConfig;
+  };
+  check: (name: string, sql: SQL) => TConfig;
+  foreignKey: (config: {
+    name: string;
+    columns: any[];
+    foreignColumns: any[];
+  }) => TConfig;
+}
+/**
+ * Abstract base class for transforming Alepha Primitives (Entity, Sequence, etc...)
+ * into drizzle models (tables, enums, sequences, etc...).
+ */
+declare abstract class ModelBuilder {
+  /**
+   * 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.
+   */
+  abstract buildSequence(sequence: SequencePrimitive, options: {
+    sequences: Map<string, unknown>;
+    schema: string;
+  }): void;
+  /**
+   * 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
+   */
+  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_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(provider: DatabaseProvider): Promise<void>;
+  /**
+   * 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.
+   */
+  getModels(provider: DatabaseProvider): Record<string, unknown>;
+  /**
+   * 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.
+   */
+  importDrizzleKit(): typeof DrizzleKit;
+}
+declare const devMigrationsSchema: alepha26.TObject<{
+  id: alepha26.TNumber;
+  name: alepha26.TString;
+  snapshot: alepha26.TString;
+  created_at: alepha26.TString;
+}>;
+type DevMigrations = Static<typeof devMigrationsSchema>;
+//#endregion
+//#region ../../src/orm/providers/drivers/DatabaseProvider.d.ts
+type SQLLike = SQLWrapper | string;
+declare abstract class DatabaseProvider {
+  protected readonly alepha: Alepha;
+  protected readonly log: alepha_logger4.Logger;
+  protected abstract readonly builder: ModelBuilder;
+  protected abstract readonly kit: DrizzleKitProvider;
+  abstract readonly db: PgDatabase<any>;
+  abstract readonly dialect: "postgresql" | "sqlite";
+  abstract readonly url: string;
+  readonly enums: Map<string, unknown>;
+  readonly tables: Map<string, unknown>;
+  readonly sequences: Map<string, unknown>;
+  get name(): string;
+  get driver(): string;
+  get schema(): string;
+  table<T extends TObject>(entity: EntityPrimitive<T>): PgTableWithColumns<SchemaToTableConfig<T>>;
+  registerEntity(entity: EntityPrimitive): void;
+  registerSequence(sequence: SequencePrimitive): void;
+  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
+   */
+  protected getMigrationsFolder(): string;
+  /**
+   * Base migration orchestration - handles environment logic
+   */
+  migrate(): Promise<void>;
+  /**
+   * Production: run migrations from folder
+   */
+  protected runProductionMigration(migrationsFolder: string): Promise<void>;
+  /**
+   * Test: always synchronize
+   */
+  protected runTestMigration(): Promise<void>;
+  /**
+   * Development: default to synchronize (can be overridden)
+   */
+  protected runDevelopmentMigration(migrationsFolder: string): Promise<void>;
+  /**
+   * Common synchronization with error handling
+   */
+  protected synchronizeSchema(): Promise<void>;
+  /**
+   * 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`.
+   */
+  protected generateTestSchemaName(): string;
+}
+//#endregion
+//#region ../../src/orm/primitives/$sequence.d.ts
+/**
+ * Creates a PostgreSQL sequence primitive for generating unique numeric values.
+ */
+declare const $sequence: {
+  (options?: SequencePrimitiveOptions): SequencePrimitive;
+  [KIND]: typeof SequencePrimitive;
+};
+interface SequencePrimitiveOptions extends PgSequenceOptions {
+  /**
+   * The name of the sequence. If not provided, the property key will be used.
+   */
+  name?: string;
+  provider?: DatabaseProvider;
+}
+declare class SequencePrimitive extends Primitive<SequencePrimitiveOptions> {
+  readonly provider: DatabaseProvider;
+  onInit(): void;
+  get name(): string;
+  next(): Promise<number>;
+  current(): Promise<number>;
+  protected $provider(): DatabaseProvider;
+}
+//#endregion
+//#region ../../src/orm/services/SqliteModelBuilder.d.ts
+declare class SqliteModelBuilder extends ModelBuilder {
+  buildTable(entity: EntityPrimitive<any>, options: {
+    tables: Map<string, unknown>;
+    enums: Map<string, unknown>;
+    schema: string;
+  }): void;
+  buildSequence(sequence: SequencePrimitive, options: {
+    sequences: Map<string, unknown>;
+    schema: string;
+  }): void;
+  /**
+   * 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<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: string;
+    driverParam: string;
+    enumValues: undefined;
+  }>, string> | pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: string;
+    driverParam: number;
+    enumValues: undefined;
+  }> | pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: boolean;
+    driverParam: number;
+    enumValues: undefined;
+  }> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: {
+      [x: string]: unknown;
+      [x: number]: unknown;
+      [x: symbol]: unknown;
+    };
+    driverParam: string;
+    enumValues: undefined;
+  }>, {
+    [x: string]: unknown;
+    [x: number]: unknown;
+    [x: symbol]: unknown;
+  }> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: typebox0.StaticRecord<[], "Decode", {}, {}, string, TSchema>;
+    driverParam: string;
+    enumValues: undefined;
+  }>, typebox0.StaticRecord<[], "Decode", {}, {}, string, TSchema>> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: any;
+    driverParam: string;
+    enumValues: undefined;
+  }>, any> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: unknown[];
+    driverParam: string;
+    enumValues: undefined;
+  }>, unknown[]>;
+  mapStringToSqliteColumn: (key: string, value: TString) => pg$1.SQLiteTextBuilderInitial<string, [string, ...string[]], number | undefined> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: string;
+    driverParam: string;
+    enumValues: undefined;
+  }>, string> | pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: string;
+    driverParam: number;
+    enumValues: undefined;
+  }>;
+  sqliteJson: <TDocument extends TSchema>(name: string, document: TDocument) => drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: typebox0.StaticType<[], "Decode", {}, {}, TDocument>;
+    driverParam: string;
+    enumValues: undefined;
+  }>, typebox0.StaticType<[], "Decode", {}, {}, TDocument>>;
+  sqliteDateTime: {
+    <TConfig extends Record<string, any>>(fieldConfig: TConfig): pg$1.SQLiteCustomColumnBuilder<{
+      name: "";
+      dataType: "custom";
+      columnType: "SQLiteCustomColumn";
+      data: string;
+      driverParam: number;
+      enumValues: undefined;
+    }>;
+    <TName extends string>(dbName: TName, fieldConfig: unknown): pg$1.SQLiteCustomColumnBuilder<{
+      name: TName;
+      dataType: "custom";
+      columnType: "SQLiteCustomColumn";
+      data: string;
+      driverParam: number;
+      enumValues: undefined;
+    }>;
+  };
+  sqliteBool: {
+    <TConfig extends Record<string, any>>(fieldConfig: TConfig): pg$1.SQLiteCustomColumnBuilder<{
+      name: "";
+      dataType: "custom";
+      columnType: "SQLiteCustomColumn";
+      data: boolean;
+      driverParam: number;
+      enumValues: undefined;
+    }>;
+    <TName extends string>(dbName: TName, fieldConfig: unknown): pg$1.SQLiteCustomColumnBuilder<{
+      name: TName;
+      dataType: "custom";
+      columnType: "SQLiteCustomColumn";
+      data: boolean;
+      driverParam: number;
+      enumValues: undefined;
+    }>;
+  };
+  sqliteDate: {
+    <TConfig extends Record<string, any>>(fieldConfig: TConfig): pg$1.SQLiteCustomColumnBuilder<{
+      name: "";
+      dataType: "custom";
+      columnType: "SQLiteCustomColumn";
+      data: string;
+      driverParam: number;
+      enumValues: undefined;
+    }>;
+    <TName extends string>(dbName: TName, fieldConfig: unknown): pg$1.SQLiteCustomColumnBuilder<{
+      name: TName;
+      dataType: "custom";
+      columnType: "SQLiteCustomColumn";
+      data: string;
+      driverParam: number;
+      enumValues: undefined;
+    }>;
+  };
+}
+type SchemaToSqliteBuilder<T extends TObject> = { [key in keyof T["properties"]]: SQLiteColumnBuilderBase };
+//#endregion
+//#region ../../src/orm/providers/drivers/NodeSqliteProvider.d.ts
 /**
- * @deprecated Use `PG_IDENTITY` instead.
+ * Configuration options for the Node.js SQLite database provider.
  */
-declare const PG_SERIAL: unique symbol;
-type PgDefault = typeof PG_DEFAULT;
-type PgRef = typeof PG_REF;
-type PgPrimaryKey = typeof PG_PRIMARY_KEY;
-type PgSymbols = {
-  [PG_DEFAULT]: {};
-  [PG_PRIMARY_KEY]: {};
-  [PG_CREATED_AT]: {};
-  [PG_UPDATED_AT]: {};
-  [PG_DELETED_AT]: {};
-  [PG_VERSION]: {};
-  [PG_IDENTITY]: PgIdentityOptions;
-  [PG_REF]: PgRefOptions;
-  [PG_ENUM]: PgEnumOptions;
-  /**
-       * @deprecated Use `PG_IDENTITY` instead.
-       */
-  [PG_SERIAL]: {};
-};
-type PgSymbolKeys = keyof PgSymbols;
-type PgIdentityOptions = {
-  mode: "always" | "byDefault";
-} & PgSequenceOptions & {
-  name?: string;
-};
-interface PgEnumOptions {
-  name?: string;
-  description?: string;
+declare const nodeSqliteOptions: alepha26.Atom<alepha26.TObject<{
+  path: alepha26.TOptional<alepha26.TString>;
+}>, "alepha.postgres.node-sqlite.options">;
+type NodeSqliteProviderOptions = Static<typeof nodeSqliteOptions.schema>;
+declare module "alepha" {
+  interface State {
+    [nodeSqliteOptions.key]: NodeSqliteProviderOptions;
+  }
 }
-interface PgRefOptions {
-  ref: () => {
-    name: string;
-    entity: EntityPrimitive;
-  };
-  actions?: {
-    onUpdate?: UpdateDeleteAction;
-    onDelete?: UpdateDeleteAction;
+/**
+ * Add a fake support for SQLite in Node.js based on Postgres interfaces.
+ *
+ * This is NOT a real SQLite provider, it's a workaround to use SQLite with Drizzle ORM.
+ * This is NOT recommended for production use.
+ */
+declare class NodeSqliteProvider extends DatabaseProvider {
+  protected readonly kit: DrizzleKitProvider;
+  protected readonly log: alepha_logger4.Logger;
+  protected readonly env: {
+    DATABASE_URL?: string | undefined;
   };
+  protected readonly builder: SqliteModelBuilder;
+  protected readonly options: Readonly<{
+    path?: string | undefined;
+  }>;
+  protected sqlite: DatabaseSync;
+  get name(): string;
+  readonly dialect = "sqlite";
+  get url(): string;
+  execute(query: SQLLike): Promise<Array<Record<string, unknown>>>;
+  readonly db: PgDatabase<any>;
+  protected readonly onStart: alepha26.HookPrimitive<"start">;
+  protected executeMigrations(migrationsFolder: string): Promise<void>;
 }
 //#endregion
 //#region ../../src/orm/errors/DbError.d.ts
@@ -306,416 +684,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 +1152,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"]> } : {};
@@ -943,307 +1321,122 @@ interface PgAttrField {
   one?: boolean;
 }
 //#endregion
-//#region ../../src/orm/providers/DatabaseTypeProvider.d.ts
-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.
-       */
-  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)
-       */
-  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.
-       */
-  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
-       */
-  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.
-       */
-  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}
-       */
-  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.
-       */
-  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.
-       */
-  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.
-       */
-  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" });
-       * ```
-       */
-  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.
-       */
-  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.
-       */
-  readonly page: <T extends TObject>(resource: T, options?: TObjectOptions) => TPage<T>;
-}
-/**
- * Wrapper of TypeProvider (`t`) for database types.
- *
- * Use `db` for improve TypeBox schema definitions with database-specific attributes.
- *
- * @example
- * ```ts
- * import { t } from "alepha";
- * import { db } from "alepha/orm";
- *
- * const userSchema = t.object({
- *   id: db.primaryKey(t.uuid()),
- *   email: t.email(),
- *   createdAt: db.createdAt(),
- * });
- * ```
- */
-declare const db: DatabaseTypeProvider;
-/**
- * @deprecated Use `db` instead.
- */
-declare const pg: DatabaseTypeProvider;
-//#endregion
-//#region ../../src/orm/schemas/legacyIdSchema.d.ts
-/**
- * @deprecated Use `pg.primaryKey()` instead.
- */
-declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<alepha34.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
-//#endregion
-//#region ../../src/orm/primitives/$sequence.d.ts
-/**
- * Creates a PostgreSQL sequence primitive for generating unique numeric values.
- */
-declare const $sequence: {
-  (options?: SequencePrimitiveOptions): SequencePrimitive;
-  [KIND]: typeof SequencePrimitive;
-};
-interface SequencePrimitiveOptions extends PgSequenceOptions {
-  /**
-       * The name of the sequence. If not provided, the property key will be used.
-       */
-  name?: string;
-  provider?: DatabaseProvider;
-}
-declare class SequencePrimitive extends Primitive<SequencePrimitiveOptions> {
-  readonly provider: DatabaseProvider;
-  onInit(): void;
-  get name(): string;
-  next(): Promise<number>;
-  current(): Promise<number>;
-  protected $provider(): DatabaseProvider;
-}
-//#endregion
-//#region ../../src/orm/services/ModelBuilder.d.ts
-/**
- * Database-specific table configuration functions
- */
-interface TableConfigBuilders<TConfig> {
-  index: (name: string) => {
-    on: (...columns: any[]) => TConfig;
-  };
-  uniqueIndex: (name: string) => {
-    on: (...columns: any[]) => TConfig;
-  };
-  unique: (name: string) => {
-    on: (...columns: any[]) => TConfig;
-  };
-  check: (name: string, sql: SQL) => TConfig;
-  foreignKey: (config: {
-    name: string;
-    columns: any[];
-    foreignColumns: any[];
-  }) => TConfig;
-}
-/**
- * Abstract base class for transforming Alepha Primitives (Entity, Sequence, etc...)
- * into drizzle models (tables, enums, sequences, etc...).
- */
-declare abstract class ModelBuilder {
-  /**
-       * 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.
-       */
-  abstract buildSequence(sequence: SequencePrimitive, options: {
-    sequences: Map<string, unknown>;
-    schema: string;
-  }): void;
-  /**
-       * 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
-       */
-  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 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(provider: DatabaseProvider): Promise<void>;
-  /**
-       * 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.
-       */
-  getModels(provider: DatabaseProvider): Record<string, unknown>;
-  /**
-       * 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.
-       */
-  importDrizzleKit(): typeof DrizzleKit;
-}
-declare const devMigrationsSchema: alepha34.TObject<{
-  id: alepha34.TNumber;
-  name: alepha34.TString;
-  snapshot: alepha34.TString;
-  created_at: alepha34.TString;
-}>;
-type DevMigrations = Static<typeof devMigrationsSchema>;
-//#endregion
-//#region ../../src/orm/providers/drivers/DatabaseProvider.d.ts
-type SQLLike = SQLWrapper | string;
-declare abstract class DatabaseProvider {
-  protected readonly alepha: Alepha;
-  protected readonly log: alepha_logger3.Logger;
-  protected abstract readonly builder: ModelBuilder;
-  protected abstract readonly kit: DrizzleKitProvider;
-  abstract readonly db: PgDatabase<any>;
-  abstract readonly dialect: "postgresql" | "sqlite";
-  abstract readonly url: string;
-  readonly enums: Map<string, unknown>;
-  readonly tables: Map<string, unknown>;
-  readonly sequences: Map<string, unknown>;
-  get name(): string;
-  get driver(): string;
-  get schema(): string;
-  table<T extends TObject>(entity: EntityPrimitive<T>): PgTableWithColumns<SchemaToTableConfig<T>>;
-  registerEntity(entity: EntityPrimitive): void;
-  registerSequence(sequence: SequencePrimitive): void;
-  abstract execute(statement: SQLLike): Promise<Record<string, unknown>[]>;
-  run<T extends TObject>(statement: SQLLike, schema: T): Promise<Array<Static<T>>>;
+//#region ../../src/orm/providers/DatabaseTypeProvider.d.ts
+declare class DatabaseTypeProvider {
+  readonly attr: <T extends TSchema, Attr extends PgSymbolKeys>(type: T, attr: Attr, value?: PgSymbols[Attr]) => PgAttr<T, Attr>;
   /**
-       * Get migrations folder path - can be overridden
-       */
-  protected getMigrationsFolder(): string;
+   * 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>;
   /**
-       * Base migration orchestration - handles environment logic
-       */
-  migrate(): Promise<void>;
+   * 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>;
   /**
-       * Production: run migrations from folder
-       */
-  protected runProductionMigration(migrationsFolder: string): Promise<void>;
+   * Creates a primary key with a UUID column.
+   */
+  readonly uuidPrimaryKey: () => PgAttr<PgAttr<TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
   /**
-       * Test: always synchronize
-       */
-  protected runTestMigration(): Promise<void>;
+   * 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>;
   /**
-       * Development: default to synchronize (can be overridden)
-       */
-  protected runDevelopmentMigration(migrationsFolder: string): Promise<void>;
+   * 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>;
   /**
-       * Common synchronization with error handling
-       */
-  protected synchronizeSchema(): Promise<void>;
+   * 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>;
   /**
-       * Provider-specific migration execution
-       * MUST be implemented by each provider
-       */
-  protected abstract executeMigrations(migrationsFolder: string): Promise<void>;
+   * 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>;
   /**
-       * 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;
+   * 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.
+   */
+  readonly deletedAt: (options?: TStringOptions) => PgAttr<alepha26.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" });
+   * ```
+   */
+  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.
+   */
+  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.
+   */
+  readonly page: <T extends TObject>(resource: T, options?: TObjectOptions) => TPage<T>;
 }
+/**
+ * Wrapper of TypeProvider (`t`) for database types.
+ *
+ * Use `db` for improve TypeBox schema definitions with database-specific attributes.
+ *
+ * @example
+ * ```ts
+ * import { t } from "alepha";
+ * import { db } from "alepha/orm";
+ *
+ * const userSchema = t.object({
+ *   id: db.primaryKey(t.uuid()),
+ *   email: t.email(),
+ *   createdAt: db.createdAt(),
+ * });
+ * ```
+ */
+declare const db: DatabaseTypeProvider;
+/**
+ * @deprecated Use `db` instead.
+ */
+declare const pg: DatabaseTypeProvider;
+//#endregion
+//#region ../../src/orm/schemas/legacyIdSchema.d.ts
+/**
+ * @deprecated Use `pg.primaryKey()` instead.
+ */
+declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<alepha26.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
 //#endregion
 //#region ../../src/orm/services/QueryManager.d.ts
 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 +1444,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,34 +1468,34 @@ 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";
-  }>): alepha34.Page<T>;
+  }>): alepha26.Page<T>;
 }
 interface PgJoin {
   table: string;
@@ -1315,20 +1508,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 +1529,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.
-       */
-  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}
-       */
+   * Find an entity and update it.
+   */
+  updateOne(where: PgQueryWhereOrSQL<T>, data: WithSQL<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(entity: Static<T>, opts?: StatementOptions): Promise<void>;
   /**
-       * Find an entity by ID and update it.
-       */
-  updateById(id: string | number, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
+   * Find an entity by ID and update it.
+   */
+  updateById(id: string | number, data: WithSQL<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
-       * 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 entities and update all of them.
+   */
+  updateMany(where: PgQueryWhereOrSQL<T>, data: WithSQL<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 +1749,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,25 +1785,26 @@ 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;
 }
+type WithSQL<T> = { [P in keyof T]?: T[P] | SQL };
 //#endregion
 //#region ../../src/orm/primitives/$repository.d.ts
 /**
@@ -1636,262 +1831,108 @@ 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>;
 //#endregion
-//#region ../../src/orm/services/SqliteModelBuilder.d.ts
-declare class SqliteModelBuilder extends ModelBuilder {
-  buildTable(entity: EntityPrimitive<any>, options: {
-    tables: Map<string, unknown>;
-    enums: Map<string, unknown>;
-    schema: string;
-  }): void;
-  buildSequence(sequence: SequencePrimitive, options: {
-    sequences: Map<string, unknown>;
-    schema: string;
-  }): void;
-  /**
-       * 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<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: string;
-    driverParam: string;
-    enumValues: undefined;
-  }>, string> | pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: string;
-    driverParam: number;
-    enumValues: undefined;
-  }> | pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: boolean;
-    driverParam: number;
-    enumValues: undefined;
-  }> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: {
-      [x: string]: unknown;
-      [x: number]: unknown;
-      [x: symbol]: unknown;
-    };
-    driverParam: string;
-    enumValues: undefined;
-  }>, {
-    [x: string]: unknown;
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-  }> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: typebox1.StaticRecord<[], "Decode", {}, {}, string, TSchema>;
-    driverParam: string;
-    enumValues: undefined;
-  }>, typebox1.StaticRecord<[], "Decode", {}, {}, string, TSchema>> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: any;
-    driverParam: string;
-    enumValues: undefined;
-  }>, any> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: unknown[];
-    driverParam: string;
-    enumValues: undefined;
-  }>, unknown[]>;
-  mapStringToSqliteColumn: (key: string, value: TString) => pg$1.SQLiteTextBuilderInitial<string, [string, ...string[]], number | undefined> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: string;
-    driverParam: string;
-    enumValues: undefined;
-  }>, string> | pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: string;
-    driverParam: number;
-    enumValues: undefined;
-  }>;
-  sqliteJson: <TDocument extends TSchema>(name: string, document: TDocument) => drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: typebox1.StaticType<[], "Decode", {}, {}, TDocument>;
-    driverParam: string;
-    enumValues: undefined;
-  }>, typebox1.StaticType<[], "Decode", {}, {}, TDocument>>;
-  sqliteDateTime: {
-    <TConfig extends Record<string, any>>(fieldConfig: TConfig): pg$1.SQLiteCustomColumnBuilder<{
-      name: "";
-      dataType: "custom";
-      columnType: "SQLiteCustomColumn";
-      data: string;
-      driverParam: number;
-      enumValues: undefined;
-    }>;
-    <TName extends string>(dbName: TName, fieldConfig: unknown): pg$1.SQLiteCustomColumnBuilder<{
-      name: TName;
-      dataType: "custom";
-      columnType: "SQLiteCustomColumn";
-      data: string;
-      driverParam: number;
-      enumValues: undefined;
-    }>;
-  };
-  sqliteBool: {
-    <TConfig extends Record<string, any>>(fieldConfig: TConfig): pg$1.SQLiteCustomColumnBuilder<{
-      name: "";
-      dataType: "custom";
-      columnType: "SQLiteCustomColumn";
-      data: boolean;
-      driverParam: number;
-      enumValues: undefined;
-    }>;
-    <TName extends string>(dbName: TName, fieldConfig: unknown): pg$1.SQLiteCustomColumnBuilder<{
-      name: TName;
-      dataType: "custom";
-      columnType: "SQLiteCustomColumn";
-      data: boolean;
-      driverParam: number;
-      enumValues: undefined;
-    }>;
-  };
-  sqliteDate: {
-    <TConfig extends Record<string, any>>(fieldConfig: TConfig): pg$1.SQLiteCustomColumnBuilder<{
-      name: "";
-      dataType: "custom";
-      columnType: "SQLiteCustomColumn";
-      data: string;
-      driverParam: number;
-      enumValues: undefined;
-    }>;
-    <TName extends string>(dbName: TName, fieldConfig: unknown): pg$1.SQLiteCustomColumnBuilder<{
-      name: TName;
-      dataType: "custom";
-      columnType: "SQLiteCustomColumn";
-      data: string;
-      driverParam: number;
-      enumValues: undefined;
-    }>;
-  };
-}
-type SchemaToSqliteBuilder<T extends TObject> = { [key in keyof T["properties"]]: SQLiteColumnBuilderBase };
-//#endregion
 //#region ../../src/orm/providers/drivers/CloudflareD1Provider.d.ts
 /**
  * D1Database interface matching Cloudflare's D1 API.
@@ -1938,7 +1979,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;
@@ -1951,17 +1992,17 @@ declare class CloudflareD1Provider extends DatabaseProvider {
   get url(): string;
   get db(): PgDatabase<any>;
   execute(query: SQLLike): Promise<Array<Record<string, unknown>>>;
-  protected readonly onStart: alepha34.HookPrimitive<"start">;
+  protected readonly onStart: alepha26.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
@@ -1969,7 +2010,7 @@ declare class CloudflareD1Provider extends DatabaseProvider {
 declare class RepositoryProvider {
   protected readonly alepha: Alepha;
   protected readonly registry: Map<EntityPrimitive<any>, Service<Repository<any>>>;
-  getRepositories(provider?: DatabaseProvider): Repository<TObject<alepha34.TProperties>>[];
+  getRepositories(provider?: DatabaseProvider): Repository<TObject<alepha26.TProperties>>[];
   getRepository<T extends TObject>(entity: EntityPrimitive<T>): Repository<T>;
   createClassRepository<T extends TObject>(entity: EntityPrimitive<T>): Service<Repository<T>>;
 }
@@ -1982,10 +2023,10 @@ declare const schema: <TDocument extends TSchema>(name: string, document: TDocum
   name: string;
   dataType: "custom";
   columnType: "PgCustomColumn";
-  data: typebox1.StaticType<[], "Decode", {}, {}, TDocument>;
+  data: typebox0.StaticType<[], "Decode", {}, {}, TDocument>;
   driverParam: string;
   enumValues: undefined;
-}>, typebox1.StaticType<[], "Decode", {}, {}, TDocument>>;
+}>, typebox0.StaticType<[], "Decode", {}, {}, TDocument>>;
 //#endregion
 //#region ../../src/orm/services/PostgresModelBuilder.d.ts
 declare class PostgresModelBuilder extends ModelBuilder {
@@ -2001,17 +2042,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";
@@ -2026,19 +2067,19 @@ declare class PostgresModelBuilder extends ModelBuilder {
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
 }
-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
-       */
-  DATABASE_URL: alepha34.TOptional<alepha34.TString>;
-  /**
-       * In addition to the DATABASE_URL, you can specify the postgres schema name.
-       */
-  POSTGRES_SCHEMA: alepha34.TOptional<alepha34.TString>;
+declare const envSchema$1: alepha26.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
+   */
+  DATABASE_URL: alepha26.TOptional<alepha26.TString>;
+  /**
+   * In addition to the DATABASE_URL, you can specify the postgres schema name.
+   */
+  POSTGRES_SCHEMA: alepha26.TOptional<alepha26.TString>;
 }>;
 /**
  * Bun PostgreSQL provider using Drizzle ORM with Bun's native SQL client.
@@ -2059,7 +2100,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,25 +2112,25 @@ 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">;
-  protected readonly onStop: alepha34.HookPrimitive<"stop">;
+  protected readonly onStart: alepha26.HookPrimitive<"start">;
+  protected readonly onStop: alepha26.HookPrimitive<"stop">;
   connect(): Promise<void>;
   close(): Promise<void>;
   protected migrateLock: alepha_lock0.LockPrimitive<() => Promise<void>>;
@@ -2099,8 +2140,8 @@ declare class BunPostgresProvider extends DatabaseProvider {
 /**
  * Configuration options for the Bun SQLite database provider.
  */
-declare const bunSqliteOptions: alepha34.Atom<alepha34.TObject<{
-  path: alepha34.TOptional<alepha34.TString>;
+declare const bunSqliteOptions: alepha26.Atom<alepha26.TObject<{
+  path: alepha26.TOptional<alepha26.TString>;
 }>, "alepha.postgres.bun-sqlite.options">;
 type BunSqliteProviderOptions = Static<typeof bunSqliteOptions.schema>;
 declare module "alepha" {
@@ -2134,7 +2175,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;
   };
@@ -2149,8 +2190,8 @@ declare class BunSqliteProvider extends DatabaseProvider {
   get url(): string;
   get db(): PgDatabase<any>;
   execute(query: SQLLike): Promise<Array<Record<string, unknown>>>;
-  protected readonly onStart: alepha34.HookPrimitive<"start">;
-  protected readonly onStop: alepha34.HookPrimitive<"stop">;
+  protected readonly onStart: alepha26.HookPrimitive<"start">;
+  protected readonly onStop: alepha26.HookPrimitive<"stop">;
   protected executeMigrations(migrationsFolder: string): Promise<void>;
 }
 //#endregion
@@ -2158,25 +2199,25 @@ declare class BunSqliteProvider extends DatabaseProvider {
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
-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
-       */
-  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.
-       */
-  POSTGRES_SCHEMA: alepha34.TOptional<alepha34.TString>;
+declare const envSchema: alepha26.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
+   */
+  DATABASE_URL: alepha26.TOptional<alepha26.TString>;
+  /**
+   * In addition to the DATABASE_URL, you can specify the postgres schema name.
+   *
+   * It will monkey patch drizzle tables.
+   */
+  POSTGRES_SCHEMA: alepha26.TOptional<alepha26.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,104 +2229,65 @@ 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">;
-  protected readonly onStop: alepha34.HookPrimitive<"stop">;
+  protected readonly onStart: alepha26.HookPrimitive<"start">;
+  protected readonly onStop: alepha26.HookPrimitive<"stop">;
   connect(): Promise<void>;
   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;
 }
-//#endregion
-//#region ../../src/orm/providers/drivers/NodeSqliteProvider.d.ts
-/**
- * Configuration options for the Node.js SQLite database provider.
- */
-declare const nodeSqliteOptions: alepha34.Atom<alepha34.TObject<{
-  path: alepha34.TOptional<alepha34.TString>;
-}>, "alepha.postgres.node-sqlite.options">;
-type NodeSqliteProviderOptions = Static<typeof nodeSqliteOptions.schema>;
-declare module "alepha" {
-  interface State {
-    [nodeSqliteOptions.key]: NodeSqliteProviderOptions;
-  }
-}
-/**
- * Add a fake support for SQLite in Node.js based on Postgres interfaces.
- *
- * This is NOT a real SQLite provider, it's a workaround to use SQLite with Drizzle ORM.
- * This is NOT recommended for production use.
- */
-declare class NodeSqliteProvider extends DatabaseProvider {
-  protected readonly kit: DrizzleKitProvider;
-  protected readonly log: alepha_logger3.Logger;
-  protected readonly env: {
-    DATABASE_URL?: string | undefined;
-  };
-  protected readonly builder: SqliteModelBuilder;
-  protected readonly options: Readonly<{
-    path?: string | undefined;
-  }>;
-  protected sqlite: DatabaseSync;
-  get name(): string;
-  readonly dialect = "sqlite";
-  get url(): string;
-  execute(query: SQLLike): Promise<Array<Record<string, unknown>>>;
-  readonly db: PgDatabase<any>;
-  protected readonly onStart: alepha34.HookPrimitive<"start">;
-  protected executeMigrations(migrationsFolder: string): Promise<void>;
-}
 declare namespace index_d_exports {
-  export { $entity, $repository, $sequence, $transaction, AlephaPostgres, BunPostgresProvider, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbConflictError, DbEntityNotFoundError, DbError, DbMigrationError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, NodePostgresProvider, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SequencePrimitive, SequencePrimitiveOptions, StatementOptions, TObjectInsert, TObjectUpdate, TransactionContext, TransactionPrimitiveOptions, buildQueryString, bunSqliteOptions, db, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
+  export { $entity, $repository, $sequence, $transaction, AlephaOrm, BunPostgresProvider, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbConflictError, DbEntityNotFoundError, DbError, DbMigrationError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, NodePostgresProvider, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SequencePrimitive, SequencePrimitiveOptions, SqliteProvider, StatementOptions, TObjectInsert, TObjectUpdate, TransactionContext, TransactionPrimitiveOptions, buildQueryString, bunSqliteOptions, db, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
 }
 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 +2295,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;
@@ -2324,58 +2326,31 @@ declare module "alepha" {
     };
   }
 }
+declare const SqliteProvider: typeof NodeSqliteProvider;
 /**
- * Postgres client based on Drizzle ORM, Alepha type-safe friendly.
- *
- * Automatically selects the appropriate provider based on runtime:
- * - Bun: Uses `BunPostgresProvider` or `BunSqliteProvider`
- * - Node.js: Uses `NodePostgresProvider` or `NodeSqliteProvider`
- *
- * ```ts
- * import { t } from "alepha";
- * import { $entity, $repository, db } from "alepha/postgres";
- *
- * const users = $entity({
- *   name: "users",
- *   schema: t.object({
- *     id: db.primaryKey(),
- *     name: t.text(),
- *     email: t.text(),
- *   }),
- * });
- *
- * class App {
- *   users = $repository(users);
- *
- *   getUserByName(name: string) {
- *     return this.users.findOne({ name: { eq: name } });
- *   }
- * }
- * ```
- *
- * This is not a full ORM, but rather a set of tools to work with Postgres databases in a type-safe way.
+ * | type | quality | stability |
+ * |------|---------|-----------|
+ * | backend | epic | stable |
  *
- * It provides:
- * - A type-safe way to define entities and repositories. (via `$entity` and `$repository`)
- * - Custom query builders and filters.
- * - Built-in special columns like `createdAt`, `updatedAt`, `deletedAt`, `version`.
- * - Automatic JSONB support.
- * - Automatic synchronization of entities with the database schema (for testing and development).
- * - Fallback to raw SQL via Drizzle ORM `sql` function.
+ * Full-featured database abstraction built on Drizzle ORM with complete type safety.
  *
- * Migrations are supported via Drizzle ORM, you need to use the `drizzle-kit` CLI tool to generate and run migrations.
+ * **Features:**
+ * - Define database entities with TypeBox schemas
+ * - Automatic timestamps, soft deletes, and versioning columns
+ * - Type-safe CRUD operations with filtering, pagination, sorting, and relationships
+ * - Database transaction support with automatic rollback
+ * - Auto-incrementing sequences for IDs
+ * - PostgreSQL support (Node.js, Bun, Cloudflare Workers via pglite)
+ * - SQLite support (Node.js, Bun, Cloudflare D1)
+ * - Automatic schema sync for development/testing
+ * - Drizzle Kit migrations for production
+ * - Type-safe filters: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`, `nin`, `like`, `between`
+ * - JSONB column support
+ * - Relationship joins
  *
- * @see {@link $entity}
- * @see {@link $sequence}
- * @see {@link $repository}
- * @see {@link $transaction}
- * @see {@link NodePostgresProvider} - Node.js Postgres implementation
- * @see {@link NodeSqliteProvider} - Node.js SQLite implementation
- * @see {@link BunPostgresProvider} - Bun Postgres implementation
- * @see {@link BunSqliteProvider} - Bun SQLite implementation
  * @module alepha.postgres
  */
-declare const AlephaPostgres: alepha34.Service<alepha34.Module>;
+declare const AlephaOrm: alepha26.Service<alepha26.Module>;
 //#endregion
-export { $entity, $repository, $sequence, $transaction, AlephaPostgres, BunPostgresProvider, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbConflictError, DbEntityNotFoundError, DbError, DbMigrationError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, NodePostgresProvider, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, type Page, type PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SequencePrimitive, SequencePrimitiveOptions, StatementOptions, TObjectInsert, TObjectUpdate, TransactionContext, TransactionPrimitiveOptions, buildQueryString, bunSqliteOptions, db, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
+export { $entity, $repository, $sequence, $transaction, AlephaOrm, BunPostgresProvider, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbConflictError, DbEntityNotFoundError, DbError, DbMigrationError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, NodePostgresProvider, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, type Page, type PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SequencePrimitive, SequencePrimitiveOptions, SqliteProvider, StatementOptions, TObjectInsert, TObjectUpdate, TransactionContext, TransactionPrimitiveOptions, buildQueryString, bunSqliteOptions, db, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
 //# sourceMappingURL=index.d.ts.map