alepha 0.10.6 → 0.11.0

package/postgres.d.ts

@@ -1,80 +1,23 @@
 import * as _alepha_core1 from "alepha";
-import { Alepha, AlephaError, Descriptor, KIND, Service, Static, TArray, TBigInt, TBoolean, TInteger, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOptional, TOptionalAdd, TRecord, TSchema as TSchema$1, TString, TStringOptions, TUnion } from "alepha";
-import * as drizzle_orm6 from "drizzle-orm";
-import { BuildColumns, BuildExtraConfigColumns, SQL, SQLWrapper, TableConfig, sql } from "drizzle-orm";
-import * as pg$1 from "drizzle-orm/pg-core";
-import { AnyPgColumn, AnyPgTable, LockConfig, LockStrength, PgColumn, PgColumnBuilderBase, PgDatabase, PgInsertValue, PgSequenceOptions, PgTableExtraConfigValue, PgTableWithColumns, PgTransaction, PgTransactionConfig, SelectedFields, TableConfig as TableConfig$1, UpdateDeleteAction } from "drizzle-orm/pg-core";
+import { Alepha, AlephaError, Descriptor, DescriptorArgs, KIND, Static, StaticEncode, TArray, TBigInt, TBoolean, TInteger, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOptional, TOptionalAdd, TRecord, TSchema, TString, TStringOptions, TUnion, TUnsafe } from "alepha";
 import { DateTime, DateTimeProvider } from "alepha/datetime";
-import * as _alepha_logger1 from "alepha/logger";
+import * as _alepha_logger0 from "alepha/logger";
 import * as _alepha_lock0 from "alepha/lock";
-import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
-import postgres from "postgres";
 import * as _alepha_retry0 from "alepha/retry";
-import * as typebox1 from "typebox";
+import * as drizzle_orm0 from "drizzle-orm";
+import { BuildExtraConfigColumns, SQL, SQLWrapper, sql } from "drizzle-orm";
+import * as drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
+import { LockConfig, LockStrength, PgColumn, PgColumnBuilderBase, PgDatabase, PgInsertValue, PgSchema, PgSelectBase, PgSequenceOptions, PgTableExtraConfigValue, PgTableWithColumns, PgTransaction, PgTransactionConfig, UpdateDeleteAction } from "drizzle-orm/pg-core";
+import * as typebox9 from "typebox";
 import { PgTransactionConfig as PgTransactionConfig$1 } from "drizzle-orm/pg-core/session";
 import * as DrizzleKit from "drizzle-kit/api";
 import { MigrationConfig } from "drizzle-orm/migrator";
+import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import * as dayjs0 from "dayjs";
 import { UpdateDeleteAction as UpdateDeleteAction$1 } from "drizzle-orm/pg-core/foreign-keys";
 export * from "drizzle-orm/pg-core";
 
-//#region src/constants/PG_SCHEMA.d.ts
-declare const PG_SCHEMA: unique symbol;
-//#endregion
-//#region src/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_MANY: unique symbol;
-declare const PG_ONE: 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 PgMany = typeof PG_MANY;
-type PgOne = typeof PG_ONE;
-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_MANY]: PgManyOptions;
-  [PG_ONE]: PgManyOptions;
-  [PG_REF]: PgRefOptions;
-  /**
-   * @deprecated Use `PG_IDENTITY` instead.
-   */
-  [PG_SERIAL]: {};
-};
-type PgSymbolKeys = keyof PgSymbols;
-type PgIdentityOptions = {
-  mode: "always" | "byDefault";
-} & PgSequenceOptions & {
-  name?: string;
-};
-interface PgManyOptions {
-  table: AnyPgTable;
-  schema: TObject;
-  foreignKey: string;
-}
-interface PgRefOptions {
-  ref: () => AnyPgColumn;
-  actions?: {
-    onUpdate?: UpdateDeleteAction;
-    onDelete?: UpdateDeleteAction;
-  };
-}
-//#endregion
 //#region src/schemas/insertSchema.d.ts
 /**
  * Transforms a TObject schema for insert operations.
@@ -104,484 +47,41 @@ declare const insertSchema: <T extends TObject>(obj: T) => TObjectInsert<T>;
 type TObjectUpdate<T extends TObject> = TObject<{ [K in keyof T["properties"]]: T["properties"][K] extends TOptional<infer U> ? TOptional<TUnion<[U, TNull]>> : T["properties"][K] }>;
 declare const updateSchema: <T extends TObject>(schema: T) => TObjectUpdate<T>;
 //#endregion
-//#region src/helpers/schemaToPgColumns.d.ts
-/**
- * Convert a Typebox Schema to Drizzle ORM Postgres columns
- */
-declare const schemaToPgColumns: <T extends TObject>(schema: T) => FromSchema<T>;
-/**
- * Map a Typebox field to a PG column.
- *
- * @param name The key of the field.
- * @param value The value of the field.
- * @returns The PG column.
- */
-declare const mapFieldToColumn: (name: string, value: TSchema$1) => pg$1.PgSerialBuilderInitial<string> | pg$1.PgIntegerBuilderInitial<string> | drizzle_orm6.IsIdentity<pg$1.PgBigInt64BuilderInitial<"">, "byDefault"> | drizzle_orm6.IsIdentity<pg$1.PgBigInt64BuilderInitial<"">, "always"> | pg$1.PgBigInt53BuilderInitial<string> | pg$1.PgNumericBuilderInitial<string> | pg$1.PgDateStringBuilderInitial<string> | pg$1.PgUUIDBuilderInitial<string> | pg$1.PgCustomColumnBuilder<{
-  name: string;
-  dataType: "custom";
-  columnType: "PgCustomColumn";
-  data: Buffer<ArrayBufferLike>;
-  driverParam: unknown;
-  enumValues: undefined;
-}> | pg$1.PgTimestampStringBuilderInitial<string> | pg$1.PgTextBuilderInitial<string, [string, ...string[]]> | pg$1.PgBooleanBuilderInitial<string> | drizzle_orm6.$Type<pg$1.PgCustomColumnBuilder<{
-  name: string;
-  dataType: "custom";
-  columnType: "PgCustomColumn";
-  data: {
-    [x: string]: unknown;
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-  };
-  driverParam: string;
-  enumValues: undefined;
-}>, {
-  [x: string]: unknown;
-  [x: number]: unknown;
-  [x: symbol]: unknown;
-}> | drizzle_orm6.$Type<pg$1.PgCustomColumnBuilder<{
-  name: string;
-  dataType: "custom";
-  columnType: "PgCustomColumn";
-  data: Record<string, unknown>;
-  driverParam: string;
-  enumValues: undefined;
-}>, Record<string, unknown>> | drizzle_orm6.$Type<pg$1.PgCustomColumnBuilder<{
-  name: string;
-  dataType: "custom";
-  columnType: "PgCustomColumn";
-  data: unknown[];
-  driverParam: string;
-  enumValues: undefined;
-}>, unknown[]> | pg$1.PgArrayBuilder<{
-  name: string;
-  dataType: "array";
-  columnType: "PgArray";
-  data: string[];
-  driverParam: string | string[];
-  enumValues: [string, ...string[]];
-  size: undefined;
-  baseBuilder: {
-    name: string;
-    dataType: "string";
-    columnType: "PgText";
-    data: string;
-    enumValues: [string, ...string[]];
-    driverParam: string;
-  };
-}, {
-  name: string;
-  dataType: "string";
-  columnType: "PgText";
-  data: string;
-  enumValues: [string, ...string[]];
-  driverParam: string;
-}> | pg$1.PgArrayBuilder<{
-  name: string;
-  dataType: "array";
-  columnType: "PgArray";
-  data: number[];
-  driverParam: string | (string | number)[];
-  enumValues: undefined;
-  size: undefined;
-  baseBuilder: {
-    name: string;
-    dataType: "number";
-    columnType: "PgInteger";
-    data: number;
-    driverParam: number | string;
-    enumValues: undefined;
-  };
-}, {
-  name: string;
-  dataType: "number";
-  columnType: "PgInteger";
-  data: number;
-  driverParam: number | string;
-  enumValues: undefined;
-}> | pg$1.PgArrayBuilder<{
-  name: string;
-  dataType: "array";
-  columnType: "PgArray";
-  data: string[];
-  driverParam: string | string[];
-  enumValues: undefined;
-  size: undefined;
-  baseBuilder: {
-    name: string;
-    dataType: "string";
-    columnType: "PgNumeric";
-    data: string;
-    driverParam: string;
-    enumValues: undefined;
-  };
-}, {
-  name: string;
-  dataType: "string";
-  columnType: "PgNumeric";
-  data: string;
-  driverParam: string;
-  enumValues: undefined;
-}> | pg$1.PgArrayBuilder<{
-  name: string;
-  dataType: "array";
-  columnType: "PgArray";
-  data: boolean[];
-  driverParam: string | boolean[];
-  enumValues: undefined;
-  size: undefined;
-  baseBuilder: {
-    name: string;
-    dataType: "boolean";
-    columnType: "PgBoolean";
-    data: boolean;
-    driverParam: boolean;
-    enumValues: undefined;
-  };
-}, {
-  name: string;
-  dataType: "boolean";
-  columnType: "PgBoolean";
-  data: boolean;
-  driverParam: boolean;
-  enumValues: undefined;
-}>;
-/**
- * Map a string to a PG column.
- *
- * @param key The key of the field.
- * @param value The value of the field.
- */
-declare const mapStringToColumn: (key: string, value: TSchema$1) => pg$1.PgDateStringBuilderInitial<string> | pg$1.PgUUIDBuilderInitial<string> | pg$1.PgCustomColumnBuilder<{
-  name: string;
-  dataType: "custom";
-  columnType: "PgCustomColumn";
-  data: Buffer<ArrayBufferLike>;
-  driverParam: unknown;
-  enumValues: undefined;
-}> | pg$1.PgTimestampStringBuilderInitial<string> | pg$1.PgTextBuilderInitial<string, [string, ...string[]]>;
-declare const camelToSnakeCase: (str: string) => string;
-/**
- * Convert a schema to columns.
- */
-type FromSchema<T extends TObject> = { [key in keyof T["properties"]]: PgColumnBuilderBase };
-/**
- * A table with columns and schema.
- */
-type PgTableWithColumnsAndSchema<T extends TableConfig, R extends TObject> = PgTableWithColumns<T> & {
-  get $table(): PgTableWithColumns<T>;
-  get $schema(): R;
-  get $insertSchema(): TObjectInsert<R>;
-  get $updateSchema(): TObjectUpdate<R>;
-};
-//#endregion
 //#region src/descriptors/$entity.d.ts
 /**
  * Creates a database entity descriptor that defines table structure using TypeBox schemas.
  *
- * This descriptor provides a type-safe way to define database tables using JSON Schema
- * syntax while generating the necessary database metadata for migrations and operations.
- * It integrates with Drizzle ORM under the hood and works seamlessly with the $repository
- * descriptor for complete database functionality.
- *
- * **Key Features**
- *
- * - **Type-Safe Schema Definition**: Uses TypeBox for full TypeScript type inference
- * - **Automatic Table Generation**: Creates Drizzle ORM table structures automatically
- * - **Index Management**: Supports single-column, multi-column, and unique indexes
- * - **Constraint Support**: Foreign keys, unique constraints, and check constraints
- * - **Audit Fields**: Built-in support for created_at, updated_at, deleted_at, and version fields
- * - **Schema Validation**: Automatic insert/update schema generation with validation
- *
- * **Important Note**:
- * This descriptor only defines the table structure - it does not create the physical
- * database table. Use it with $repository to perform actual database operations,
- * and run migrations to create the tables in your database.
- *
- * **Use Cases**
- *
- * Essential for defining database schema in type-safe applications:
- * - User management and authentication tables
- * - Business domain entities (products, orders, customers)
- * - Audit and logging tables
- * - Junction tables for many-to-many relationships
- * - Configuration and settings tables
- *
  * @example
- * **Basic entity with indexes:**
  * ```ts
+ * import { t } from "alepha";
  * import { $entity } from "alepha/postgres";
- * import { pg, t } from "alepha";
  *
- * const User = $entity({
+ * const userEntity = $entity({
  *   name: "users",
  *   schema: t.object({
- *     id: pg.primaryKey(t.uuid()),
- *     email: t.text({ format: "email" }),
- *     username: t.text({ minLength: 3, maxLength: 30 }),
- *     firstName: t.text(),
- *     lastName: t.text(),
- *     isActive: t.boolean({ default: true }),
- *     createdAt: pg.createdAt(),
- *     updatedAt: pg.updatedAt(),
- *     deletedAt: pg.deletedAt()
- *   }),
- *   indexes: [
- *     "email",              // Simple index on email
- *     "username",           // Simple index on username
- *     { column: "email", unique: true },  // Unique constraint on email
- *     { columns: ["firstName", "lastName"] } // Composite index
- *   ]
- * });
- * ```
- *
- * @example
- * **E-commerce product entity with relationships:**
- * ```ts
- * const Product = $entity({
- *   name: "products",
- *   schema: t.object({
- *     id: pg.primaryKey(t.uuid()),
- *     sku: t.text({ minLength: 3 }),
- *     name: t.text({ minLength: 1, maxLength: 200 }),
- *     description: t.optional(t.text()),
- *     price: t.number({ minimum: 0 }),
- *     categoryId: t.text({ format: "uuid" }),
- *     inStock: t.boolean({ default: true }),
- *     stockQuantity: t.integer({ minimum: 0, default: 0 }),
- *     tags: t.optional(t.array(t.text())), // PostgreSQL array column
- *     metadata: t.optional(t.record(t.text(), t.any())), // JSONB column
- *     version: pg.version(),
- *     createdAt: pg.createdAt(),
- *     updatedAt: pg.updatedAt()
- *   }),
- *   indexes: [
- *     { column: "sku", unique: true },        // Unique SKU
- *     "categoryId",                           // Foreign key index
- *     "inStock",                             // Filter frequently by stock status
- *     { columns: ["categoryId", "inStock"] }, // Composite for category + stock queries
- *     "createdAt"                            // For date-based queries
- *   ],
- *   foreignKeys: [
- *     {
- *       name: "fk_product_category",
- *       columns: ["categoryId"],
- *       foreignColumns: [Category.id] // Reference to Category entity
- *     }
- *   ]
- * });
- * ```
- *
- * @example
- * **Audit log entity with constraints:**
- * ```ts
- * const AuditLog = $entity({
- *   name: "audit_logs",
- *   schema: t.object({
- *     id: pg.primaryKey(t.uuid()),
- *     tableName: t.text(),
- *     recordId: t.text(),
- *     action: t.enum(["CREATE", "UPDATE", "DELETE"]),
- *     userId: t.optional(t.text({ format: "uuid" })),
- *     oldValues: t.optional(t.record(t.text(), t.any())),
- *     newValues: t.optional(t.record(t.text(), t.any())),
- *     timestamp: pg.createdAt(),
- *     ipAddress: t.optional(t.text()),
- *     userAgent: t.optional(t.text())
- *   }),
- *   indexes: [
- *     "tableName",
- *     "recordId",
- *     "userId",
- *     "action",
- *     { columns: ["tableName", "recordId"] }, // Find all changes to a record
- *     { columns: ["userId", "timestamp"] },   // User activity timeline
- *     "timestamp"  // Time-based queries
- *   ],
- *   constraints: [
- *     {
- *       name: "valid_action_values",
- *       columns: ["action"],
- *       check: sql`action IN ('CREATE', 'UPDATE', 'DELETE')`
- *     }
- *   ]
- * });
- * ```
- *
- * @example
- * **Many-to-many junction table:**
- * ```ts
- * const UserRole = $entity({
- *   name: "user_roles",
- *   schema: t.object({
- *     id: pg.primaryKey(t.uuid()),
- *     userId: t.text({ format: "uuid" }),
- *     roleId: t.text({ format: "uuid" }),
- *     assignedBy: t.text({ format: "uuid" }),
- *     assignedAt: pg.createdAt(),
- *     expiresAt: t.optional(t.datetime())
- *   }),
- *   indexes: [
- *     "userId",
- *     "roleId",
- *     "assignedBy",
- *     { columns: ["userId", "roleId"], unique: true }, // Prevent duplicate assignments
- *     "expiresAt" // For cleanup of expired roles
- *   ],
- *   foreignKeys: [
- *     {
- *       columns: ["userId"],
- *       foreignColumns: [User.id]
- *     },
- *     {
- *       columns: ["roleId"],
- *       foreignColumns: [Role.id]
- *     },
- *     {
- *       columns: ["assignedBy"],
- *       foreignColumns: [User.id]
- *     }
- *   ]
- * });
- * ```
- *
- * @example
- * **Entity with custom Drizzle configuration:**
- * ```ts
- * const Order = $entity({
- *   name: "orders",
- *   schema: t.object({
- *     id: pg.primaryKey(t.uuid()),
- *     orderNumber: t.text(),
- *     customerId: t.text({ format: "uuid" }),
- *     status: t.enum(["pending", "processing", "shipped", "delivered"]),
- *     totalAmount: t.number({ minimum: 0 }),
- *     currency: t.text({ default: "USD" }),
- *     notes: t.optional(t.text()),
- *     createdAt: pg.createdAt(),
- *     updatedAt: pg.updatedAt(),
- *     version: pg.version()
+ *     id: pg.primaryKey(),
+ *     name: t.text(),
+ *     email: t.email(),
  *   }),
- *   indexes: [
- *     { column: "orderNumber", unique: true },
- *     "customerId",
- *     "status",
- *     "createdAt",
- *     { columns: ["customerId", "status"] }
- *   ],
- *   // Advanced Drizzle ORM configuration
- *   config: (table) => [
- *     // Custom index with specific options
- *     index("idx_orders_amount_status")
- *       .on(table.totalAmount, table.status)
- *       .where(sql`status != 'cancelled'`), // Partial index
- *
- *     // Full-text search index (PostgreSQL specific)
- *     index("idx_orders_search")
- *       .using("gin", table.notes)
- *   ]
  * });
  * ```
- *
- * @stability 2
  */
 declare const $entity: {
-  <TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>>(options: EntityDescriptorOptions<TTableName, TSchema>): PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
-  [KIND]: string;
+  <TSchema$1 extends TObject>(options: EntityDescriptorOptions<TSchema$1>): EntityDescriptor<TSchema$1>;
+  [KIND]: typeof EntityDescriptor;
 };
