alepha 0.10.1 → 0.10.2

package/postgres.d.ts

@@ -1,6 +1,6 @@
 import * as _alepha_core1 from "alepha";
 import { Alepha, AlephaError, Descriptor, KIND, Service, Static, TArray, TBigInt, TBoolean, TInteger, TKeysToIndexer, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOptional, TOptionalAdd, TPick, TRecord, TSchema as TSchema$1, TString, TStringOptions, TUnion } from "alepha";
-import * as drizzle_orm7 from "drizzle-orm";
+import * as drizzle_orm0 from "drizzle-orm";
 import { BuildColumns, BuildExtraConfigColumns, SQL, SQLWrapper, TableConfig, sql } from "drizzle-orm";
 import * as pg$1 from "drizzle-orm/pg-core";
 import { AnyPgColumn, LockConfig, LockStrength, PgColumn, PgColumnBuilderBase, PgDatabase, PgInsertValue, PgSequenceOptions, PgTableExtraConfigValue, PgTableWithColumns, PgTransaction, PgTransactionConfig, SelectedFields, TableConfig as TableConfig$1, UpdateDeleteAction } from "drizzle-orm/pg-core";
@@ -10,7 +10,7 @@ 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 typebox0 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";
@@ -91,6 +91,7 @@ declare const insertSchema: <T extends TObject>(obj: T) => TObjectInsert<T>;
  * After:  { name?: string | null; age: number; }
  */
 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
 /**
@@ -104,14 +105,14 @@ declare const schemaToPgColumns: <T extends TObject>(schema: T) => FromSchema<T>
  * @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_orm7.IsIdentity<pg$1.PgBigInt64BuilderInitial<"">, "byDefault"> | drizzle_orm7.IsIdentity<pg$1.PgBigInt64BuilderInitial<"">, "always"> | pg$1.PgBigInt53BuilderInitial<string> | pg$1.PgNumericBuilderInitial<string> | pg$1.PgTimestampBuilderInitial<string> | pg$1.PgUUIDBuilderInitial<string> | pg$1.PgCustomColumnBuilder<{
+declare const mapFieldToColumn: (name: string, value: TSchema$1) => pg$1.PgSerialBuilderInitial<string> | pg$1.PgIntegerBuilderInitial<string> | drizzle_orm0.IsIdentity<pg$1.PgBigInt64BuilderInitial<"">, "byDefault"> | drizzle_orm0.IsIdentity<pg$1.PgBigInt64BuilderInitial<"">, "always"> | pg$1.PgBigInt53BuilderInitial<string> | pg$1.PgNumericBuilderInitial<string> | pg$1.PgTimestampBuilderInitial<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.PgDateStringBuilderInitial<string> | pg$1.PgTextBuilderInitial<string, [string, ...string[]]> | pg$1.PgBooleanBuilderInitial<string> | drizzle_orm7.$Type<pg$1.PgCustomColumnBuilder<{
+}> | pg$1.PgTimestampStringBuilderInitial<string> | pg$1.PgDateStringBuilderInitial<string> | pg$1.PgTextBuilderInitial<string, [string, ...string[]]> | pg$1.PgBooleanBuilderInitial<string> | drizzle_orm0.$Type<pg$1.PgCustomColumnBuilder<{
   name: string;
   dataType: "custom";
   columnType: "PgCustomColumn";
@@ -126,14 +127,14 @@ declare const mapFieldToColumn: (name: string, value: TSchema$1) => pg$1.PgSeria
   [x: string]: unknown;
   [x: number]: unknown;
   [x: symbol]: unknown;
-}> | drizzle_orm7.$Type<pg$1.PgCustomColumnBuilder<{
+}> | drizzle_orm0.$Type<pg$1.PgCustomColumnBuilder<{
   name: string;
   dataType: "custom";
   columnType: "PgCustomColumn";
   data: Record<string, unknown>;
   driverParam: string;
   enumValues: undefined;
-}>, Record<string, unknown>> | drizzle_orm7.$Type<pg$1.PgCustomColumnBuilder<{
+}>, Record<string, unknown>> | drizzle_orm0.$Type<pg$1.PgCustomColumnBuilder<{
   name: string;
   dataType: "custom";
   columnType: "PgCustomColumn";
@@ -1195,12 +1196,30 @@ type PgQueryWhere<T extends object> = { [Key in keyof T]?: FilterOperators<T[Key
 };
 //#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>>;
 interface PgQuery<T extends TObject> {
   distinct?: boolean;
   where?: PgQueryWhereOrSQL<Static<T>>;
   limit?: number;
   offset?: number;
-  sort?: { [key in keyof Static<T>]?: "asc" | "desc" };
+  orderBy?: OrderBy<Static<T>>;
   groupBy?: (keyof Static<T>)[];
 }
 type PgQueryResult<T extends TObject, Select extends (keyof Static<T>)[]> = TPick<T, TKeysToIndexer<Select>>;
@@ -1216,10 +1235,10 @@ declare abstract class PostgresProvider {
 }
 //#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: typebox0.TObject<{
+  page: typebox0.TOptional<typebox0.TInteger>;
+  size: typebox0.TOptional<typebox0.TInteger>;
+  sort: typebox0.TOptional<typebox0.TString>;
 }>;
 type PageQuery = Static<typeof pageQuerySchema>;
 //#endregion
@@ -1379,7 +1398,7 @@ type Page<T> = {
  *           filters.searchTerm ? { name: { ilike: `%${filters.searchTerm}%` } } : {}
  *         ]
  *       },
- *       sort: { createdAt: "desc" }
+ *       orderBy: [{ column: "createdAt", direction: "desc" }]
  *     });
  *
  *     return await this.products.paginate({ page, size }, query, { count: true });
@@ -1504,7 +1523,7 @@ type Page<T> = {
  *     // Automatically excludes soft-deleted records
  *     return await this.documents.find({
  *       where: { authorId: { isNotNull: true } },
- *       sort: { updatedAt: "desc" }
+ *       orderBy: [{ column: "updatedAt", direction: "desc" }]
  *     });
  *   }
  *
@@ -1666,7 +1685,7 @@ 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_orm7.ExtractTablesWithRelations<Record<string, never>>>;
+  protected get db(): PgDatabase<any, Record<string, never>, drizzle_orm0.ExtractTablesWithRelations<Record<string, never>>>;
   /**
    * Execute a SQL query.
    */
