alepha 0.10.7 → 0.11.1

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, PgSelectBase, PgSequenceOptions, PgTableExtraConfigValue, PgTableWithColumns, PgTransaction, PgTransactionConfig, 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 typebox0 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 typebox4 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.
@@ -84,11 +27,11 @@ interface PgRefOptions {
  * Before: { name: string; age: number(default=0); }
  * After:  { name: string; age?: number; }
  */
-type TObjectInsert<T$1 extends TObject> = TObject<{ [K in keyof T$1["properties"]]: T$1["properties"][K] extends {
+type TObjectInsert<T extends TObject> = TObject<{ [K in keyof T["properties"]]: T["properties"][K] extends {
   [PG_DEFAULT]: any;
 } | {
   "~optional": true;
-} ? TOptional<T$1["properties"][K]> : T$1["properties"][K] }>;
+} ? TOptional<T["properties"][K]> : T["properties"][K] }>;
 declare const insertSchema: <T extends TObject>(obj: T) => TObjectInsert<T>;
 //#endregion
 //#region src/schemas/updateSchema.d.ts
@@ -101,401 +44,42 @@ declare const insertSchema: <T extends TObject>(obj: T) => TObjectInsert<T>;
  * Before: { name?: string; age: number; }
  * After:  { name?: string | null; age: number; }
  */
-type TObjectUpdate<T$1 extends TObject> = TObject<{ [K in keyof T$1["properties"]]: T$1["properties"][K] extends TOptional<infer U> ? TOptional<TUnion<[U, TNull]>> : T$1["properties"][K] }>;
+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$1 extends TObject> = { [key in keyof T$1["properties"]]: PgColumnBuilderBase };
-/**
- * A table with columns and schema.
- */
-type PgTableWithColumnsAndSchema<T$1 extends TableConfig, R$1 extends TObject> = PgTableWithColumns<T$1> & {
-  get $table(): PgTableWithColumns<T$1>;
-  get $schema(): R$1;
-  get $insertSchema(): TObjectInsert<R$1>;
-  get $updateSchema(): TObjectUpdate<R$1>;
-  alias: (alias: string) => PgTableWithColumnsAndSchema<T$1, R$1>;
-};
-//#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)
- *   ]
  * });
  * ```
  */
 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$1 extends string, T$1 extends TObject, Keys = keyof Static<T$1>> {
+interface EntityDescriptorOptions<T extends TObject, Keys = keyof Static<T>> {
   /**
    * The database table name that will be created for this entity.
+   * If not provided, name will be inferred from the $repository variable name.
    */
-  name: TTableName$1;
+  name: string;
   /**
    * TypeBox schema defining the table structure and column types.
    */
-  schema: T$1;
+  schema: T;
   /**
    * Database indexes to create for query optimization.
    */
@@ -537,11 +121,12 @@ interface EntityDescriptorOptions<TTableName$1 extends string, T$1 extends TObje
     /**
      * Local columns that reference the foreign table.
      */
-    columns: Array<keyof Static<T$1>>;
+    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.
@@ -553,12 +138,6 @@ interface EntityDescriptorOptions<TTableName$1 extends string, T$1 extends TObje
    * - **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: [
@@ -584,7 +163,7 @@ interface EntityDescriptorOptions<TTableName$1 extends string, T$1 extends TObje
     /**
      * Columns involved in this constraint.
      */
-    columns: Array<keyof Static<T$1>>;
+    columns: Array<keyof Static<T>>;
     /**
      * Optional name for the constraint.
      */
@@ -600,52 +179,86 @@ interface EntityDescriptorOptions<TTableName$1 extends string, T$1 extends TObje
   }>;
   /**
    * 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$1>, "pg">) => PgTableExtraConfigValue[];
+  config?: (self: BuildExtraConfigColumns<string, FromSchema<T>, "pg">) => PgTableExtraConfigValue[];
 }
-type Entity<T$1 extends TObject> = PgTableWithColumnsAndSchema<PgTableConfig<string, T$1, FromSchema<T$1>>, T$1>;
-type PgTableConfig<TTableName$1 extends string, TSchema$2 extends TObject, TColumnsMap$1 extends FromSchema<TSchema$2>> = {
-  name: TTableName$1;
-  schema: any;
-  columns: BuildColumns<TTableName$1, TColumnsMap$1, "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 {
@@ -653,6 +266,39 @@ declare class PgError extends AlephaError {
   constructor(message: string, cause?: unknown);
 }
 //#endregion
+//#region src/helpers/pgAttr.d.ts
+/**
+ * Decorates a typebox schema with a Postgres attribute.
+ *
+ * > It's just a fancy way to add Symbols to a field.
+ *
+ * @example
+ * ```ts
+ * import { t } from "alepha";
+ * import { PG_UPDATED_AT } from "../constants/PG_SYMBOLS";
+ *
+ * export const updatedAtSchema = pgAttr(
+ *   t.datetime(), PG_UPDATED_AT,
+ * );
+ * ```
+ */
+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.
+ */
+declare const getAttrFields: (schema: TObject, name: PgSymbolKeys) => PgAttrField[];
+/**
+ * Type representation.
+ */
+type PgAttr<T extends TSchema, TAttr extends PgSymbolKeys> = T & { [K in TAttr]: PgSymbols[K] };
+interface PgAttrField {
+  key: string;
+  type: TSchema;
+  data: any;
+  nested?: any[];
+  one?: boolean;
+}
+//#endregion
 //#region src/interfaces/FilterOperators.d.ts
 interface FilterOperators<TValue> {
   /**
@@ -1009,55 +655,11 @@ interface FilterOperators<TValue> {
   arrayOverlaps?: TValue;
 }
 //#endregion
-//#region src/interfaces/PgQuery.d.ts
-/**
- * Order direction for sorting
- */
-type OrderDirection = "asc" | "desc";
-/**
- * Single order by clause with column and direction
- */
-interface OrderByClause<T$1> {
-  column: keyof T$1;
-  direction?: OrderDirection;
-}
-/**
- * Order by parameter - supports 3 modes:
- * 1. String: orderBy: "name" (defaults to ASC)
- * 2. Single object: orderBy: { column: "name", direction: "desc" }
- * 3. Array: orderBy: [{ column: "name", direction: "asc" }, { column: "age", direction: "desc" }]
- */
-type OrderBy<T$1> = keyof T$1 | OrderByClause<T$1> | Array<OrderByClause<T$1>>;
-/**
- * Generic query interface for PostgreSQL entities
- */
-interface PgQuery<T$1 extends TObject = TObject> {
-  distinct?: (keyof Static<T$1>)[];
-  columns?: (keyof Static<T$1>)[];
-  where?: PgQueryWhereOrSQL<T$1>;
-  limit?: number;
-  offset?: number;
-  orderBy?: OrderBy<Static<T$1>>;
-  groupBy?: (keyof Static<T$1>)[];
-}
-type PgStatic<T$1 extends TObject, Relations extends PgRelationMap<T$1>> = Static<T$1> & { [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$1 extends TObject = TObject, Relations extends PgRelationMap<T$1> | undefined = undefined> extends PgQuery<T$1> {
-  with?: Relations;
-  where?: PgQueryWhereOrSQL<T$1, Relations>;
-}
-type PgRelationMap<Base extends TObject> = Record<string, PgRelation<Base>>;
-type PgRelation<Base extends TObject> = {
-  type?: "left" | "inner" | "right";
-  join: PgTableWithColumnsAndSchema<any, TObject>;
-  on: SQLWrapper | [keyof Static<Base>, PgColumn];
-  with?: PgRelationMap<TObject>;
-};
-//#endregion
 //#region src/interfaces/PgQueryWhere.d.ts
-type PgQueryWhere<T$1 extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = (PgQueryWhereOperators<T$1> & PgQueryWhereConditions<T$1>) | (PgQueryWhereRelations<Relations> & PgQueryWhereOperators<T$1> & PgQueryWhereConditions<T$1, Relations>);
-type PgQueryWhereOrSQL<T$1 extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = SQLWrapper | PgQueryWhere<T$1, Relations>;
-type PgQueryWhereOperators<T$1 extends TObject> = { [Key in keyof Static<T$1>]?: FilterOperators<Static<T$1>[Key]> | Static<T$1>[Key] | (Static<T$1>[Key] extends object ? NestedJsonbQuery<Static<T$1>[Key]> : never) };
-type PgQueryWhereConditions<T$1 extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = {
+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.
@@ -1074,7 +676,7 @@ type PgQueryWhereConditions<T$1 extends TObject, Relations extends PgRelationMap
    *   )
    * ```
    */