-interface EntityDescriptorOptions<TTableName extends string, T extends TObject, Keys = keyof Static<T>> {
+interface EntityDescriptorOptions<T extends TObject, Keys = keyof Static<T>> {
   /**
    * The database table name that will be created for this entity.
-   *
-   * This name:
-   * - Must be unique within your database schema
-   * - Should follow your database naming conventions (typically snake_case)
-   * - Will be used in generated SQL queries and migrations
-   * - Should be descriptive of the entity's purpose
-   *
-   * **Naming Guidelines**:
-   * - Use plural nouns for table names ("users", "products", "orders")
-   * - Use snake_case for multi-word names ("user_profiles", "order_items")
-   * - Keep names concise but descriptive
-   * - Avoid SQL reserved words
-   *
-   * @example "users"
-   * @example "product_categories"
-   * @example "user_roles"
-   * @example "audit_logs"
+   * If not provided, name will be inferred from the $repository variable name.
    */
-  name: TTableName;
+  name: string;
   /**
    * TypeBox schema defining the table structure and column types.
-   *
-   * This schema:
-   * - Defines all table columns with their types and constraints
-   * - Provides full TypeScript type inference for the entity
-   * - Supports validation rules and default values
-   * - Enables automatic insert/update schema generation
-   * - Must include exactly one primary key field marked with `pg.primaryKey()`
-   *
-   * **Supported PostgreSQL Types**:
-   * - `pg.primaryKey(t.uuid())` - UUID primary key
-   * - `t.text()` - VARCHAR column
-   * - `t.integer()`, `t.number()` - Numeric columns
-   * - `t.boolean()` - Boolean column
-   * - `t.array(t.text())` - PostgreSQL array column
-   * - `t.record(t.text(), t.any())` - JSONB column
-   * - `pg.createdAt()`, `pg.updatedAt()`, `pg.deletedAt()` - Audit timestamps
-   * - `pg.version()` - Optimistic locking version field
-   *
-   * **Schema Best Practices**:
-   * - Always include a primary key
-   * - Use appropriate TypeBox constraints (minLength, format, etc.)
-   * - Add audit fields for trackability
-   * - Use optional fields for nullable columns
-   * - Include foreign key columns for relationships
-   *
-   * @example
-   * ```ts
-   * t.object({
-   *   id: pg.primaryKey(t.uuid()),
-   *   email: t.text({ format: "email" }),
-   *   firstName: t.text({ minLength: 1, maxLength: 100 }),
-   *   lastName: t.text({ minLength: 1, maxLength: 100 }),
-   *   age: t.optional(t.integer({ minimum: 0, maximum: 150 })),
-   *   isActive: t.boolean({ default: true }),
-   *   preferences: t.optional(t.record(t.text(), t.any())),
-   *   tags: t.optional(t.array(t.text())),
-   *   createdAt: pg.createdAt(),
-   *   updatedAt: pg.updatedAt(),
-   *   version: pg.version()
-   * })
-   * ```
    */
   schema: T;
   /**
    * Database indexes to create for query optimization.
-   *
-   * Indexes improve query performance but consume disk space and slow down writes.
-   * Choose indexes based on your actual query patterns and performance requirements.
-   *
-   * **Index Types**:
-   * - **Simple string**: Creates a single-column index
-   * - **Single column object**: Creates index on one column with options
-   * - **Multi-column object**: Creates composite index on multiple columns
-   *
-   * **Index Guidelines**:
-   * - Index frequently queried columns (WHERE, ORDER BY, JOIN conditions)
-   * - Create unique indexes for business constraints
-   * - Use composite indexes for multi-column queries
-   * - Index foreign key columns for join performance
-   * - Monitor index usage and remove unused indexes
-   *
-   * **Performance Considerations**:
-   * - Each index increases storage requirements
-   * - Indexes slow down INSERT/UPDATE/DELETE operations
-   * - PostgreSQL can use multiple indexes in complex queries
-   * - Partial indexes can be more efficient for filtered queries
-   *
-   * @example ["email", "createdAt", { column: "username", unique: true }]
-   * @example [{ columns: ["userId", "status"], name: "idx_user_status" }]
-   * @example ["categoryId", { columns: ["price", "inStock"] }]
    */
   indexes?: (Keys | {
     /**
@@ -612,35 +112,6 @@ interface EntityDescriptorOptions<TTableName extends string, T extends TObject,
   })[];
   /**
    * Foreign key constraints to maintain referential integrity.
-   *
-   * Foreign keys ensure that values in specified columns must exist in the referenced table.
-   * They prevent orphaned records and maintain database consistency.
-   *
-   * **Foreign Key Benefits**:
-   * - Prevents invalid references to non-existent records
-   * - Maintains data integrity automatically
-   * - Provides clear schema documentation of relationships
-   * - Enables cascade operations (DELETE, UPDATE)
-   *
-   * **Considerations**:
-   * - Foreign keys can impact performance on large tables
-   * - They prevent deletion of referenced records
-   * - Consider cascade options for related data cleanup
-   *
-   * @example
-   * ```ts
-   * foreignKeys: [
-   *   {
-   *     name: "fk_user_role",
-   *     columns: ["roleId"],
-   *     foreignColumns: [Role.id]
-   *   },
-   *   {
-   *     columns: ["createdBy"],
-   *     foreignColumns: [User.id]
-   *   }
-   * ]
-   * ```
    */
   foreignKeys?: Array<{
     /**
@@ -653,8 +124,9 @@ interface EntityDescriptorOptions<TTableName extends string, T extends TObject,
     columns: Array<keyof Static<T>>;
     /**
      * Referenced columns in the foreign table.
+     * Must be EntityColumn references from other entities.
      */
-    foreignColumns: Array<AnyPgColumn>;
+    foreignColumns: Array<() => EntityColumn<any>>;
   }>;
   /**
    * Additional table constraints for data validation.
@@ -666,12 +138,6 @@ interface EntityDescriptorOptions<TTableName extends string, T extends TObject,
    * - **Unique constraints**: Prevent duplicate values across columns
    * - **Check constraints**: Enforce custom validation rules with SQL expressions
    *
-   * **Use Cases**:
-   * - Enforce unique combinations of columns
-   * - Validate value ranges or patterns
-   * - Ensure consistent data states
-   * - Implement business rule validation
-   *
    * @example
    * ```ts
    * constraints: [
@@ -713,52 +179,86 @@ interface EntityDescriptorOptions<TTableName extends string, T extends TObject,
   }>;
   /**
    * Advanced Drizzle ORM configuration for complex table setups.
-   *
-   * This allows you to use advanced Drizzle ORM features that aren't covered
-   * by the simplified options above. Use this for:
-   * - Custom index types (GIN, GIST, etc.)
-   * - Partial indexes with WHERE clauses
-   * - Advanced constraint configurations
-   * - PostgreSQL-specific features
-   *
-   * **When to Use**:
-   * - Need PostgreSQL-specific index types
-   * - Require partial indexes for performance
-   * - Want fine-grained control over table creation
-   * - Using advanced PostgreSQL features
-   *
-   * See Drizzle ORM documentation for complete configuration options.
-   *
-   * @param self - The table columns available for configuration
-   * @returns Array of Drizzle table configuration objects
-   *
-   * @example
-   * ```ts
-   * config: (table) => [
-   *   // Partial index for active users only
-   *   index("idx_active_users_email")
-   *     .on(table.email)
-   *     .where(sql`is_active = true`),
-   *
-   *   // GIN index for full-text search
-   *   index("idx_content_search")
-   *     .using("gin", table.searchVector),
-   *
-   *   // Unique constraint with custom options
-   *   uniqueIndex("idx_unique_slug_per_tenant")
-   *     .on(table.tenantId, table.slug)
-   * ]
-   * ```
    */
   config?: (self: BuildExtraConfigColumns<string, FromSchema<T>, "pg">) => PgTableExtraConfigValue[];
 }
-type Entity<T extends TObject> = PgTableWithColumnsAndSchema<PgTableConfig<string, T, FromSchema<T>>, T>;
-type PgTableConfig<TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>> = {
-  name: TTableName;
-  schema: any;
-  columns: BuildColumns<TTableName, TColumnsMap, "pg">;
-  dialect: "pg";
+declare class EntityDescriptor<T extends TObject = TObject> {
+  readonly options: EntityDescriptorOptions<T>;
+  constructor(options: EntityDescriptorOptions<T>);
+  alias(alias: string): this;
+  get cols(): EntityColumns<T>;
+  get name(): string;
+  get schema(): T;
+  get insertSchema(): TObjectInsert<T>;
+  get updateSchema(): TObjectUpdate<T>;
+}
+/**
+ * Convert a schema to columns.
+ */
+type FromSchema<T extends TObject> = { [key in keyof T["properties"]]: PgColumnBuilderBase };
+type SchemaToTableConfig<T extends TObject> = {
+  name: string;
+  schema: string | undefined;
+  columns: { [key in keyof T["properties"]]: PgColumn };
+  dialect: string;
+};
+type EntityColumn<T extends TObject> = {
+  name: string;
+  entity: EntityDescriptor<T>;
+};
+type EntityColumns<T extends TObject> = { [key in keyof T["properties"]]: EntityColumn<T> };
+//#endregion
+//#region src/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;
+}
+interface PgRefOptions {
+  ref: () => {
+    name: string;
+    entity: EntityDescriptor;
+  };
+  actions?: {
+    onUpdate?: UpdateDeleteAction;
+    onDelete?: UpdateDeleteAction;
+  };
+}
 //#endregion
 //#region src/errors/PgError.d.ts
 declare class PgError extends AlephaError {
@@ -782,7 +282,7 @@ declare class PgError extends AlephaError {
  * );
  * ```
  */
-declare const pgAttr: <T extends TSchema$1, Attr extends PgSymbolKeys>(type: T, attr: Attr, value?: PgSymbols[Attr]) => PgAttr<T, Attr>;
+declare const pgAttr: <T extends TSchema, Attr extends PgSymbolKeys>(type: T, attr: Attr, value?: PgSymbols[Attr]) => PgAttr<T, Attr>;
 /**
  * Retrieves the fields of a schema that have a specific attribute.
  */
@@ -790,10 +290,10 @@ declare const getAttrFields: (schema: TObject, name: PgSymbolKeys) => PgAttrFiel
 /**
  * Type representation.
  */
-type PgAttr<T extends TSchema$1, TAttr extends PgSymbolKeys> = T & { [K in TAttr]: PgSymbols[K] };
+type PgAttr<T extends TSchema, TAttr extends PgSymbolKeys> = T & { [K in TAttr]: PgSymbols[K] };
 interface PgAttrField {
   key: string;
-  type: TSchema$1;
+  type: TSchema;
   data: any;
   nested?: any[];
   one?: boolean;
@@ -1156,7 +656,10 @@ interface FilterOperators<TValue> {
 }
 //#endregion
 //#region src/interfaces/PgQueryWhere.d.ts
-type PgQueryWhere<T extends TObject> = { [Key in keyof Static<T>]?: FilterOperators<Static<T>[Key]> | Static<T>[Key] } & {
+type PgQueryWhere<T extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = (PgQueryWhereOperators<T> & PgQueryWhereConditions<T>) | (PgQueryWhereRelations<Relations> & PgQueryWhereOperators<T> & PgQueryWhereConditions<T, Relations>);
+type PgQueryWhereOrSQL<T extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = SQLWrapper | PgQueryWhere<T, Relations>;
+type PgQueryWhereOperators<T extends TObject> = { [Key in keyof Static<T>]?: FilterOperators<Static<T>[Key]> | Static<T>[Key] | (Static<T>[Key] extends object ? NestedJsonbQuery<Static<T>[Key]> : never) };
+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.
@@ -1173,7 +676,7 @@ type PgQueryWhere<T extends TObject> = { [Key in keyof Static<T>]?: FilterOperat
    *   )
    * ```
    */
-  and?: Array<PgQueryWhereOrSQL<T>>;
+  and?: Array<PgQueryWhereOrSQL<T, Relations>>;
   /**
    * Combine a list of conditions with the `or` operator. Conditions
    * that are equal `undefined` are automatically ignored.
@@ -1190,7 +693,7 @@ type PgQueryWhere<T extends TObject> = { [Key in keyof Static<T>]?: FilterOperat
    *   )
    * ```
    */
-  or?: Array<PgQueryWhereOrSQL<T>>;
+  or?: Array<PgQueryWhereOrSQL<T, Relations>>;
   /**
    * Negate the meaning of an expression using the `not` keyword.
    *
@@ -1202,7 +705,7 @@ type PgQueryWhere<T extends TObject> = { [Key in keyof Static<T>]?: FilterOperat
    *   .where(not(inArray(cars.make, ['GM', 'Ford'])))
    * ```
    */
-  not?: PgQueryWhereOrSQL<T>;
+  not?: PgQueryWhereOrSQL<T, Relations>;
   /**
    * Test whether a subquery evaluates to have any rows.
    *
@@ -1225,26 +728,11 @@ type PgQueryWhere<T extends TObject> = { [Key in keyof Static<T>]?: FilterOperat
    */
   exists?: SQLWrapper;
 };
-type PgQueryWhereOrSQL<T extends TObject> = SQLWrapper | PgQueryWhere<T>;
-type PgQueryWhereWithManyOrSQL<T extends TObject> = SQLWrapper | PgQueryWhereWithMany<T>;
-type PgQueryWhereWithMany<T extends TObject> = PgQueryWhere<RemoveManyRelations<T>> & ExtractManyRelations<T>;
-type RelField = {
-  [PG_MANY]: any;
-} | {
-  [PG_ONE]: any;
-};
-type ExtractManyRelations<T extends TObject> = { [K in keyof T["properties"] as T["properties"][K] extends RelField ? T["properties"][K] extends TArray ? T["properties"][K]["items"] extends TObject ? K : never : never : T["properties"][K] extends TObject ? K : never]?: PgQueryWhere<T["properties"][K] extends TArray ? T["properties"][K]["items"] extends TObject ? T["properties"][K]["items"] : TObject : T["properties"][K] extends TObject ? T["properties"][K] : TObject> };
-type RemoveManyRelations<T extends TObject> = TObject<{ [K in keyof T["properties"] as T["properties"][K] extends RelField ? never : K]: T["properties"][K] }>;
-type PgQueryWithMap<T extends TObject> = { [K in keyof T["properties"] as T["properties"][K] extends RelField ? K : never]?: T["properties"][K] extends TArray ? T["properties"][K]["items"] extends TObject ? PgQueryWithMany<T["properties"][K]["items"]> : never : T["properties"][K] extends TObject ? PgQueryWithOne<T["properties"][K]> : T["properties"][K] extends PgAttr<PgAttr<TOptionalAdd<infer U>, PgOne>, PgDefault> ? U extends TObject ? PgQueryWithOne<U> : never : never };
-type PgQueryWithOne<T extends TObject> = true | {
-  columns?: (keyof Static<T>)[];
-  relations?: PgQueryWithMap<T>;
-};
-type PgQueryWithMany<T extends TObject> = true | {
-  limit?: number;
-  columns?: (keyof Static<T>)[];
-  relations?: PgQueryWithMap<T>;
-};
+type PgQueryWhereRelations<Relations extends PgRelationMap<TObject> | undefined = undefined> = Relations extends PgRelationMap<TObject> ? { [K in keyof Relations]?: PgQueryWhere<Relations[K]["join"]["schema"], Relations[K]["with"]> } : {};
+/**
+ * Recursively allow nested queries for JSONB object/array types
+ */
+type NestedJsonbQuery<T> = T extends object ? T extends Array<infer U> ? U extends object ? { [K in keyof U]?: FilterOperators<U[K]> | U[K] } : FilterOperators<U> | U : { [K in keyof T]?: FilterOperators<T[K]> | T[K] | (T[K] extends object ? NestedJsonbQuery<T[K]> : never) } : FilterOperators<T> | T;
 //#endregion
 //#region src/interfaces/PgQuery.d.ts
 /**
@@ -1265,32 +753,140 @@ interface OrderByClause<T> {
  * 3. Array: orderBy: [{ column: "name", direction: "asc" }, { column: "age", direction: "desc" }]
  */
 type OrderBy<T> = keyof T | OrderByClause<T> | Array<OrderByClause<T>>;
+/**
+ * Generic query interface for PostgreSQL entities
+ */
 interface PgQuery<T extends TObject = TObject> {
-  distinct?: boolean;
-  where?: PgQueryWhereWithMany<T> | SQLWrapper;
+  distinct?: (keyof Static<T>)[];
+  columns?: (keyof Static<T>)[];
+  where?: PgQueryWhereOrSQL<T>;
   limit?: number;
   offset?: number;
   orderBy?: OrderBy<Static<T>>;
   groupBy?: (keyof Static<T>)[];
-  relations?: PgQueryWithMap<T>;
+}
+type PgStatic<T extends TObject, Relations extends PgRelationMap<T>> = Static<T> & { [K in keyof Relations]: Static<Relations[K]["join"]["schema"]> & (Relations[K]["with"] extends PgRelationMap<TObject> ? PgStatic<Relations[K]["join"]["schema"], Relations[K]["with"]> : {}) };
+interface PgQueryRelations<T extends TObject = TObject, Relations extends PgRelationMap<T> | undefined = undefined> extends PgQuery<T> {
+  with?: Relations;
+  where?: PgQueryWhereOrSQL<T, Relations>;
+}
+type PgRelationMap<Base extends TObject> = Record<string, PgRelation<Base>>;
+type PgRelation<Base extends TObject> = {
+  type?: "left" | "inner" | "right";
+  join: {
+    schema: TObject;
+    name: string;
+  };
+  on: SQLWrapper | [keyof Static<Base>, {
+    name: string;
+  }];
+  with?: PgRelationMap<TObject>;
+};
+//#endregion
+//#region src/descriptors/$sequence.d.ts
+/**
+ * Creates a PostgreSQL sequence descriptor for generating unique numeric values.
+ */
+declare const $sequence: {
+  (options?: SequenceDescriptorOptions): SequenceDescriptor;
+  [KIND]: typeof SequenceDescriptor;
+};
+interface SequenceDescriptorOptions extends PgSequenceOptions {
+  /**
+   * The name of the sequence. If not provided, the property key will be used.
+   */
+  name?: string;
+  provider?: DatabaseProvider;
+}
+declare class SequenceDescriptor extends Descriptor<SequenceDescriptorOptions> {
+  readonly provider: DatabaseProvider;
+  onInit(): void;
+  get name(): string;
+  next(): Promise<number>;
+  current(): Promise<number>;
+  protected $provider(): DatabaseProvider;
 }
 //#endregion
-//#region src/providers/drivers/PostgresProvider.d.ts
+//#region src/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 Descriptors (Entity, Sequence, etc...)
+ * into drizzle models (tables, enums, sequences, etc...).
+ */
+declare abstract class ModelBuilder {
+  /**
+   * Build a table from an entity descriptor.
+   */
+  abstract buildTable(entity: EntityDescriptor, options: {
+    tables: Map<string, unknown>;
+    enums: Map<string, unknown>;
+    schema: string;
+  }): void;
+  /**
+   * Build a sequence from a sequence descriptor.
+   */
+  abstract buildSequence(sequence: SequenceDescriptor, 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 descriptor
+   * @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: EntityDescriptor, builders: TableConfigBuilders<TConfig>, tableResolver?: (entityName: string) => any, customConfigHandler?: (config: any, self: TSelf) => TConfig[]): ((self: TSelf) => TConfig[]) | undefined;
+}
+//#endregion
+//#region src/providers/drivers/DatabaseProvider.d.ts
 type SQLLike = SQLWrapper | string;
-declare abstract class PostgresProvider {
+declare abstract class DatabaseProvider {
   protected readonly alepha: Alepha;
-  abstract get db(): PgDatabase<any>;
-  readonly dialect: "postgres" | "sqlite";
+  protected abstract readonly builder: ModelBuilder;
+  abstract readonly db: PgDatabase<any>;
+  abstract readonly dialect: "postgres" | "sqlite";
+  readonly enums: Map<string, unknown>;
+  readonly tables: Map<string, unknown>;
+  readonly sequences: Map<string, unknown>;
+  table<T extends TObject>(entity: EntityDescriptor<T>): PgTableWithColumns<SchemaToTableConfig<T>>;
   get schema(): string;
-  execute<T extends TObject | undefined>(query: SQLLike, schema?: T): Promise<Array<T extends TObject ? Static<T> : any>>;
-  protected mapResult<T extends TObject = any>(result: Array<any>, schema?: T): Array<T extends TObject ? Static<T> : any>;
+  registerEntity(entity: EntityDescriptor): void;
+  registerSequence(sequence: SequenceDescriptor): void;
+  abstract execute(statement: SQLLike): Promise<Record<string, unknown>[]>;
+  run<T extends TObject>(statement: SQLLike, schema: T): Promise<Array<Static<T>>>;
 }
 //#endregion
 //#region src/schemas/pageQuerySchema.d.ts
-declare const pageQuerySchema: typebox1.TObject<{
-  page: typebox1.TOptional<typebox1.TInteger>;
-  size: typebox1.TOptional<typebox1.TInteger>;
-  sort: typebox1.TOptional<typebox1.TString>;
+declare const pageQuerySchema: typebox9.TObject<{
+  page: typebox9.TOptional<typebox9.TInteger>;
+  size: typebox9.TOptional<typebox9.TInteger>;
+  sort: typebox9.TOptional<typebox9.TString>;
 }>;
 type PageQuery = Static<typeof pageQuerySchema>;
 //#endregion
@@ -1298,9 +894,13 @@ type PageQuery = Static<typeof pageQuerySchema>;
 /**
  * Create a pagination schema for the given object schema.
  *
+ * > use `pg.page` directly.
+ *
  * @example
+ * ```ts
  * const userSchema = t.object({ id: t.int(), name: t.text() });
- * const pagedUserSchema = pageSchema(userSchema);
+ * const userPageSchema = pageSchema(userSchema);
+ * ```
  *
  * @see {@link $repository#paginate}
  */
@@ -1317,106 +917,218 @@ type TPage<T extends TObject | TRecord> = TObject<{
     totalElements: TOptionalAdd<TInteger>;
   }>;
 }>;
+/**
+ * Opinionated type definition for a paginated response.
+ *
+ * @example
+ * ```ts
+ * const page = {
+ *   content: [ ... ]
+ *   can: {
+ *     next: true,
+ *     previous: false
+ *   },
+ *   page: {
+ *     number: 0,
+ *     size: 10,
+ *     totalElements: 1200
+ *   }
+ * }
+ * ```
+ */
 type Page<T> = {
+  /**
+   * Array of items on the current page.
+   */
   content: T[];
   can: {
+    /**
+     * Indicates if there is a next page.
+     */
     next: boolean;
+    /**
+     * Indicates if there is a previous page.
+     */
     previous: boolean;
   };
   page: {
+    /**
+     * Page number, starting from 0.
+     */
     number: number;
+    /**
+     * Number of items per page.
+     */
     size: number;
+    /**
+     * Requires `count: true` in the paginate options.
+     */
     totalElements?: number;
   };
 };
 //#endregion
+//#region src/services/PgJsonQueryManager.d.ts
+/**
+ * Manages JSONB query generation for nested object and array queries in PostgreSQL.
+ * This class handles complex nested queries using PostgreSQL's JSONB operators.
+ */
+declare class PgJsonQueryManager {
+  /**
+   * Check if a query contains nested JSONB queries.
+   * A nested query is when the value is an object with operator keys.
+   */
+  hasNestedQuery(where: PgQueryWhere<TObject>): boolean;
+  /**
+   * Build a JSONB query condition for nested object queries.
+   * Supports deep nesting like: { profile: { contact: { email: { eq: "test@example.com" } } } }
+   *
+   * @param column The JSONB column
+   * @param path The path to the nested property (e.g., ['profile', 'contact', 'email'])
+   * @param operator The filter operator (e.g., { eq: "test@example.com" })
+   * @returns SQL condition
+   */
+  buildJsonbCondition(column: PgColumn, path: string[], operator: FilterOperators<any>): SQL | undefined;
+  /**
+   * Build JSONB array query conditions.
+   * Supports queries like: { addresses: { city: { eq: "Wonderland" } } }
+   * which translates to: EXISTS (SELECT 1 FROM jsonb_array_elements(addresses) elem WHERE elem->>'city' = 'Wonderland')
+   */
+  buildJsonbArrayCondition(column: PgColumn, path: string[], arrayPath: string, operator: FilterOperators<any>): SQL | undefined;
+  /**
+   * Apply a filter operator to a JSONB value.
+   */
+  private applyOperatorToJsonValue;
+  /**
+   * Parse a nested query object and extract the path and operator.
+   * For example: { profile: { contact: { email: { eq: "test@example.com" } } } }
+   * Returns: { path: ['profile', 'contact', 'email'], operator: { eq: "test@example.com" } }
+   */
+  parseNestedQuery(nestedQuery: any, currentPath?: string[]): Array<{
+    path: string[];
+    operator: FilterOperators<any>;
+  }>;
+  /**
+   * Determine if a property is a JSONB column based on the schema.
+   * A column is JSONB if it's defined as an object or array in the TypeBox schema.
+   */
+  isJsonbColumn(schema: TObject, columnName: string): boolean;
+  /**
+   * Check if an array property contains primitive types (string, number, boolean, etc.)
+   * rather than objects. Primitive arrays should use native Drizzle operators.
+   * @returns true if the array contains primitives, false if it contains objects
+   */
+  isPrimitiveArray(schema: TObject, columnName: string): boolean;
+  /**
+   * Check if a nested path points to an array property.
+   */
+  isArrayProperty(schema: TObject, path: string[]): boolean;
+}
+//#endregion
+//#region src/services/PgQueryManager.d.ts
+declare class PgQueryManager {
+  protected readonly jsonQueryManager: PgJsonQueryManager;
+  protected readonly alepha: Alepha;
+  /**
+   * Convert a query object to a SQL query.
+   */
+  toSQL(query: PgQueryWhereOrSQL<TObject>, options: {
+    schema: TObject;
+    col: (key: string) => PgColumn;
+    joins?: PgJoin[];
+  }): SQL | undefined;
+  /**
+   * Build a JSONB query for nested object/array queries.
+   */
+  protected buildJsonbQuery(column: PgColumn, nestedQuery: any, schema: TObject, columnName: string): SQL | undefined;
+  /**
+   * Check if an object has any filter operator properties.
+   */
+  protected hasFilterOperatorProperties(obj: any): boolean;
+  /**
+   * Map a filter operator to a SQL query.
+   */
+  mapOperatorToSql(operator: FilterOperators<any> | any, column: PgColumn, columnSchema?: TObject, columnName?: string): 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
+   */
+  parsePaginationSort(sort: string): Array<{
+    column: string;
+    direction: "asc" | "desc";
+  }> | {
+    column: string;
+    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
+   */
+  normalizeOrderBy(orderBy: any): Array<{
+    column: string;
+    direction: "asc" | "desc";
+  }>;
+  /**
+   * Create a pagination object.
+   *
+   * @param entities The entities to paginate.
+   * @param limit The limit of the pagination.
+   * @param offset The offset of the pagination.
+   */
+  createPagination<T>(entities: T[], limit?: number, offset?: number): Page<T>;
+}
+interface PgJoin {
+  table: string;
+  schema: TObject;
+  key: string;
+  col: (key: string) => PgColumn;
+  parent?: string;
+}
+//#endregion
+//#region src/services/PgRelationManager.d.ts
+declare class PgRelationManager {
+  /**
+   * 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
+   */
+  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)
+   */
+  private isAllNull;
+  /**
+   * Build a schema that includes all join properties recursively
+   */
+  buildSchemaWithJoins(baseSchema: TObject, joins: PgJoin[], parentPath?: string): TObject;
+}
+//#endregion
 //#region src/descriptors/$repository.d.ts
 /**
- * Creates a repository descriptor for database operations on a defined entity.
+ * Creates a repository for database operations on a defined entity.
  *
  * This descriptor provides a comprehensive, type-safe interface for performing all
  * database operations on entities defined with $entity. It offers a rich set of
  * CRUD operations, advanced querying capabilities, pagination, transactions, and
  * built-in support for audit trails and soft deletes.
- *
- * **Key Features**
- *
- * - **Complete CRUD Operations**: Create, read, update, delete with full type safety
- * - **Advanced Querying**: Complex WHERE conditions, sorting, pagination, and aggregations
- * - **Transaction Support**: Database transactions for consistency and atomicity
- * - **Soft Delete Support**: Built-in soft delete functionality with `pg.deletedAt()` fields
- * - **Optimistic Locking**: Version-based conflict resolution with `pg.version()` fields
- * - **Audit Trail Integration**: Automatic handling of `createdAt`, `updatedAt` timestamps
- * - **Raw SQL Support**: Execute custom SQL queries when needed
- * - **Pagination**: Built-in pagination with metadata and navigation
- *
- * **Important Requirements**
- * - Must be used with an entity created by $entity
- * - Entity schema must include exactly one primary key field
- * - Database tables must be created via migrations before use
- *
- * **Use Cases**
- *
- * Essential for all database-driven applications:
- * - User management and authentication systems
- * - E-commerce product and order management
- * - Content management and blogging platforms
- * - Financial and accounting applications
- * - Any application requiring persistent data storage
- *
- * @example
- * **Basic repository with CRUD operations:**
- * ```ts
- * import { $entity, $repository } from "alepha/postgres";
- * import { pg, t } from "alepha";
- *
- * // First, define the entity
- * const User = $entity({
- *   name: "users",
- *   schema: t.object({
- *     id: pg.primaryKey(t.uuid()),
- *     email: t.text({ format: "email" }),
- *     firstName: t.text(),
- *     lastName: t.text(),
- *     isActive: t.boolean({ default: true }),
- *     createdAt: pg.createdAt(),
- *     updatedAt: pg.updatedAt()
- *   }),
- *   indexes: [{ column: "email", unique: true }]
- * });
- *
- * class UserService {
- *   users = $repository({ table: User });
- *
- *   async createUser(userData: { email: string; firstName: string; lastName: string }) {
- *     return await this.users.create({
- *       id: generateUUID(),
- *       email: userData.email,
- *       firstName: userData.firstName,
- *       lastName: userData.lastName,
- *       isActive: true
- *     });
- *   }
- *
- *   async getUserByEmail(email: string) {
- *     return await this.users.findOne({ email });
- *   }
- *
- *   async updateUser(id: string, updates: { firstName?: string; lastName?: string }) {
- *     return await this.users.updateById(id, updates);
- *   }
- *
- *   async deactivateUser(id: string) {
- *     return await this.users.updateById(id, { isActive: false });
- *   }
- * }
- * ```
  */
 declare const $repository: {
-  <EntityTableConfig extends TableConfig, EntitySchema extends TObject>(optionsOrTable: RepositoryDescriptorOptions<EntityTableConfig, EntitySchema> | PgTableWithColumnsAndSchema<EntityTableConfig, EntitySchema>): RepositoryDescriptor<EntityTableConfig, EntitySchema>;
+  <T extends TObject>(optionsOrEntity: EntityDescriptor<T> | EntityDescriptorOptions<T> | RepositoryDescriptorOptions<T>): RepositoryDescriptor<T>;
   [KIND]: typeof RepositoryDescriptor;
 };
-interface RepositoryDescriptorOptions<EntityTableConfig extends TableConfig, EntitySchema extends TObject> {
+interface RepositoryDescriptorOptions<T extends TObject> {
   /**
    * The entity table definition created with $entity.
    *
@@ -1451,7 +1163,7 @@ interface RepositoryDescriptorOptions<EntityTableConfig extends TableConfig, Ent
    * const userRepository = $repository({ table: User });
    * ```
    */
-  table: PgTableWithColumnsAndSchema<EntityTableConfig, EntitySchema>;
+  entity: EntityDescriptor<T>;
   /**
    * Override the default PostgreSQL database provider.
    *
@@ -1474,14 +1186,16 @@ interface RepositoryDescriptorOptions<EntityTableConfig extends TableConfig, Ent
    * @example TenantSpecificPostgresProvider
    * @example TestDatabaseProvider
    */
-  provider?: Service<PostgresProvider>;
+  provider?: DatabaseProvider;
+  name?: string;
 }
-declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, EntitySchema extends TObject> extends Descriptor<RepositoryDescriptorOptions<EntityTableConfig, EntitySchema>> {
+declare class RepositoryDescriptor<T extends TObject = TObject> extends Descriptor<RepositoryDescriptorOptions<T>> {
+  protected readonly relationManager: PgRelationManager;
+  protected readonly queryManager: PgQueryManager;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly alepha: Alepha;
-  readonly provider: PostgresProvider;
-  readonly schema: EntitySchema;
-  readonly schemaInsert: TObjectInsert<EntitySchema>;
+  readonly provider: DatabaseProvider;
+  constructor(args: DescriptorArgs<RepositoryDescriptorOptions<T>>);
   /**
    * Represents the primary key of the table.
    * - Key is the name of the primary key column.
@@ -1489,15 +1203,15 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    *
    * ID is mandatory. If the table does not have a primary key, it will throw an error.
    */
-  readonly id: {
-    type: TSchema$1;
-    key: keyof EntitySchema["properties"];
+  get id(): {
+    type: TSchema;
+    key: keyof T["properties"];
     col: PgColumn;
   };
   /**
    * Get Drizzle table object.
    */
-  get table(): PgTableWithColumns<EntityTableConfig>;
+  get table(): PgTableWithColumns<SchemaToTableConfig<T>>;
   /**
    * Get SQL table name. (from Drizzle table object)
    */
@@ -1505,87 +1219,104 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
   /**
    * Getter for the database connection from the database provider.
    */
-  protected get db(): PgDatabase<any, Record<string, never>, drizzle_orm6.ExtractTablesWithRelations<Record<string, never>>>;
+  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}`);
+   *   }
+   * }
+   * ```
+   */
+  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)
    */
-  query<T extends TObject = EntitySchema>(query: SQLLike | ((table: PgTableWithColumns<EntityTableConfig>, db: PgDatabase<any>) => SQLLike), schema?: T): Promise<Static<T>[]>;
-  protected mapRawFieldsToEntity(row: any[]): any;
+  protected mapRawFieldsToEntity(row: Record<string, unknown>): any;
   /**
    * Get a Drizzle column from the table by his name.
-   *
-   * @param name - The name of the column to get.
-   * @returns The column from the table.
    */
-  protected col(name: keyof PgTableWithColumns<EntityTableConfig>["_"]["columns"]): PgColumn;
+  protected col(name: keyof StaticEncode<T>): PgColumn;
   /**
    * Run a transaction.
-   *
-   * @param transaction
-   * @param config
    */
   transaction<T>(transaction: (tx: PgTransaction<any, Record<string, any>, any>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
   /**
    * Start a SELECT query on the table.
-   *
-   * @returns The SELECT query builder.
    */
-  protected select(opts?: StatementOptions): pg$1.PgSelectBase<string, Record<string, PgColumn<drizzle_orm6.ColumnBaseConfig<drizzle_orm6.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
+  protected select(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_orm6.ColumnBaseConfig<drizzle_orm6.ColumnDataType, string>, {}, {}>;
+    [x: string]: PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>;
   }>;
-  protected selectDistinct(opts: StatementOptions | undefined, fields: SelectedFields): pg$1.PgSelectBase<string, SelectedFields, "partial", Record<string, "not-null">, false, never, {
-    [x: string]: unknown;
+  /**
+   * Start a SELECT DISTINCT query on the table.
+   */
+  protected selectDistinct(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]: never;
+    [x: string]: any;
   }>;
   /**
    * Start an INSERT query on the table.
-   *
-   * @returns The INSERT query builder.
    */
-  protected insert(opts?: StatementOptions): pg$1.PgInsertBuilder<PgTableWithColumns<EntityTableConfig>, any, false>;
+  protected insert(opts?: StatementOptions): drizzle_orm_pg_core0.PgInsertBuilder<PgTableWithColumns<SchemaToTableConfig<T>>, any, false>;
   /**
    * Start an UPDATE query on the table.
-   *
-   * @returns The UPDATE query builder.
    */
-  protected update(opts?: StatementOptions): pg$1.PgUpdateBuilder<PgTableWithColumns<EntityTableConfig>, any>;
+  protected update(opts?: StatementOptions): drizzle_orm_pg_core0.PgUpdateBuilder<PgTableWithColumns<SchemaToTableConfig<T>>, any>;
   /**
    * Start a DELETE query on the table.
-   *
-   * @returns The DELETE query builder.
    */
-  protected delete(opts?: StatementOptions): pg$1.PgDeleteBase<PgTableWithColumns<EntityTableConfig>, any, undefined, undefined, false, never>;
+  protected delete(opts?: StatementOptions): drizzle_orm_pg_core0.PgDeleteBase<PgTableWithColumns<SchemaToTableConfig<T>>, any, undefined, undefined, false, never>;
   /**
-   * Find entities.
+   * Create a Drizzle `select` query based on a JSON query object.
    *
-   * @param query The find query.
-   * @param opts The statement options.
-   * @returns The found entities.
+   * > This method is the base for `find`, `findOne`, `findById`, and `paginate`.
    */
-  find(query?: PgQuery<EntitySchema>, opts?: StatementOptions): Promise<Static<EntitySchema>[]>;
+  find<R extends PgRelationMap<T>>(query?: PgQueryRelations<T, R>, opts?: StatementOptions): Promise<PgStatic<T, R>[]>;
   /**
    * 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.
    *
-   * @param where The where clause.
-   * @param opts The statement options.
-   * @returns The found entity.
+   * 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.
    */
-  findOne<T extends EntitySchema = EntitySchema>(where: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<Static<EntitySchema>>;
+  paginate<R extends PgRelationMap<T>>(pagination?: PageQuery, query?: PgQueryRelations<T, R>, opts?: StatementOptions & {
+    count?: boolean;
+  }): Promise<Page<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.
    */
-  findById(id: string | number, opts?: StatementOptions): Promise<Static<EntitySchema>>;
+  findById(id: string | number, opts?: StatementOptions): Promise<Static<T>>;
   /**
-   * Paginate entities.
+   * Helper to create a type-safe query object.
    */
-  paginate(pagination?: PageQuery, query?: PgQuery<EntitySchema>, opts?: StatementOptions & {
-    count?: boolean;
-  }): Promise<Page<Static<EntitySchema>>>;
-  createQuery(query?: PgQuery<EntitySchema>): PgQuery<EntitySchema>;
-  createQueryWhere(where?: PgQueryWhere<EntitySchema>): PgQueryWhere<EntitySchema>;
+  createQuery(): PgQuery<T>;
+  /**
+   * Helper to create a type-safe where clause.
+   */
+  createQueryWhere(): PgQueryWhere<T>;
   /**
    * Create an entity.
    *
@@ -1593,7 +1324,7 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    * @param opts The options for creating the entity.
    * @returns The ID of the created entity.
    */
-  create(data: Static<TObjectInsert<EntitySchema>>, opts?: StatementOptions): Promise<Static<EntitySchema>>;
+  create(data: Static<TObjectInsert<T>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
    * Create many entities.
    *
@@ -1601,11 +1332,11 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    * @param opts The statement options.
    * @returns The created entities.
    */
-  createMany(values: Array<Static<TObjectInsert<EntitySchema>>>, opts?: StatementOptions): Promise<Static<EntitySchema>[]>;
+  createMany(values: Array<Static<TObjectInsert<T>>>, opts?: StatementOptions): Promise<Static<T>[]>;
   /**
    * Find an entity and update it.
    */
-  updateOne(where: PgQueryWhereOrSQL<EntitySchema>, data: Partial<Static<TObjectUpdate<EntitySchema>>>, opts?: StatementOptions): Promise<Static<EntitySchema>>;
+  updateOne(where: PgQueryWhereOrSQL<T>, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
    * Save a given entity.
    *
@@ -1627,132 +1358,90 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    * @see {@link PostgresTypeProvider#version}
    * @see {@link PgVersionMismatchError}
    */
-  save(entity: Static<EntitySchema>, opts?: StatementOptions): Promise<Static<EntitySchema>>;
+  save(entity: Static<T>, opts?: StatementOptions): Promise<void>;
   /**
    * Find an entity by ID and update it.
    */
-  updateById(id: string | number, data: Partial<Static<TObjectUpdate<EntitySchema>>>, opts?: StatementOptions): Promise<Static<EntitySchema>>;
+  updateById(id: string | number, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
    * Find many entities and update all of them.
    */
-  updateMany(where: PgQueryWhereOrSQL<EntitySchema>, data: Partial<Static<TObjectUpdate<EntitySchema>>>, opts?: StatementOptions): Promise<void>;
+  updateMany(where: PgQueryWhereOrSQL<T>, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
    * Find many and delete all of them.
+   * @returns Array of deleted entity IDs
    */
-  deleteMany(where?: PgQueryWhereOrSQL<EntitySchema>, opts?: StatementOptions): Promise<void>;
+  deleteMany(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
    * Delete all entities.
+   * @returns Array of deleted entity IDs
    */
-  clear(opts?: StatementOptions): Promise<void>;
+  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
    */
-  destroy(entity: Static<EntitySchema>, opts?: StatementOptions): Promise<void>;
+  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)
    */
-  deleteOne(where?: PgQueryWhereOrSQL<EntitySchema>, opts?: StatementOptions): Promise<void>;
+  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 PgEntityNotFoundError if the entity is not found
    */
-  deleteById(id: string | number, opts?: StatementOptions): Promise<void>;
+  deleteById(id: string | number, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
    * Count entities.
    */
-  count(where?: PgQueryWhereOrSQL<EntitySchema>, opts?: StatementOptions): Promise<number>;
+  count(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<number>;
   protected conflictMessagePattern: string;
   protected handleError(error: unknown, message: string): PgError;
-  protected withDeletedAt(where: PgQueryWhereOrSQL<EntitySchema>, opts?: {
+  protected withDeletedAt(where: PgQueryWhereOrSQL<T>, opts?: {
     force?: boolean;
-  }): PgQueryWhereOrSQL<EntitySchema>;
-  protected get organization(): undefined;
+  }): PgQueryWhereOrSQL<T>;
   protected deletedAt(): PgAttrField | undefined;
-  /**
-   * Convert a query object to a SQL query.
-   *
-   * @param query The query object.
-   * @param schema The schema to use.
-   * @param col The column to use.
-   */
-  protected jsonQueryToSql(query: PgQueryWhereOrSQL<EntitySchema>, schema?: TObject, col?: (key: string) => PgColumn): SQL | undefined;
-  /**
-   * Map a filter operator to a SQL query.
-   *
-   * @param operator
-   * @param column
-   * @protected
-   */
-  protected mapOperatorToSql(operator: FilterOperators<any> | any, column: PgColumn): SQL | undefined;
-  /**
-   * Create a pagination object.
-   *
-   * @param entities The entities to paginate.
-   * @param limit The limit of the pagination.
-   * @param offset The offset of the pagination.
-   */
-  protected createPagination(entities: Static<EntitySchema>[], limit?: number, offset?: number): Page<Static<EntitySchema>>;
   /**
    * Convert something to valid Pg Insert Value.
    */
-  protected cast(data: any, insert: boolean): PgInsertValue<PgTableWithColumns<EntityTableConfig>>;
+  protected cast(data: any, insert: boolean): PgInsertValue<PgTableWithColumns<SchemaToTableConfig<T>>>;
   /**
-   * Clean a row. Remove all null values.
+   * Transform a row from the database into a clean entity.
    *
-   * @param row The row to clean.
-   * @param schema The schema to use.
-   * @returns The cleaned row.
+   * - Validate against schema
+   * - Replace all null values by undefined
+   * - Fix date-time and date fields to ISO strings
+   * - Cast BigInt to string
    */
-  protected clean<T extends TObject = EntitySchema>(row: any, schema?: T): Static<T>;
+  protected clean<T extends TObject>(row: Record<string, unknown>, schema: T): Static<T>;
   /**
-   * 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
+   * Clean a row with joins recursively
    */
-  protected parsePaginationSort(sort: string): Array<{
-    column: string;
-    direction: "asc" | "desc";
-  }> | {
-    column: string;
-    direction: "asc" | "desc";
-  };
+  protected cleanWithJoins<T extends TObject>(row: Record<string, unknown>, schema: T, joins: PgJoin[], parentPath?: string): Static<T>;
   /**
-   * 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
+   * Convert a where clause to SQL.
    */
-  protected normalizeOrderBy(orderBy: any): Array<{
-    column: string;
-    direction: "asc" | "desc";
-  }>;
+  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.
    */
-  protected getWhereId(id: string | number): PgQueryWhereOrSQL<EntitySchema>;
+  protected getWhereId(id: string | number): PgQueryWhere<T>;
   /**
    * Find a primary key in the schema.
-   *
-   * @param schema
-   * @protected
    */
   protected getPrimaryKey(schema: TObject): {
     key: string;
-    col: PgColumn<drizzle_orm6.ColumnBaseConfig<drizzle_orm6.ColumnDataType, string>, {}, {}>;
-    type: TSchema$1;
+    col: PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>;
+    type: TSchema;
   };
+  protected $provider(): DatabaseProvider;
 }
 /**
  * The options for a statement.
@@ -1779,374 +1468,6 @@ interface StatementOptions {
   now?: DateTime;
 }
 //#endregion
-//#region src/descriptors/$sequence.d.ts
-/**
- * Creates a PostgreSQL sequence descriptor for generating unique numeric values.
- *
- * This descriptor provides a type-safe interface to PostgreSQL sequences, which are
- * database objects that generate unique numeric identifiers. Sequences are commonly
- * used for primary keys, order numbers, invoice numbers, and other cases where
- * guaranteed unique, incrementing values are needed across concurrent operations.
- *
- * **Key Features**
- *
- * - **Thread-Safe**: PostgreSQL sequences are inherently thread-safe and handle concurrency
- * - **Configurable Parameters**: Start value, increment, min/max bounds, and cycling behavior
- * - **Automatic Creation**: Sequences are created automatically when first used
- * - **Type Safety**: Full TypeScript support with numeric return types
- * - **Performance**: Optimized for high-throughput ID generation
- * - **Schema Support**: Works with PostgreSQL schemas for organization
- *
- * **Use Cases**
- *
- * Perfect for generating unique identifiers in concurrent environments:
- * - Primary key generation (alternative to UUIDs)
- * - Order numbers and invoice sequences
- * - Ticket numbers and reference IDs
- * - Version numbers and revision tracking
- * - Batch numbers for processing workflows
- * - Any scenario requiring guaranteed unique incrementing numbers
- *
- * @example
- * **Basic sequence for order numbers:**
- * ```ts
- * import { $sequence } from "alepha/postgres";
- *
- * class OrderService {
- *   orderNumbers = $sequence({
- *     name: "order_numbers",
- *     start: 1000,      // Start from order #1000
- *     increment: 1      // Increment by 1 each time
- *   });
- *
- *   async createOrder(orderData: OrderData) {
- *     const orderNumber = await this.orderNumbers.next();
- *
- *     return await this.orders.create({
- *       id: generateUUID(),
- *       orderNumber,
- *       ...orderData
- *     });
- *   }
- *
- *   async getCurrentOrderNumber() {
- *     // Get the last generated number without incrementing
- *     return await this.orderNumbers.current();
- *   }
- * }
- * ```
- *
- * @example
- * **Invoice numbering with yearly reset:**
- * ```ts
- * class InvoiceService {
- *   // Separate sequence for each year
- *   getInvoiceSequence(year: number) {
- *     return $sequence({
- *       name: `invoice_numbers_${year}`,
- *       start: 1,
- *       increment: 1
- *     });
- *   }
- *
- *   async generateInvoiceNumber(): Promise<string> {
- *     const year = new Date().getFullYear();
- *     const sequence = this.getInvoiceSequence(year);
- *     const number = await sequence.next();
- *
- *     // Format as INV-2024-001, INV-2024-002, etc.
- *     return `INV-${year}-${number.toString().padStart(3, '0')}`;
- *   }
- * }
- * ```
- *
- * @example
- * **High-performance ID generation with custom increments:**
- * ```ts
- * class TicketService {
- *   // Generate ticket numbers in increments of 10 for better distribution
- *   ticketSequence = $sequence({
- *     name: "ticket_numbers",
- *     start: 1000,
- *     increment: 10,
- *     min: 1000,
- *     max: 999999,
- *     cycle: false  // Don't cycle when max is reached
- *   });
- *
- *   priorityTicketSequence = $sequence({
- *     name: "priority_ticket_numbers",
- *     start: 1,
- *     increment: 1,
- *     min: 1,
- *     max: 999,
- *     cycle: true   // Cycle when reaching max
- *   });
- *
- *   async generateTicketNumber(isPriority: boolean = false): Promise<number> {
- *     if (isPriority) {
- *       return await this.priorityTicketSequence.next();
- *     }
- *     return await this.ticketSequence.next();
- *   }
- *
- *   async getSequenceStatus() {
- *     return {
- *       currentTicketNumber: await this.ticketSequence.current(),
- *       currentPriorityNumber: await this.priorityTicketSequence.current()
- *     };
- *   }
- * }
- * ```
- *
- * @example
- * **Batch processing with sequence-based coordination:**
- * ```ts
- * class BatchProcessor {
- *   batchSequence = $sequence({
- *     name: "batch_numbers",
- *     start: 1,
- *     increment: 1
- *   });
- *
- *   async processBatch(items: any[]) {
- *     const batchNumber = await this.batchSequence.next();
- *
- *     console.log(`Starting batch processing #${batchNumber} with ${items.length} items`);
- *
- *     try {
- *       // Process items with batch number for tracking
- *       for (const item of items) {
- *         await this.processItem(item, batchNumber);
- *       }
- *
- *       await this.auditLogger.log({
- *         event: 'batch_completed',
- *         batchNumber,
- *         itemCount: items.length,
- *         timestamp: new Date()
- *       });
- *
- *       return { batchNumber, processedCount: items.length };
- *
- *     } catch (error) {
- *       await this.auditLogger.log({
- *         event: 'batch_failed',
- *         batchNumber,
- *         error: error.message,
- *         timestamp: new Date()
- *       });
- *       throw error;
- *     }
- *   }
- *
- *   async processItem(item: any, batchNumber: number) {
- *     // Associate item processing with batch number
- *     await this.items.update(item.id, {
- *       ...item.updates,
- *       batchNumber,
- *       processedAt: new Date()
- *     });
- *   }
- * }
- * ```
- *
- * @example
- * **Multi-tenant sequence management:**
- * ```ts
- * class TenantSequenceService {
- *   // Create tenant-specific sequences
- *   getTenantSequence(tenantId: string, sequenceType: string) {
- *     return $sequence({
- *       name: `${tenantId}_${sequenceType}_seq`,
- *       start: 1,
- *       increment: 1
- *     });
- *   }
- *
- *   async generateTenantOrderNumber(tenantId: string): Promise<string> {
- *     const sequence = this.getTenantSequence(tenantId, 'orders');
- *     const number = await sequence.next();
- *
- *     return `${tenantId.toUpperCase()}-ORD-${number.toString().padStart(6, '0')}`;
- *   }
- *
- *   async generateTenantInvoiceNumber(tenantId: string): Promise<string> {
- *     const sequence = this.getTenantSequence(tenantId, 'invoices');
- *     const number = await sequence.next();
- *
- *     return `${tenantId.toUpperCase()}-INV-${number.toString().padStart(6, '0')}`;
- *   }
- *
- *   async getTenantSequenceStatus(tenantId: string) {
- *     const orderSeq = this.getTenantSequence(tenantId, 'orders');
- *     const invoiceSeq = this.getTenantSequence(tenantId, 'invoices');
- *
- *     return {
- *       tenant: tenantId,
- *       sequences: {
- *         orders: {
- *           current: await orderSeq.current(),
- *           next: await orderSeq.next()
- *         },
- *         invoices: {
- *           current: await invoiceSeq.current()
- *         }
- *       }
- *     };
- *   }
- * }
- * ```
- *
- * **Important Notes**:
- * - Sequences are created automatically when first used
- * - PostgreSQL sequences are atomic and handle high concurrency
- * - Sequence values are not rolled back in failed transactions
- * - Consider the impact of max values and cycling behavior
- * - Sequences are schema-scoped in PostgreSQL
- *
- * @stability 1
- */
-declare const $sequence: {
-  (options?: SequenceDescriptorOptions): SequenceDescriptor;
-  [KIND]: typeof SequenceDescriptor;
-};
-interface SequenceDescriptorOptions {
-  /**
-   * Name of the PostgreSQL sequence to create.
-   *
-   * This name:
-   * - Must be unique within the database schema
-   * - Should follow PostgreSQL identifier conventions
-   * - Will be used in generated SQL for sequence operations
-   * - Should be descriptive of the sequence's purpose
-   *
-   * If not provided, defaults to the property key where the sequence is declared.
-   *
-   * **Naming Guidelines**:
-   * - Use descriptive names like "order_numbers", "invoice_seq"
-   * - Include the purpose or entity type in the name
-   * - Consider adding "_seq" suffix for clarity
-   * - Use snake_case for consistency with PostgreSQL conventions
-   *
-   * @example "order_numbers"
-   * @example "invoice_sequence"
-   * @example "ticket_numbers_seq"
-   */
-  name?: string;
-  /**
-   * The starting value for the sequence.
-   *
-   * This value:
-   * - Determines the first number that will be generated
-   * - Can be any integer within the sequence's range
-   * - Is useful for avoiding conflicts with existing data
-   * - Can be set higher for business reasons (e.g., starting invoices at 1000)
-   *
-   * **Common Patterns**:
-   * - Start at 1 for simple counters
-   * - Start at 1000+ for professional-looking numbers
-   * - Start at current max + 1 when migrating existing data
-   *
-   * @default 1
-   * @example 1     // Simple counter starting at 1
-   * @example 1000  // Professional numbering starting at 1000
-   * @example 10000 // Large starting number for established businesses
-   */
-  start?: number;
-  /**
-   * The increment value for each call to next().
-   *
-   * This value:
-   * - Determines how much the sequence increases each time
-   * - Can be any positive or negative integer
-   * - Affects the gaps between generated numbers
-   * - Can be used for number distribution strategies
-   *
-   * **Use Cases**:
-   * - increment: 1 for consecutive numbering
-   * - increment: 10 for distributed numbering (leaves gaps for manual entries)
-   * - increment: -1 for countdown sequences
-   *
-   * @default 1
-   * @example 1   // Standard consecutive numbering
-   * @example 10  // Leave gaps between numbers
-   * @example 100 // Large gaps for special numbering schemes
-   */
-  increment?: number;
-  /**
-   * The minimum value the sequence can generate.
-   *
-   * When the sequence reaches this value:
-   * - It cannot generate values below this minimum
-   * - Helps prevent negative numbers in contexts where they don't make sense
-   * - Works with cycling behavior to define the lower bound
-   *
-   * **Considerations**:
-   * - Set to 1 for positive-only sequences
-   * - Set to 0 if zero values are acceptable
-   * - Consider business rules about minimum valid numbers
-   *
-   * @example 1     // No zero or negative values
-   * @example 0     // Allow zero values
-   * @example 1000  // Maintain minimum professional appearance
-   */
-  min?: number;
-  /**
-   * The maximum value the sequence can generate.
-   *
-   * When the sequence reaches this value:
-   * - It cannot generate values above this maximum
-   * - Behavior depends on the cycle option
-   * - Useful for preventing overflow or limiting number ranges
-   *
-   * **Planning Considerations**:
-   * - Consider the expected volume of your application
-   * - Account for business growth over time
-   * - Factor in any formatting constraints (e.g., fixed-width displays)
-   * - Remember that PostgreSQL sequences can handle very large numbers
-   *
-   * @example 999999    // Six-digit limit
-   * @example 2147483647 // Maximum 32-bit signed integer
-   * @example 9999      // Four-digit limit for display purposes
-   */
-  max?: number;
-  /**
-   * Whether the sequence should cycle back to the minimum when it reaches the maximum.
-   *
-   * **cycle: true**:
-   * - When max is reached, next value will be the minimum value
-   * - Useful for scenarios where number reuse is acceptable
-   * - Common for temporary identifiers or rotating references
-   *
-   * **cycle: false (default)**:
-   * - When max is reached, further calls will fail with an error
-   * - Prevents unexpected number reuse
-   * - Better for permanent identifiers where uniqueness is critical
-   *
-   * **Use Cases for Cycling**:
-   * - Temporary ticket numbers that can be reused
-   * - Session IDs with limited lifetime
-   * - Batch numbers in rotating systems
-   *
-   * **Avoid Cycling For**:
-   * - Primary keys and permanent identifiers
-   * - Invoice numbers and financial references
-   * - Audit logs and compliance records
-   *
-   * @default false
-   */
-  cycle?: boolean;
-}
-declare class SequenceDescriptor extends Descriptor<SequenceDescriptorOptions> {
-  protected readonly provider: PostgresProvider;
-  protected created: boolean;
-  get name(): string;
-  protected create(): Promise<void>;
-  next(): Promise<number>;
-  current(): Promise<number>;
-}
-//#endregion
 //#region src/descriptors/$transaction.d.ts
 /**
  * Creates a transaction descriptor for database operations requiring atomicity and consistency.
@@ -2298,66 +1619,85 @@ declare class PgVersionMismatchError extends PgError {
   constructor(table: string, id: any);
 }
 //#endregion
-//#region src/providers/RepositoryProvider.d.ts
-declare class RepositoryProvider {
-  protected readonly log: _alepha_logger1.Logger;
+//#region src/providers/DrizzleKitProvider.d.ts
+declare class DrizzleKitProvider {
+  protected readonly log: _alepha_logger0.Logger;
   protected readonly alepha: Alepha;
-  protected get repositories(): RepositoryDescriptor<TableConfig$1, TObject>[];
   /**
-   * Get all repositories.
+   * Synchronize database with current schema definitions.
    *
-   * @param provider - Filter by provider.
-   */
-  getRepositories(provider?: PostgresProvider): RepositoryDescriptor<TableConfig$1, TObject>[];
-  /**
-   * Get all tables from the repositories.
+   * 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.
    *
-   * @param provider
+   * Does nothing in production mode, you must handle migrations manually.
    */
-  getTables(provider?: PostgresProvider): pg$1.PgTableWithColumns<TableConfig$1>[];
+  synchronize(provider: DatabaseProvider): Promise<void>;
   /**
-   * Get all pg providers from the repositories.
+   * Mostly used for testing purposes. You can generate SQL migration statements without executing them.
    */
-  getProviders(): PostgresProvider[];
-}
-//#endregion
-//#region src/providers/DrizzleKitProvider.d.ts
-declare class DrizzleKitProvider {
-  protected readonly log: _alepha_logger1.Logger;
-  protected readonly alepha: Alepha;
-  protected readonly repositoryProvider: RepositoryProvider;
-  push(provider: PostgresProvider, schema?: string): Promise<void>;
-  setPgSchema(provider: PostgresProvider): Promise<void>;
+  generateMigration(provider: DatabaseProvider, prevSnapshot?: any): Promise<{
+    statements: string[];
+    models: Record<string, unknown>;
+    snapshot?: any;
+  }>;
   /**
-   * Try to generate migrations from scratch based on the models.
-   * Then, execute the migrations.
-   *
-   * This is useful for testing or development purposes.
-   *
-   * Do not use in production.
-   *
-   * @param provider - The Postgres provider to use.
-   * @param schema - The schema to use.
-   * @returns A promise that resolves once the migrations have been executed.
+   * Load all tables, enums, sequences, etc. from the provider's repositories.
    */
-  synchronize(provider: PostgresProvider, schema?: string): Promise<void>;
+  getModels(provider: DatabaseProvider): Record<string, unknown>;
   /**
-   * Get all tables from the provider's repositories.
+   * Load the migration snapshot from the database.
    */
-  protected getTables(provider: PostgresProvider, schema?: string): Promise<Record<string, any>>;
-  protected loadMigrationSnapshot(provider: PostgresProvider): Promise<any>;
-  protected saveMigrationSnapshot(provider: PostgresProvider, curr: Record<string, any>, entry?: {
-    id: number;
-    snapshot: string;
-  }): Promise<void>;
-  protected executeStatements(statements: string[], provider: PostgresProvider, _schema?: string, catchErrors?: boolean): Promise<void>;
-  protected prepareSchema(schemaName: string, provider: PostgresProvider, repositories: any[]): Promise<void>;
+  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.
    */
   protected importDrizzleKit(): typeof DrizzleKit;
-  synchronizeSqlite(provider: PostgresProvider): Promise<void>;
+}
+declare const devMigrationsSchema: typebox9.TObject<{
+  id: typebox9.TNumber;
+  name: typebox9.TString;
+  snapshot: typebox9.TString;
+  created_at: typebox9.TString;
+}>;
+type DevMigrations = Static<typeof devMigrationsSchema>;
+//#endregion
+//#region src/services/PostgresModelBuilder.d.ts
+declare class PostgresModelBuilder extends ModelBuilder {
+  protected schemas: Map<string, drizzle_orm_pg_core0.PgSchema<string>>;
+  protected getPgSchema(name: string): any;
+  buildTable(entity: EntityDescriptor<any>, options: {
+    tables: Map<string, unknown>;
+    enums: Map<string, unknown>;
+    schema: string;
+  }): void;
+  buildSequence(sequence: SequenceDescriptor, options: {
+    sequences: Map<string, unknown>;
+    schema: string;
+  }): void;
+  /**
+   * Get PostgreSQL-specific config builder for the table.
+   */
+  protected getTableConfig(entity: EntityDescriptor, 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.
+   */
+  mapStringToColumn: (key: string, value: TSchema) => drizzle_orm_pg_core0.PgUUIDBuilderInitial<string> | drizzle_orm_pg_core0.PgCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "PgCustomColumn";
+    data: Buffer<ArrayBufferLike>;
+    driverParam: unknown;
+    enumValues: undefined;
+  }> | drizzle_orm_pg_core0.PgTimestampStringBuilderInitial<string> | drizzle_orm_pg_core0.PgDateStringBuilderInitial<string> | drizzle_orm_pg_core0.PgTextBuilderInitial<string, [string, ...string[]]>;
 }
 //#endregion
 //#region src/providers/drivers/NodePostgresProvider.d.ts
@@ -2385,42 +1725,33 @@ declare const envSchema: _alepha_core1.TObject<{
    * It will generate the migration script and save it to the DB.
    *
    * This is recommended for development and testing purposes only.
-   *
-   * @default false
    */
   POSTGRES_SYNCHRONIZE: _alepha_core1.TOptional<_alepha_core1.TBoolean>;
-  /**
-   * Push the schema to the database.
-   * It's like `drizzle-kit push` command.
-   * It will introspect the models from DB and generate the SQL statements to create or update the tables.
-   *
-   * @default false
-   */
-  POSTGRES_PUSH: _alepha_core1.TOptional<_alepha_core1.TBoolean>;
 }>;
 interface NodePostgresProviderOptions {
   migrations: MigrationConfig;
   connection: postgres.Options<any>;
 }
-declare class NodePostgresProvider extends PostgresProvider {
+declare class NodePostgresProvider extends DatabaseProvider {
+  static readonly SSL_MODES: readonly ["require", "allow", "prefer", "verify-full"];
   readonly dialect = "postgres";
-  protected readonly sslModes: readonly ["require", "allow", "prefer", "verify-full"];
-  protected readonly log: _alepha_logger1.Logger;
+  protected readonly log: _alepha_logger0.Logger;
   protected readonly env: {
     DATABASE_URL?: string | undefined;
     POSTGRES_SCHEMA?: string | undefined;
     POSTGRES_SYNCHRONIZE?: boolean | undefined;
-    POSTGRES_PUSH?: boolean | undefined;
   };
   protected readonly alepha: Alepha;
   protected readonly kit: DrizzleKitProvider;
+  protected readonly builder: PostgresModelBuilder;
   protected client?: postgres.Sql;
   protected pg?: PostgresJsDatabase;
   readonly options: NodePostgresProviderOptions;
   /**
    * In testing mode, the schema name will be generated and deleted after the test.
    */
-  protected schemaForTesting?: string;
+  protected schemaForTesting: string | undefined;
+  execute(statement: SQLLike): Promise<Array<Record<string, unknown>>>;
   /**
    * Get Postgres schema.
    */
@@ -2450,7 +1781,7 @@ declare class NodePostgresProvider extends PostgresProvider {
 //#endregion
 //#region src/providers/PostgresTypeProvider.d.ts
 declare class PostgresTypeProvider {
-  readonly attr: <T extends TSchema$1, Attr extends PgSymbolKeys>(type: T, attr: Attr, value?: PgSymbols[Attr]) => PgAttr<T, Attr>;
+  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.
    */
@@ -2478,7 +1809,7 @@ declare class PostgresTypeProvider {
    * 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$1>(type: T, value?: Static<T>) => PgAttr<T, PgDefault>;
+  readonly default: <T extends TSchema>(type: T, value?: Static<T>) => PgAttr<T, PgDefault>;
   /**
    * Creates a column 'version'.
    *
@@ -2493,21 +1824,33 @@ declare class PostgresTypeProvider {
   /**
    * 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>;
+  readonly createdAt: (options?: TStringOptions) => PgAttr<PgAttr<typebox9.TCodec<TString, dayjs0.Dayjs>, 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>;
+  readonly updatedAt: (options?: TStringOptions) => PgAttr<PgAttr<typebox9.TCodec<TString, dayjs0.Dayjs>, 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<typebox1.TOptional<TString>, typeof PG_DELETED_AT>;
+  readonly deletedAt: (options?: TStringOptions) => PgAttr<typebox9.TOptional<typebox9.TCodec<TString, dayjs0.Dayjs>>, 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$1>(type: T, ref: () => any, actions?: {
+  readonly ref: <T extends TSchema>(type: T, ref: () => any, actions?: {
     onUpdate?: UpdateDeleteAction$1;
     onDelete?: UpdateDeleteAction$1;
   }) => PgAttr<T, PgRef>;
@@ -2516,8 +1859,6 @@ declare class PostgresTypeProvider {
    * It's used by {@link RepositoryDescriptor#paginate} method.
    */
   readonly page: <T extends TObject>(resource: T, options?: TObjectOptions) => TPage<T>;
-  readonly many: <T extends TObject, Config extends TableConfig>(table: PgTableWithColumnsAndSchema<Config, T>, foreignKey: keyof T["properties"]) => TOptionalAdd<PgAttr<PgAttr<TArray<T>, PgMany>, PgDefault>>;
-  readonly one: <T extends TObject, Config extends TableConfig>(table: PgTableWithColumnsAndSchema<Config, T>, foreignKey: keyof T["properties"]) => PgAttr<PgAttr<TOptionalAdd<T>, PgOne>, PgDefault>;
 }
 declare const pg: PostgresTypeProvider;
 //#endregion
@@ -2525,13 +1866,13 @@ declare const pg: PostgresTypeProvider;
 /**
  * @deprecated Use `pg.primaryKey()` instead.
  */
-declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<typebox1.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
+declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<typebox9.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
 //#endregion
 //#region src/types/schema.d.ts
 /**
  * Postgres schema type.
  */
-declare const schema: <TDocument extends TSchema$1>(name: string, document: TDocument) => drizzle_orm6.$Type<pg$1.PgCustomColumnBuilder<{
+declare const schema: <TDocument extends TSchema>(name: string, document: TDocument) => drizzle_orm0.$Type<drizzle_orm_pg_core0.PgCustomColumnBuilder<{
   name: string;
   dataType: "custom";
   columnType: "PgCustomColumn";
@@ -2574,14 +1915,13 @@ declare const schema: <TDocument extends TSchema$1>(name: string, document: TDoc
  *
  * Migrations are supported via Drizzle ORM, you need to use the `drizzle-kit` CLI tool to generate and run migrations.
  *
- * Relations are **NOT SUPPORTED** yet. If you need relations, please use the `drizzle-orm` package directly.
- *
  * @see {@link $entity}
+ * @see {@link $sequence}
  * @see {@link $repository}
  * @see {@link $transaction}
  * @module alepha.postgres
  */
 declare const AlephaPostgres: _alepha_core1.Service<_alepha_core1.Module<{}>>;
 //#endregion
-export { $entity, $repository, $sequence, $transaction, AlephaPostgres, DrizzleKitProvider, Entity, EntityDescriptorOptions, ExtractManyRelations, FilterOperators, FromSchema, NodePostgresProvider, NodePostgresProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_IDENTITY, PG_MANY, PG_ONE, PG_PRIMARY_KEY, PG_REF, PG_SCHEMA, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgAttr, PgAttrField, PgConflictError, PgDefault, PgEntityNotFoundError, PgError, PgIdentityOptions, PgMany, PgManyOptions, PgMigrationError, PgOne, PgPrimaryKey, PgQuery, PgQueryWhere, PgQueryWhereOrSQL, PgQueryWhereWithMany, PgQueryWhereWithManyOrSQL, PgQueryWithMany, PgQueryWithMap, PgQueryWithOne, PgRef, PgRefOptions, PgSymbolKeys, PgSymbols, PgTableConfig, PgTableWithColumnsAndSchema, PgVersionMismatchError, PostgresProvider, PostgresTypeProvider, RelField, RemoveManyRelations, RepositoryDescriptor, RepositoryDescriptorOptions, RepositoryProvider, SQLLike, SequenceDescriptor, SequenceDescriptorOptions, StatementOptions, TObjectInsert, TObjectUpdate, TPage, TransactionContext, TransactionDescriptorOptions, camelToSnakeCase, drizzle_orm6 as drizzle, getAttrFields, insertSchema, legacyIdSchema, mapFieldToColumn, mapStringToColumn, pageQuerySchema, pageSchema, pg, pgAttr, schema, schemaToPgColumns, sql, updateSchema };
+export { $entity, $repository, $sequence, $transaction, AlephaPostgres, DatabaseProvider, DrizzleKitProvider, EntityColumn, EntityColumns, EntityDescriptor, EntityDescriptorOptions, FilterOperators, FromSchema, NodePostgresProvider, NodePostgresProviderOptions, 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, PgConflictError, PgDefault, PgEntityNotFoundError, PgEnumOptions, PgError, PgIdentityOptions, PgMigrationError, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, PgVersionMismatchError, PostgresTypeProvider, RepositoryDescriptor, RepositoryDescriptorOptions, SQLLike, SchemaToTableConfig, SequenceDescriptor, SequenceDescriptorOptions, StatementOptions, TObjectInsert, TObjectUpdate, TPage, TransactionContext, TransactionDescriptorOptions, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, pageQuerySchema, pageSchema, pg, pgAttr, schema, sql, updateSchema };
 //# sourceMappingURL=index.d.ts.map