@@ -1691,10 +1710,10 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    *
    * @returns The SELECT query builder.
    */
-  protected select(opts?: StatementOptions): pg$1.PgSelectBase<string, Record<string, PgColumn<drizzle_orm7.ColumnBaseConfig<drizzle_orm7.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
+  protected select(opts?: StatementOptions): pg$1.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_orm7.ColumnBaseConfig<drizzle_orm7.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;
@@ -1866,6 +1885,36 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    * @returns The cleaned row.
    */
   protected clean<T extends TObject = EntitySchema>(row: any, 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
+   */
+  protected 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
+   */
+  protected normalizeOrderBy(orderBy: any): Array<{
+    column: string;
+    direction: "asc" | "desc";
+  }>;
   /**
    * Get the where clause for an ID.
    *
@@ -1881,7 +1930,7 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    */
   protected getPrimaryKey(schema: TObject): {
     key: string;
-    col: PgColumn<drizzle_orm7.ColumnBaseConfig<drizzle_orm7.ColumnDataType, string>, {}, {}>;
+    col: PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>;
     type: TSchema$1;
   };
 }
@@ -2287,373 +2336,12 @@ declare class SequenceDescriptor extends Descriptor<SequenceDescriptorOptions> {
  * It integrates seamlessly with the repository pattern and provides built-in handling
  * for optimistic locking scenarios with automatic retry on version mismatches.
  *
- * **Key Features**
- *
- * - **ACID Compliance**: Full transaction support with commit/rollback functionality
- * - **Automatic Retry Logic**: Built-in retry for optimistic locking conflicts
- * - **Type Safety**: Full TypeScript support with generic parameters
- * - **Isolation Levels**: Configurable transaction isolation levels
- * - **Error Handling**: Automatic rollback on errors with proper error propagation
- * - **Repository Integration**: Seamless integration with $repository operations
- * - **Performance**: Efficient transaction management with connection reuse
- *
- * **Use Cases**
- *
- * Essential for operations requiring atomicity and consistency:
- * - Financial transactions and accounting operations
- * - Complex business workflows with multiple database operations
- * - Data migrations and bulk operations
- * - E-commerce order processing with inventory updates
- * - User registration with related data creation
- * - Audit trail creation with business operations
- *
- * @example
- * **Basic transaction for financial operations:**
- * ```ts
- * import { $transaction } from "alepha/postgres";
- *
- * class BankingService {
- *   transfer = $transaction({
- *     handler: async (tx, fromAccountId: string, toAccountId: string, amount: number) => {
- *       // All operations within this transaction are atomic
- *       console.log(`Processing transfer: $${amount} from ${fromAccountId} to ${toAccountId}`);
- *
- *       // Get current account balances
- *       const fromAccount = await this.accounts.findById(fromAccountId, { tx });
- *       const toAccount = await this.accounts.findById(toAccountId, { tx });
- *
- *       // Validate sufficient balance
- *       if (fromAccount.balance < amount) {
- *         throw new Error(`Insufficient funds. Balance: $${fromAccount.balance}, Required: $${amount}`);
- *       }
- *
- *       // Update account balances atomically
- *       const updatedFromAccount = await this.accounts.updateById(
- *         fromAccountId,
- *         { balance: fromAccount.balance - amount },
- *         { tx }
- *       );
- *
- *       const updatedToAccount = await this.accounts.updateById(
- *         toAccountId,
- *         { balance: toAccount.balance + amount },
- *         { tx }
- *       );
- *
- *       // Create transaction record
- *       const transactionRecord = await this.transactions.create({
- *         id: generateUUID(),
- *         fromAccountId,
- *         toAccountId,
- *         amount,
- *         type: 'transfer',
- *         status: 'completed',
- *         processedAt: new Date().toISOString()
- *       }, { tx });
- *
- *       console.log(`Transfer completed successfully: ${transactionRecord.id}`);
- *
- *       return {
- *         transactionId: transactionRecord.id,
- *         fromBalance: updatedFromAccount.balance,
- *         toBalance: updatedToAccount.balance
- *       };
- *     }
- *   });
- *
- *   async transferFunds(fromAccountId: string, toAccountId: string, amount: number) {
- *     // This will automatically retry if there's a version mismatch (optimistic locking)
- *     return await this.transfer.run(fromAccountId, toAccountId, amount);
- *   }
- * }
- * ```
- *
- * @example
- * **E-commerce order processing with inventory management:**
- * ```ts
- * class OrderService {
- *   processOrder = $transaction({
- *     config: {
- *       isolationLevel: 'serializable'  // Highest isolation for critical operations
- *     },
- *     handler: async (tx, orderData: {
- *       customerId: string;
- *       items: Array<{ productId: string; quantity: number; price: number }>;
- *       shippingAddress: Address;
- *       paymentMethodId: string;
- *     }) => {
- *       console.log(`Processing order for customer ${orderData.customerId}`);
- *
- *       let totalAmount = 0;
- *       const orderItems = [];
- *
- *       // Process each item and update inventory atomically
- *       for (const itemData of orderData.items) {
- *         const product = await this.products.findById(itemData.productId, { tx });
- *
- *         // Check inventory availability
- *         if (product.stockQuantity < itemData.quantity) {
- *           throw new Error(`Insufficient stock for ${product.name}. Available: ${product.stockQuantity}, Requested: ${itemData.quantity}`);
- *         }
- *
- *         // Update product inventory with optimistic locking
- *         await this.products.save({
- *           ...product,
- *           stockQuantity: product.stockQuantity - itemData.quantity
- *         }, { tx });
- *
- *         // Calculate totals
- *         const lineTotal = itemData.price * itemData.quantity;
- *         totalAmount += lineTotal;
- *
- *         orderItems.push({
- *           id: generateUUID(),
- *           productId: itemData.productId,
- *           quantity: itemData.quantity,
- *           unitPrice: itemData.price,
- *           lineTotal
- *         });
- *       }
- *
- *       // Create the main order record
- *       const order = await this.orders.create({
- *         id: generateUUID(),
- *         customerId: orderData.customerId,
- *         status: 'pending',
- *         totalAmount,
- *         shippingAddress: orderData.shippingAddress,
- *         createdAt: new Date().toISOString()
- *       }, { tx });
- *
- *       // Create order items
- *       for (const itemData of orderItems) {
- *         await this.orderItems.create({
- *           ...itemData,
- *           orderId: order.id
- *         }, { tx });
- *       }
- *
- *       // Process payment
- *       const paymentResult = await this.paymentService.processPayment({
- *         orderId: order.id,
- *         amount: totalAmount,
- *         paymentMethodId: orderData.paymentMethodId,
- *         customerId: orderData.customerId
- *       }, { tx });
- *
- *       if (!paymentResult.success) {
- *         throw new Error(`Payment failed: ${paymentResult.error}`);
- *       }
- *
- *       // Update order status
- *       const completedOrder = await this.orders.updateById(
- *         order.id,
- *         {
- *           status: 'paid',
- *           paymentId: paymentResult.paymentId,
- *           paidAt: new Date().toISOString()
- *         },
- *         { tx }
- *       );
- *
- *       console.log(`Order processed successfully: ${order.id}`);
- *
- *       return {
- *         orderId: order.id,
- *         totalAmount,
- *         paymentId: paymentResult.paymentId,
- *         itemCount: orderItems.length
- *       };
- *     }
- *   });
- * }
- * ```
- *
- * @example
- * **User registration with related data creation:**
- * ```ts
- * class UserService {
- *   registerUser = $transaction({
- *     handler: async (tx, registrationData: {
- *       email: string;
- *       password: string;
- *       profile: {
- *         firstName: string;
- *         lastName: string;
- *         dateOfBirth: string;
- *       };
- *       preferences: {
- *         notifications: boolean;
- *         newsletter: boolean;
- *       };
- *     }) => {
- *       console.log(`Registering new user: ${registrationData.email}`);
- *
- *       // Check if email already exists
- *       const existingUser = await this.users.find(
- *         { where: { email: registrationData.email } },
- *         { tx }
- *       );
- *
- *       if (existingUser.length > 0) {
- *         throw new Error(`User with email ${registrationData.email} already exists`);
- *       }
- *
- *       // Hash password
- *       const hashedPassword = await this.hashPassword(registrationData.password);
- *
- *       // Create user record
- *       const user = await this.users.create({
- *         id: generateUUID(),
- *         email: registrationData.email,
- *         passwordHash: hashedPassword,
- *         isActive: true,
- *         emailVerified: false
- *       }, { tx });
- *
- *       // Create user profile
- *       const profile = await this.userProfiles.create({
- *         id: generateUUID(),
- *         userId: user.id,
- *         firstName: registrationData.profile.firstName,
- *         lastName: registrationData.profile.lastName,
- *         dateOfBirth: registrationData.profile.dateOfBirth
- *       }, { tx });
- *
- *       // Create user preferences
- *       const preferences = await this.userPreferences.create({
- *         id: generateUUID(),
- *         userId: user.id,
- *         notifications: registrationData.preferences.notifications,
- *         newsletter: registrationData.preferences.newsletter
- *       }, { tx });
- *
- *       // Create audit log entry
- *       await this.auditLogs.create({
- *         id: generateUUID(),
- *         userId: user.id,
- *         action: 'user_registered',
- *         details: { email: user.email },
- *         timestamp: new Date().toISOString()
- *       }, { tx });
- *
- *       console.log(`User registration completed: ${user.id}`);
- *
- *       return {
- *         userId: user.id,
- *         email: user.email,
- *         profile: {
- *           firstName: profile.firstName,
- *           lastName: profile.lastName
- *         }
- *       };
- *     }
- *   });
- * }
- * ```
- *
- * @example
- * **Data migration with progress tracking:**
- * ```ts
- * class MigrationService {
- *   migrateUserData = $transaction({
- *     config: {
- *       isolationLevel: 'read_committed',
- *       accessMode: 'read_write'
- *     },
- *     handler: async (tx, batchSize: number = 1000) => {
- *       console.log(`Starting data migration with batch size ${batchSize}`);
- *
- *       let totalMigrated = 0;
- *       let hasMore = true;
- *       let offset = 0;
- *
- *       while (hasMore) {
- *         // Get batch of users to migrate
- *         const users = await this.legacyUsers.find({
- *           limit: batchSize,
- *           offset,
- *           sort: { id: 'asc' }
- *         }, { tx });
- *
- *         if (users.length === 0) {
- *           hasMore = false;
- *           break;
- *         }
- *
- *         // Process each user in the batch
- *         for (const legacyUser of users) {
- *           try {
- *             // Transform legacy data to new format
- *             const newUser = {
- *               id: generateUUID(),
- *               email: legacyUser.email_address,
- *               firstName: legacyUser.first_name,
- *               lastName: legacyUser.last_name,
- *               createdAt: legacyUser.created_date,
- *               isActive: legacyUser.status === 'active'
- *             };
- *
- *             // Create new user record
- *             await this.users.create(newUser, { tx });
- *
- *             // Mark legacy user as migrated
- *             await this.legacyUsers.updateById(
- *               legacyUser.id,
- *               {
- *                 migrated: true,
- *                 migratedAt: new Date().toISOString(),
- *                 newUserId: newUser.id
- *               },
- *               { tx }
- *             );
- *
- *             totalMigrated++;
- *
- *           } catch (error) {
- *             console.error(`Failed to migrate user ${legacyUser.id}:`, error.message);
- *
- *             // Log failed migration
- *             await this.migrationErrors.create({
- *               id: generateUUID(),
- *               legacyUserId: legacyUser.id,
- *               error: error.message,
- *               attemptedAt: new Date().toISOString()
- *             }, { tx });
- *           }
- *         }
- *
- *         offset += batchSize;
- *         console.log(`Migrated ${totalMigrated} users so far...`);
- *       }
- *
- *       // Update migration status
- *       await this.migrationStatus.updateById(
- *         'user_migration',
- *         {
- *           totalMigrated,
- *           completedAt: new Date().toISOString(),
- *           status: 'completed'
- *         },
- *         { tx }
- *       );
- *
- *       console.log(`Migration completed. Total migrated: ${totalMigrated}`);
- *
- *       return { totalMigrated };
- *     }
- *   });
- * }
- * ```
- *
  * **Important Notes**:
  * - All operations within the transaction handler are atomic
  * - Automatic retry on `PgVersionMismatchError` for optimistic locking
  * - Pass `{ tx }` option to all repository operations within the transaction
  * - Transactions are automatically rolled back on any unhandled error
  * - Use appropriate isolation levels based on your consistency requirements
- *
- * @stability 2
  */
 declare const $transaction: <T extends any[], R>(opts: TransactionDescriptorOptions<T, R>) => _alepha_retry0.RetryDescriptorFn<(...args: T) => Promise<R>>;
 interface TransactionDescriptorOptions<T extends any[], R> {
@@ -2980,7 +2668,7 @@ declare class PostgresTypeProvider {
    * 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<typebox0.TOptional<TString>, typeof PG_DELETED_AT>;
   /**
    * Creates a reference to another table or schema. Basically a foreign key.
    */
@@ -3000,13 +2688,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<typebox0.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_orm7.$Type<pg$1.PgCustomColumnBuilder<{
+declare const schema: <TDocument extends TSchema$1>(name: string, document: TDocument) => drizzle_orm0.$Type<pg$1.PgCustomColumnBuilder<{
   name: string;
   dataType: "custom";
   columnType: "PgCustomColumn";
@@ -3056,7 +2744,7 @@ declare const schema: <TDocument extends TSchema$1>(name: string, document: TDoc
  * @see {@link $transaction}
  * @module alepha.postgres
  */
-declare const AlephaPostgres: _alepha_core1.Service<_alepha_core1.Module>;
+declare const AlephaPostgres: _alepha_core1.Service<_alepha_core1.Module<{}>>;
 //#endregion
-export { $entity, $repository, $sequence, $transaction, AlephaPostgres, DrizzleKitProvider, Entity, EntityDescriptorOptions, FilterOperators, FromSchema, NodePostgresProvider, NodePostgresProviderOptions, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SCHEMA, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgDefault, PgEntityNotFoundError, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryResult, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgSymbolKeys, PgSymbols, PgTableConfig, PgTableWithColumnsAndSchema, PostgresProvider, PostgresTypeProvider, RepositoryDescriptor, RepositoryDescriptorOptions, RepositoryProvider, SQLLike, SequenceDescriptor, SequenceDescriptorOptions, StatementOptions, TObjectInsert, TPage, TransactionContext, TransactionDescriptorOptions, camelToSnakeCase, drizzle_orm7 as drizzle, insertSchema, legacyIdSchema, mapFieldToColumn, mapStringToColumn, pageQuerySchema, pageSchema, pg, schema, schemaToPgColumns, sql };
+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_PRIMARY_KEY, PG_REF, PG_SCHEMA, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgDefault, PgEntityNotFoundError, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryResult, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgSymbolKeys, PgSymbols, PgTableConfig, PgTableWithColumnsAndSchema, PostgresProvider, PostgresTypeProvider, RepositoryDescriptor, RepositoryDescriptorOptions, RepositoryProvider, SQLLike, SequenceDescriptor, SequenceDescriptorOptions, StatementOptions, TObjectInsert, TObjectUpdate, TPage, TransactionContext, TransactionDescriptorOptions, camelToSnakeCase, drizzle_orm0 as drizzle, insertSchema, legacyIdSchema, mapFieldToColumn, mapStringToColumn, pageQuerySchema, pageSchema, pg, schema, schemaToPgColumns, sql, updateSchema };
 //# sourceMappingURL=index.d.ts.map

package/queue/redis.d.ts

@@ -23,7 +23,7 @@ declare class RedisQueueProvider implements QueueProvider {
  * @see {@link RedisQueueProvider}
  * @module alepha.queue.redis
  */
-declare const AlephaQueueRedis: _alepha_core0.Service<_alepha_core0.Module>;
+declare const AlephaQueueRedis: _alepha_core0.Service<_alepha_core0.Module<{}>>;
 //#endregion
 export { AlephaQueueRedis, RedisQueueProvider };
 //# sourceMappingURL=index.d.ts.map

package/queue.d.ts

@@ -754,7 +754,7 @@ declare class ConsumerDescriptor<T extends TSchema> extends Descriptor<ConsumerD
  * @see {@link $consumer}
  * @module alepha.queue
  */
-declare const AlephaQueue: _alepha_core1.Service<_alepha_core1.Module>;
+declare const AlephaQueue: _alepha_core1.Service<_alepha_core1.Module<{}>>;
 //#endregion
 export { $consumer, $queue, AlephaQueue, ConsumerDescriptor, ConsumerDescriptorOptions, MemoryQueueProvider, QueueDescriptor, QueueDescriptorOptions, QueueMessage, QueueMessageSchema, QueueProvider };
 //# sourceMappingURL=index.d.ts.map

package/react/auth.d.ts

@@ -488,7 +488,7 @@ declare module "alepha/react" {
  * @see {@link ReactAuthProvider}
  * @module alepha.react.auth
  */
-declare const AlephaReactAuth: _alepha_core4.Service<_alepha_core4.Module>;
+declare const AlephaReactAuth: _alepha_core4.Service<_alepha_core4.Module<{}>>;
 //#endregion
 export { $auth, AccessToken, AlephaReactAuth, AuthDescriptor, AuthDescriptorOptions, AuthExternal, AuthInternal, CredentialsOptions, OAuth2Options, OAuth2Profile, OidcOptions, ReactAuth, ReactAuthProvider, SessionExpiredError, useAuth };
 //# sourceMappingURL=index.d.ts.map

package/react/form.d.ts

@@ -171,7 +171,7 @@ declare module "alepha" {
  * @see {@link useForm}
  * @module alepha.react.form
  */
-declare const AlephaReactForm: _alepha_core0.Service<_alepha_core0.Module>;
+declare const AlephaReactForm: _alepha_core0.Service<_alepha_core0.Module<{}>>;
 //#endregion
 export { AlephaReactForm, FormCtrlOptions, FormEventLike, FormModel, FormState, FormStateEvent, InputField, InputHTMLAttributesLike, SchemaToInput, UseFormStateReturn, useForm, useFormState };
 //# sourceMappingURL=index.d.ts.map

package/react/head.d.ts

@@ -114,7 +114,7 @@ declare module "alepha/react" {
  * @see {@link ServerHeadProvider}
  * @module alepha.react.head
  */
-declare const AlephaReactHead: _alepha_core1.Service<_alepha_core1.Module>;
+declare const AlephaReactHead: _alepha_core1.Service<_alepha_core1.Module<{}>>;
 //#endregion
 export { $head, AlephaReactHead, Head, HeadDescriptor, HeadDescriptorOptions, ServerHeadProvider, SimpleHead, UseHeadOptions, UseHeadReturn, useHead };
 //# sourceMappingURL=index.d.ts.map

package/react/i18n.d.ts

@@ -109,7 +109,7 @@ declare module "alepha" {
  *
  * @module alepha.react.i18n
  */
-declare const AlephaReactI18n: _alepha_core1.Service<_alepha_core1.Module>;
+declare const AlephaReactI18n: _alepha_core1.Service<_alepha_core1.Module<{}>>;
 //#endregion
 export { $dictionary, AlephaReactI18n, DictionaryDescriptor, DictionaryDescriptorOptions, I18nProvider, ServiceDictionary, useI18n };
 //# sourceMappingURL=index.d.ts.map