-  and?: Array<PgQueryWhereOrSQL<T$1, Relations>>;
+  and?: Array<PgQueryWhereOrSQL<T, Relations>>;
   /**
    * Combine a list of conditions with the `or` operator. Conditions
    * that are equal `undefined` are automatically ignored.
@@ -1091,7 +693,7 @@ type PgQueryWhereConditions<T$1 extends TObject, Relations extends PgRelationMap
    *   )
    * ```
    */
-  or?: Array<PgQueryWhereOrSQL<T$1, Relations>>;
+  or?: Array<PgQueryWhereOrSQL<T, Relations>>;
   /**
    * Negate the meaning of an expression using the `not` keyword.
    *
@@ -1103,7 +705,7 @@ type PgQueryWhereConditions<T$1 extends TObject, Relations extends PgRelationMap
    *   .where(not(inArray(cars.make, ['GM', 'Ford'])))
    * ```
    */
-  not?: PgQueryWhereOrSQL<T$1, Relations>;
+  not?: PgQueryWhereOrSQL<T, Relations>;
   /**
    * Test whether a subquery evaluates to have any rows.
    *
@@ -1126,11 +728,167 @@ type PgQueryWhereConditions<T$1 extends TObject, Relations extends PgRelationMap
    */
   exists?: SQLWrapper;
 };
-type PgQueryWhereRelations<Relations extends PgRelationMap<TObject> | undefined = undefined> = Relations extends PgRelationMap<TObject> ? { [K in keyof Relations]?: PgQueryWhere<Relations[K]["join"]["$schema"], Relations[K]["with"]> } : {};
+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
+/**
+ * Order direction for sorting
+ */
+type OrderDirection = "asc" | "desc";
+/**
+ * Single order by clause with column and direction
+ */
+interface OrderByClause<T> {
+  column: keyof T;
+  direction?: OrderDirection;
+}
+/**
+ * Order by parameter - supports 3 modes:
+ * 1. String: orderBy: "name" (defaults to ASC)
+ * 2. Single object: orderBy: { column: "name", direction: "desc" }
+ * 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?: (keyof Static<T>)[];
+  columns?: (keyof Static<T>)[];
+  where?: PgQueryWhereOrSQL<T>;
+  limit?: number;
+  offset?: number;
+  orderBy?: OrderBy<Static<T>>;
+  groupBy?: (keyof Static<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/services/ModelBuilder.d.ts
 /**
- * Recursively allow nested queries for JSONB object/array types
+ * 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...).
  */
-type NestedJsonbQuery<T$1> = T$1 extends object ? T$1 extends Array<infer U> ? U extends object ? { [K in keyof U]?: FilterOperators<U[K]> | U[K] } : FilterOperators<U> | U : { [K in keyof T$1]?: FilterOperators<T$1[K]> | T$1[K] | (T$1[K] extends object ? NestedJsonbQuery<T$1[K]> : never) } : FilterOperators<T$1> | T$1;
+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 DatabaseProvider {
+  protected readonly alepha: Alepha;
+  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;
+  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: typebox4.TObject<{
+  page: typebox4.TOptional<typebox4.TInteger>;
+  size: typebox4.TOptional<typebox4.TInteger>;
+  sort: typebox4.TOptional<typebox4.TString>;
+}>;
+type PageQuery = Static<typeof pageQuerySchema>;
 //#endregion
 //#region src/schemas/pageSchema.d.ts
 /**
@@ -1147,8 +905,8 @@ type NestedJsonbQuery<T$1> = T$1 extends object ? T$1 extends Array<infer U> ? U
  * @see {@link $repository#paginate}
  */
 declare const pageSchema: <T extends TObject | TRecord>(objectSchema: T, options?: TObjectOptions) => TPage<T>;
-type TPage<T$1 extends TObject | TRecord> = TObject<{
-  content: TArray<T$1>;
+type TPage<T extends TObject | TRecord> = TObject<{
+  content: TArray<T>;
   can: TObject<{
     next: TBoolean;
     previous: TBoolean;
@@ -1178,11 +936,11 @@ type TPage<T$1 extends TObject | TRecord> = TObject<{
  * }
  * ```
  */
-type Page<T$1> = {
+type Page<T> = {
   /**
    * Array of items on the current page.
    */
-  content: T$1[];
+  content: T[];
   can: {
     /**
      * Indicates if there is a next page.
@@ -1209,7 +967,7 @@ type Page<T$1> = {
   };
 };
 //#endregion
-//#region src/helpers/PgJsonQueryManager.d.ts
+//#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.
@@ -1266,9 +1024,10 @@ declare class PgJsonQueryManager {
   isArrayProperty(schema: TObject, path: string[]): boolean;
 }
 //#endregion
-//#region src/helpers/PgQueryManager.d.ts
+//#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.
    */
@@ -1281,10 +1040,14 @@ declare class PgQueryManager {
    * 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): SQL | undefined;
+  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" }]
@@ -1332,68 +1095,26 @@ interface PgJoin {
   parent?: string;
 }
 //#endregion
-//#region src/helpers/PgRelationManager.d.ts
+//#region src/services/PgRelationManager.d.ts
 declare class PgRelationManager {
-  buildJoins(builder: PgSelectBase<any, any, any>, joins: Array<PgJoin>, withRelations: PgRelationMap<TObject>, table: PgTableWithColumnsAndSchema<any, any>, parentKey?: string): void;
+  /**
+   * 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/helpers/pgAttr.d.ts
-/**
- * Decorates a typebox schema with a Postgres attribute.
- *
- * > It's just a fancy way to add Symbols to a field.
- *
- * @example
- * ```ts
- * import { t } from "alepha";
- * import { PG_UPDATED_AT } from "../constants/PG_SYMBOLS";
- *
- * export const updatedAtSchema = pgAttr(
- *   t.datetime(), PG_UPDATED_AT,
- * );
- * ```
- */
-declare const pgAttr: <T extends TSchema$1, Attr extends PgSymbolKeys>(type: T, attr: Attr, value?: PgSymbols[Attr]) => PgAttr<T, Attr>;
-/**
- * Retrieves the fields of a schema that have a specific attribute.
- */
-declare const getAttrFields: (schema: TObject, name: PgSymbolKeys) => PgAttrField[];
-/**
- * Type representation.
- */
-type PgAttr<T$1 extends TSchema$1, TAttr extends PgSymbolKeys> = T$1 & { [K in TAttr]: PgSymbols[K] };
-interface PgAttrField {
-  key: string;
-  type: TSchema$1;
-  data: any;
-  nested?: any[];
-  one?: boolean;
-}
-//#endregion
-//#region src/providers/drivers/PostgresProvider.d.ts
-type SQLLike = SQLWrapper | string;
-declare abstract class PostgresProvider {
-  protected readonly alepha: Alepha;
-  abstract get db(): PgDatabase<any>;
-  readonly dialect: "postgres" | "sqlite";
-  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>;
-}
-//#endregion
-//#region src/schemas/pageQuerySchema.d.ts
-declare const pageQuerySchema: typebox0.TObject<{
-  page: typebox0.TOptional<typebox0.TInteger>;
-  size: typebox0.TOptional<typebox0.TInteger>;
-  sort: typebox0.TOptional<typebox0.TString>;
-}>;
-type PageQuery = Static<typeof pageQuerySchema>;
-//#endregion
 //#region src/descriptors/$repository.d.ts
 /**
  * Creates a repository for database operations on a defined entity.
@@ -1402,75 +1123,12 @@ type PageQuery = Static<typeof pageQuerySchema>;
  * 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
- *
- * @example
- * **Basic repository with CRUD operations:**
- * ```ts
- * import { $entity, $repository } from "alepha/postgres";
- * import { pg, t } from "alepha";
- *
- * // First, define the entity
- * const users = $entity({
- *   name: "users",
- *   schema: t.object({
- *     id: pg.primaryKey(t.uuid()),
- *     email: t.text({ format: "email" }),
- *     firstName: t.text(),
- *     lastName: t.text(),
- *     isActive: pg.default(t.boolean(), true),
- *     createdAt: pg.createdAt(),
- *     updatedAt: pg.updatedAt()
- *   }),
- *   indexes: [{ column: "email", unique: true }]
- * });
- *
- * class UserService {
- *   users = $repository(users);
- *
- *   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
- *     });
- *   }
- *
- *   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$1 extends TableConfig, EntitySchema$1 extends TObject> {
+interface RepositoryDescriptorOptions<T extends TObject> {
   /**
    * The entity table definition created with $entity.
    *
@@ -1505,7 +1163,7 @@ interface RepositoryDescriptorOptions<EntityTableConfig$1 extends TableConfig, E
    * const userRepository = $repository({ table: User });
    * ```
    */
-  table: PgTableWithColumnsAndSchema<EntityTableConfig$1, EntitySchema$1>;
+  entity: EntityDescriptor<T>;
   /**
    * Override the default PostgreSQL database provider.
    *
@@ -1528,16 +1186,16 @@ interface RepositoryDescriptorOptions<EntityTableConfig$1 extends TableConfig, E
    * @example TenantSpecificPostgresProvider
    * @example TestDatabaseProvider
    */
-  provider?: Service<PostgresProvider>;
+  provider?: DatabaseProvider;
+  name?: string;
 }
-declare class RepositoryDescriptor<EntityTableConfig$1 extends TableConfig, EntitySchema$1 extends TObject> extends Descriptor<RepositoryDescriptorOptions<EntityTableConfig$1, EntitySchema$1>> {
-  protected readonly pgRelationManager: PgRelationManager;
-  protected readonly pgQueryManager: PgQueryManager;
+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$1;
-  readonly schemaInsert: TObjectInsert<EntitySchema$1>;
+  readonly provider: DatabaseProvider;
+  constructor(args: DescriptorArgs<RepositoryDescriptorOptions<T>>);
   /**
    * Represents the primary key of the table.
    * - Key is the name of the primary key column.
@@ -1545,15 +1203,15 @@ declare class RepositoryDescriptor<EntityTableConfig$1 extends TableConfig, Enti
    *
    * 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$1["properties"];
+  get id(): {
+    type: TSchema;
+    key: keyof T["properties"];
     col: PgColumn;
   };
   /**
    * Get Drizzle table object.
    */
-  get table(): PgTableWithColumns<EntityTableConfig$1>;
+  get table(): PgTableWithColumns<SchemaToTableConfig<T>>;
   /**
    * Get SQL table name. (from Drizzle table object)
    */
@@ -1561,7 +1219,7 @@ declare class RepositoryDescriptor<EntityTableConfig$1 extends TableConfig, Enti
   /**
    * 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.
    *
@@ -1572,11 +1230,18 @@ declare class RepositoryDescriptor<EntityTableConfig$1 extends TableConfig, Enti
    *
    * @example
    * ```ts
-   * const users = $entity({ ... });
-   * const result = await repository.query(sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`, users.$schema);
+   * 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<T extends TObject = EntitySchema$1>(query: SQLLike | ((table: PgTableWithColumns<EntityTableConfig$1>, db: PgDatabase<any>) => SQLLike), schema?: T): Promise<Static<T>[]>;
+  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)
    */
@@ -1584,7 +1249,7 @@ declare class RepositoryDescriptor<EntityTableConfig$1 extends TableConfig, Enti
   /**
    * Get a Drizzle column from the table by his name.
    */
-  protected col(name: keyof PgTableWithColumns<EntityTableConfig$1>["_"]["columns"]): PgColumn;
+  protected col(name: keyof StaticEncode<T>): PgColumn;
   /**
    * Run a transaction.
    */
@@ -1592,15 +1257,15 @@ declare class RepositoryDescriptor<EntityTableConfig$1 extends TableConfig, Enti
   /**
    * Start a SELECT query on the table.
    */
-  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>, {}, {}>;
   }>;
   /**
    * Start a SELECT DISTINCT query on the table.
    */
-  protected selectDistinct(opts?: StatementOptions, columns?: (keyof Static<EntitySchema$1>)[]): pg$1.PgSelectBase<string, Record<string, any>, "partial", Record<string, "not-null">, false, never, {
+  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]: any;
@@ -1608,25 +1273,25 @@ declare class RepositoryDescriptor<EntityTableConfig$1 extends TableConfig, Enti
   /**
    * Start an INSERT query on the table.
    */
-  protected insert(opts?: StatementOptions): pg$1.PgInsertBuilder<PgTableWithColumns<EntityTableConfig$1>, any, false>;
+  protected insert(opts?: StatementOptions): drizzle_orm_pg_core0.PgInsertBuilder<PgTableWithColumns<SchemaToTableConfig<T>>, any, false>;
   /**
    * Start an UPDATE query on the table.
    */
-  protected update(opts?: StatementOptions): pg$1.PgUpdateBuilder<PgTableWithColumns<EntityTableConfig$1>, any>;
+  protected update(opts?: StatementOptions): drizzle_orm_pg_core0.PgUpdateBuilder<PgTableWithColumns<SchemaToTableConfig<T>>, any>;
   /**
    * Start a DELETE query on the table.
    */
-  protected delete(opts?: StatementOptions): pg$1.PgDeleteBase<PgTableWithColumns<EntityTableConfig$1>, any, undefined, undefined, false, never>;
+  protected delete(opts?: StatementOptions): drizzle_orm_pg_core0.PgDeleteBase<PgTableWithColumns<SchemaToTableConfig<T>>, any, undefined, undefined, false, never>;
   /**
    * Create a Drizzle `select` query based on a JSON query object.
    *
    * > This method is the base for `find`, `findOne`, `findById`, and `paginate`.
    */
-  find<R extends PgRelationMap<EntitySchema$1>>(query?: PgQueryRelations<EntitySchema$1, R>, opts?: StatementOptions): Promise<PgStatic<EntitySchema$1, R>[]>;
+  find<R extends PgRelationMap<T>>(query?: PgQueryRelations<T, R>, opts?: StatementOptions): Promise<PgStatic<T, R>[]>;
   /**
    * Find a single entity.
    */
-  findOne<R extends PgRelationMap<EntitySchema$1>>(query: Pick<PgQueryRelations<EntitySchema$1, R>, "with" | "where">, opts?: StatementOptions): Promise<PgStatic<EntitySchema$1, R>>;
+  findOne<R extends PgRelationMap<T>>(query: Pick<PgQueryRelations<T, R>, "with" | "where">, opts?: StatementOptions): Promise<PgStatic<T, R>>;
   /**
    * Find entities with pagination.
    *
@@ -1634,24 +1299,24 @@ declare class RepositoryDescriptor<EntityTableConfig$1 extends TableConfig, Enti
    *
    * > Pagination CAN also do a count query to get the total number of elements.
    */
-  paginate<R extends PgRelationMap<EntitySchema$1>>(pagination?: PageQuery, query?: PgQueryRelations<EntitySchema$1, R>, opts?: StatementOptions & {
+  paginate<R extends PgRelationMap<T>>(pagination?: PageQuery, query?: PgQueryRelations<T, R>, opts?: StatementOptions & {
     count?: boolean;
-  }): Promise<Page<PgStatic<EntitySchema$1, R>>>;
+  }): 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$1>>;
+  findById(id: string | number, opts?: StatementOptions): Promise<Static<T>>;
   /**
    * Helper to create a type-safe query object.
    */
-  createQuery(): PgQuery<EntitySchema$1>;
+  createQuery(): PgQuery<T>;
   /**
    * Helper to create a type-safe where clause.
    */
-  createQueryWhere(): PgQueryWhere<EntitySchema$1>;
+  createQueryWhere(): PgQueryWhere<T>;
   /**
    * Create an entity.
    *
@@ -1659,7 +1324,7 @@ declare class RepositoryDescriptor<EntityTableConfig$1 extends TableConfig, Enti
    * @param opts The options for creating the entity.
    * @returns The ID of the created entity.
    */
-  create(data: Static<TObjectInsert<EntitySchema$1>>, opts?: StatementOptions): Promise<Static<EntitySchema$1>>;
+  create(data: Static<TObjectInsert<T>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
    * Create many entities.
    *
@@ -1667,11 +1332,11 @@ declare class RepositoryDescriptor<EntityTableConfig$1 extends TableConfig, Enti
    * @param opts The statement options.
    * @returns The created entities.
    */
-  createMany(values: Array<Static<TObjectInsert<EntitySchema$1>>>, opts?: StatementOptions): Promise<Static<EntitySchema$1>[]>;
+  createMany(values: Array<Static<TObjectInsert<T>>>, opts?: StatementOptions): Promise<Static<T>[]>;
   /**
    * Find an entity and update it.
    */
-  updateOne(where: PgQueryWhereOrSQL<EntitySchema$1>, data: Partial<Static<TObjectUpdate<EntitySchema$1>>>, opts?: StatementOptions): Promise<Static<EntitySchema$1>>;
+  updateOne(where: PgQueryWhereOrSQL<T>, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
    * Save a given entity.
    *
@@ -1693,51 +1358,57 @@ declare class RepositoryDescriptor<EntityTableConfig$1 extends TableConfig, Enti
    * @see {@link PostgresTypeProvider#version}
    * @see {@link PgVersionMismatchError}
    */
-  save(entity: Static<EntitySchema$1>, opts?: StatementOptions): Promise<Static<EntitySchema$1>>;
+  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$1>>>, opts?: StatementOptions): Promise<Static<EntitySchema$1>>;
+  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$1>, data: Partial<Static<TObjectUpdate<EntitySchema$1>>>, 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$1>, 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$1>, 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$1>, 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$1>, 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$1>, opts?: {
+  protected withDeletedAt(where: PgQueryWhereOrSQL<T>, opts?: {
     force?: boolean;
-  }): PgQueryWhereOrSQL<EntitySchema$1>;
+  }): PgQueryWhereOrSQL<T>;
   protected deletedAt(): PgAttrField | undefined;
   /**
    * Convert something to valid Pg Insert Value.
    */
-  protected cast(data: any, insert: boolean): PgInsertValue<PgTableWithColumns<EntityTableConfig$1>>;
+  protected cast(data: any, insert: boolean): PgInsertValue<PgTableWithColumns<SchemaToTableConfig<T>>>;
   /**
    * Transform a row from the database into a clean entity.
    *
@@ -1746,37 +1417,31 @@ declare class RepositoryDescriptor<EntityTableConfig$1 extends TableConfig, Enti
    * - Fix date-time and date fields to ISO strings
    * - Cast BigInt to string
    */
-  protected clean<T extends TObject = EntitySchema$1>(row: Record<string, unknown>, schema?: T): Static<T>;
+  protected clean<T extends TObject>(row: Record<string, unknown>, schema: T): Static<T>;
   /**
    * Clean a row with joins recursively
    */
-  protected cleanWithJoins<T extends TObject = EntitySchema$1>(row: Record<string, unknown>, schema: T, joins: PgJoin[], parentPath?: string): Static<T>;
-  /**
-   * Build a schema that includes all join properties recursively
-   */
-  protected buildSchemaWithJoins(baseSchema: TObject, joins: PgJoin[], parentPath?: string): TObject;
+  protected cleanWithJoins<T extends TObject>(row: Record<string, unknown>, schema: T, joins: PgJoin[], parentPath?: string): Static<T>;
   /**
    * Convert a where clause to SQL.
    */
-  protected toSQL(where: PgQueryWhereOrSQL<EntitySchema$1>, joins?: PgJoin[]): SQL | undefined;
+  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): PgQueryWhere<EntitySchema$1>;
+  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.
@@ -1803,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.
@@ -2188,7 +1485,7 @@ declare class SequenceDescriptor extends Descriptor<SequenceDescriptorOptions> {
  * - Use appropriate isolation levels based on your consistency requirements
  */
 declare const $transaction: <T extends any[], R>(opts: TransactionDescriptorOptions<T, R>) => _alepha_retry0.RetryDescriptorFn<(...args: T) => Promise<R>>;
-interface TransactionDescriptorOptions<T$1 extends any[], R$1> {
+interface TransactionDescriptorOptions<T extends any[], R> {
   /**
    * Transaction handler function that contains all database operations to be executed atomically.
    *
@@ -2248,7 +1545,7 @@ interface TransactionDescriptorOptions<T$1 extends any[], R$1> {
    * }
    * ```
    */
-  handler: (tx: PgTransaction<any, any, any>, ...args: T$1) => Promise<R$1>;
+  handler: (tx: PgTransaction<any, any, any>, ...args: T) => Promise<R>;
   /**
    * PostgreSQL transaction configuration options.
    *
@@ -2322,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: typebox4.TObject<{
+  id: typebox4.TNumber;
+  name: typebox4.TString;
+  snapshot: typebox4.TString;
+  created_at: typebox4.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
@@ -2409,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.
    */
@@ -2474,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.
    */
@@ -2502,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'.
    *
@@ -2517,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<typebox4.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<typebox4.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<typebox0.TOptional<TString>, typeof PG_DELETED_AT>;
+  readonly deletedAt: (options?: TStringOptions) => PgAttr<typebox4.TOptional<typebox4.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>;
@@ -2540,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
@@ -2549,13 +1866,13 @@ declare const pg: PostgresTypeProvider;
 /**
  * @deprecated Use `pg.primaryKey()` instead.
  */
-declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<typebox0.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
+declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<typebox4.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";
@@ -2598,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, 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, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, PgTableConfig, PgTableWithColumnsAndSchema, PgVersionMismatchError, PostgresProvider, PostgresTypeProvider, 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