alepha 0.14.4 → 0.15.0

package/dist/api/users/index.d.ts

@@ -1,18 +1,18 @@
-import * as alepha1 from "alepha";
+import * as alepha23 from "alepha";
 import { Alepha, AlephaError, Page, PageQuery, Primitive, Static, StaticEncode, TNull, TObject, TOptional, TSchema, TUnion } from "alepha";
 import * as alepha_api_notifications0 from "alepha/api/notifications";
 import { VerificationController } from "alepha/api/verifications";
 import * as alepha_server0 from "alepha/server";
-import * as alepha_orm0 from "alepha/orm";
+import * as alepha_orm24 from "alepha/orm";
 import { Page as Page$1, Repository } from "alepha/orm";
 import { AuditService } from "alepha/api/audits";
 import * as alepha_logger5 from "alepha/logger";
 import * as alepha_bucket0 from "alepha/bucket";
-import * as alepha_server_links2 from "alepha/server/links";
+import * as alepha_server_links0 from "alepha/server/links";
+import { OAuth2Profile, ServerAuthProvider, WithLinkFn, WithLoginFn } from "alepha/server/auth";
 import * as alepha_cache0 from "alepha/cache";
 import { DateTime, DateTimeProvider } from "alepha/datetime";
-import { CryptoProvider, RealmPrimitive, RealmPrimitiveOptions, UserAccount } from "alepha/security";
-import { OAuth2Profile, ServerAuthProvider, WithLinkFn, WithLoginFn } from "alepha/server/auth";
+import { CryptoProvider, IssuerPrimitive, IssuerPrimitiveOptions, UserAccount } from "alepha/security";
 import { FileSystemProvider } from "alepha/file";
 import { FileController } from "alepha/api/files";
 import "drizzle-orm/d1";
@@ -24,33 +24,31 @@ import { PgTransactionConfig } from "drizzle-orm/pg-core/session";
 import * as DrizzleKit from "drizzle-kit/api";
 import "alepha/retry";
 import "drizzle-orm/sqlite-core";
-import "alepha/lock";
-import "drizzle-orm/postgres-js";
-import "postgres";
 
 //#region ../../src/api/users/atoms/realmAuthSettingsAtom.d.ts
-declare const realmAuthSettingsAtom: alepha1.Atom<alepha1.TObject<{
-  displayName: alepha1.TOptional<alepha1.TString>;
-  description: alepha1.TOptional<alepha1.TString>;
-  logoUrl: alepha1.TOptional<alepha1.TString>;
-  registrationAllowed: alepha1.TBoolean;
-  emailEnabled: alepha1.TBoolean;
-  emailRequired: alepha1.TBoolean;
-  usernameEnabled: alepha1.TBoolean;
-  usernameRequired: alepha1.TBoolean;
-  phoneEnabled: alepha1.TBoolean;
-  phoneRequired: alepha1.TBoolean;
-  verifyEmailRequired: alepha1.TBoolean;
-  verifyPhoneRequired: alepha1.TBoolean;
-  firstNameLastNameEnabled: alepha1.TBoolean;
-  firstNameLastNameRequired: alepha1.TBoolean;
-  resetPasswordAllowed: alepha1.TBoolean;
-  passwordPolicy: alepha1.TObject<{
-    minLength: alepha1.TInteger;
-    requireUppercase: alepha1.TBoolean;
-    requireLowercase: alepha1.TBoolean;
-    requireNumbers: alepha1.TBoolean;
-    requireSpecialCharacters: alepha1.TBoolean;
+declare const realmAuthSettingsAtom: alepha23.Atom<alepha23.TObject<{
+  displayName: alepha23.TOptional<alepha23.TString>;
+  description: alepha23.TOptional<alepha23.TString>;
+  logoUrl: alepha23.TOptional<alepha23.TString>;
+  registrationAllowed: alepha23.TBoolean;
+  emailEnabled: alepha23.TBoolean;
+  emailRequired: alepha23.TBoolean;
+  usernameEnabled: alepha23.TBoolean;
+  usernameRequired: alepha23.TBoolean;
+  usernameRegExp: alepha23.TString;
+  phoneEnabled: alepha23.TBoolean;
+  phoneRequired: alepha23.TBoolean;
+  verifyEmailRequired: alepha23.TBoolean;
+  verifyPhoneRequired: alepha23.TBoolean;
+  firstNameLastNameEnabled: alepha23.TBoolean;
+  firstNameLastNameRequired: alepha23.TBoolean;
+  resetPasswordAllowed: alepha23.TBoolean;
+  passwordPolicy: alepha23.TObject<{
+    minLength: alepha23.TInteger;
+    requireUppercase: alepha23.TBoolean;
+    requireLowercase: alepha23.TBoolean;
+    requireNumbers: alepha23.TBoolean;
+    requireSpecialCharacters: alepha23.TBoolean;
   }>;
 }>, "alepha.api.users.realmAuthSettings">;
 type RealmAuthSettings = Static<typeof realmAuthSettingsAtom.schema>;
@@ -85,114 +83,114 @@ type TObjectUpdate<T extends TObject> = TObject<{ [K in keyof T["properties"]]:
 //#region ../../src/orm/primitives/$entity.d.ts
 interface EntityPrimitiveOptions<T extends TObject, Keys = keyof Static<T>> {
   /**
-   * The database table name that will be created for this entity.
-   * If not provided, name will be inferred from the $repository variable name.
-   */
+       * The database table name that will be created for this entity.
+       * If not provided, name will be inferred from the $repository variable name.
+       */
   name: string;
   /**
-   * TypeBox schema defining the table structure and column types.
-   */
+       * TypeBox schema defining the table structure and column types.
+       */
   schema: T;
   /**
-   * Database indexes to create for query optimization.
-   */
+       * Database indexes to create for query optimization.
+       */
   indexes?: (Keys | {
     /**
-     * Single column to index.
-     */
+             * Single column to index.
+             */
     column: Keys;
     /**
-     * Whether this should be a unique index (enforces uniqueness constraint).
-     */
+             * Whether this should be a unique index (enforces uniqueness constraint).
+             */
     unique?: boolean;
     /**
-     * Custom name for the index. If not provided, generates name automatically.
-     */
+             * Custom name for the index. If not provided, generates name automatically.
+             */
     name?: string;
   } | {
     /**
-     * Multiple columns for composite index (order matters for query optimization).
-     */
+             * Multiple columns for composite index (order matters for query optimization).
+             */
     columns: Keys[];
     /**
-     * Whether this should be a unique index (enforces uniqueness constraint).
-     */
+             * Whether this should be a unique index (enforces uniqueness constraint).
+             */
     unique?: boolean;
     /**
-     * Custom name for the index. If not provided, generates name automatically.
-     */
+             * Custom name for the index. If not provided, generates name automatically.
+             */
     name?: string;
   })[];
   /**
-   * Foreign key constraints to maintain referential integrity.
-   */
+       * Foreign key constraints to maintain referential integrity.
+       */
   foreignKeys?: Array<{
     /**
-     * Optional name for the foreign key constraint.
-     */
+             * Optional name for the foreign key constraint.
+             */
     name?: string;
     /**
-     * Local columns that reference the foreign table.
-     */
+             * Local columns that reference the foreign table.
+             */
     columns: Array<keyof Static<T>>;
     /**
-     * Referenced columns in the foreign table.
-     * Must be EntityColumn references from other entities.
-     */
+             * Referenced columns in the foreign table.
+             * Must be EntityColumn references from other entities.
+             */
     foreignColumns: Array<() => EntityColumn<any>>;
   }>;
   /**
-   * Additional table constraints for data validation.
-   *
-   * Constraints enforce business rules at the database level, providing
-   * an additional layer of data integrity beyond application validation.
-   *
-   * **Constraint Types**:
-   * - **Unique constraints**: Prevent duplicate values across columns
-   * - **Check constraints**: Enforce custom validation rules with SQL expressions
-   *
-   * @example
-   * ```ts
-   * constraints: [
-   *   {
-   *     name: "unique_user_email",
-   *     columns: ["email"],
-   *     unique: true
-   *   },
-   *   {
-   *     name: "valid_age_range",
-   *     columns: ["age"],
-   *     check: sql`age >= 0 AND age <= 150`
-   *   },
-   *   {
-   *     name: "unique_user_username_per_tenant",
-   *     columns: ["tenantId", "username"],
-   *     unique: true
-   *   }
-   * ]
-   * ```
-   */
+       * Additional table constraints for data validation.
+       *
+       * Constraints enforce business rules at the database level, providing
+       * an additional layer of data integrity beyond application validation.
+       *
+       * **Constraint Types**:
+       * - **Unique constraints**: Prevent duplicate values across columns
+       * - **Check constraints**: Enforce custom validation rules with SQL expressions
+       *
+       * @example
+       * ```ts
+       * constraints: [
+       *   {
+       *     name: "unique_user_email",
+       *     columns: ["email"],
+       *     unique: true
+       *   },
+       *   {
+       *     name: "valid_age_range",
+       *     columns: ["age"],
+       *     check: sql`age >= 0 AND age <= 150`
+       *   },
+       *   {
+       *     name: "unique_user_username_per_tenant",
+       *     columns: ["tenantId", "username"],
+       *     unique: true
+       *   }
+       * ]
+       * ```
+       */
   constraints?: Array<{
     /**
-     * Columns involved in this constraint.
-     */
+             * Columns involved in this constraint.
+             */
     columns: Array<keyof Static<T>>;
     /**
-     * Optional name for the constraint.
-     */
+             * Optional name for the constraint.
+             */
     name?: string;
     /**
-     * Whether this is a unique constraint.
-     */
+             * Whether this is a unique constraint.
+             */
     unique?: boolean | {};
     /**
-     * SQL expression for check constraint validation.
-     */
+             * SQL expression for check constraint validation.
+             */
     check?: SQL;
   }>;
   /**
-   * Advanced Drizzle ORM configuration for complex table setups.
-   */
+       * Advanced Drizzle ORM configuration for complex table setups.
+       */
   config?: (self: BuildExtraConfigColumns<string, FromSchema<T>, "pg">) => PgTableExtraConfigValue[];
 }
 declare class EntityPrimitive<T extends TObject = TObject> {
@@ -246,8 +244,8 @@ type PgSymbols = {
   [PG_REF]: PgRefOptions;
   [PG_ENUM]: PgEnumOptions;
   /**
-   * @deprecated Use `PG_IDENTITY` instead.
-   */
+       * @deprecated Use `PG_IDENTITY` instead.
+       */
   [PG_SERIAL]: {};
 };
 type PgSymbolKeys = keyof PgSymbols;
@@ -280,416 +278,416 @@ declare class DbError extends AlephaError {
 //#region ../../src/orm/interfaces/FilterOperators.d.ts
 interface FilterOperators<TValue> {
   /**
-   * Test that two values are equal.
-   *
-   * Remember that the SQL standard dictates that
-   * two NULL values are not equal, so if you want to test
-   * whether a value is null, you may want to use
-   * `isNull` instead.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select cars made by Ford
-   * db.select().from(cars)
-   *   .where(eq(cars.make, 'Ford'))
-   * ```
-   *
-   * @see isNull for a way to test equality to NULL.
-   */
+       * Test that two values are equal.
+       *
+       * Remember that the SQL standard dictates that
+       * two NULL values are not equal, so if you want to test
+       * whether a value is null, you may want to use
+       * `isNull` instead.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select cars made by Ford
+       * db.select().from(cars)
+       *   .where(eq(cars.make, 'Ford'))
+       * ```
+       *
+       * @see isNull for a way to test equality to NULL.
+       */
   eq?: TValue;
   /**
-   * Test that two values are not equal.
-   *
-   * Remember that the SQL standard dictates that
-   * two NULL values are not equal, so if you want to test
-   * whether a value is not null, you may want to use
-   * `isNotNull` instead.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select cars not made by Ford
-   * db.select().from(cars)
-   *   .where(ne(cars.make, 'Ford'))
-   * ```
-   *
-   * @see isNotNull for a way to test whether a value is not null.
-   */
+       * Test that two values are not equal.
+       *
+       * Remember that the SQL standard dictates that
+       * two NULL values are not equal, so if you want to test
+       * whether a value is not null, you may want to use
+       * `isNotNull` instead.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select cars not made by Ford
+       * db.select().from(cars)
+       *   .where(ne(cars.make, 'Ford'))
+       * ```
+       *
+       * @see isNotNull for a way to test whether a value is not null.
+       */
   ne?: TValue;
   /**
-   * Test that the first expression passed is greater than
-   * the second expression.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select cars made after 2000.
-   * db.select().from(cars)
-   *   .where(gt(cars.year, 2000))
-   * ```
-   *
-   * @see gte for greater-than-or-equal
-   */
+       * Test that the first expression passed is greater than
+       * the second expression.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select cars made after 2000.
+       * db.select().from(cars)
+       *   .where(gt(cars.year, 2000))
+       * ```
+       *
+       * @see gte for greater-than-or-equal
+       */
   gt?: TValue;
   /**
-   * Test that the first expression passed is greater than
-   * or equal to the second expression. Use `gt` to
-   * test whether an expression is strictly greater
-   * than another.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select cars made on or after 2000.
-   * db.select().from(cars)
-   *   .where(gte(cars.year, 2000))
-   * ```
-   *
-   * @see gt for a strictly greater-than condition
-   */
+       * Test that the first expression passed is greater than
+       * or equal to the second expression. Use `gt` to
+       * test whether an expression is strictly greater
+       * than another.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select cars made on or after 2000.
+       * db.select().from(cars)
+       *   .where(gte(cars.year, 2000))
+       * ```
+       *
+       * @see gt for a strictly greater-than condition
+       */
   gte?: TValue;
   /**
-   * Test that the first expression passed is less than
-   * the second expression.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select cars made before 2000.
-   * db.select().from(cars)
-   *   .where(lt(cars.year, 2000))
-   * ```
-   *
-   * @see lte for greater-than-or-equal
-   */
+       * Test that the first expression passed is less than
+       * the second expression.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select cars made before 2000.
+       * db.select().from(cars)
+       *   .where(lt(cars.year, 2000))
+       * ```
+       *
+       * @see lte for greater-than-or-equal
+       */
   lt?: TValue;
   /**
-   * Test that the first expression passed is less than
-   * or equal to the second expression.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select cars made before 2000.
-   * db.select().from(cars)
-   *   .where(lte(cars.year, 2000))
-   * ```
-   *
-   * @see lt for a strictly less-than condition
-   */
+       * Test that the first expression passed is less than
+       * or equal to the second expression.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select cars made before 2000.
+       * db.select().from(cars)
+       *   .where(lte(cars.year, 2000))
+       * ```
+       *
+       * @see lt for a strictly less-than condition
+       */
   lte?: TValue;
   /**
-   * Test whether the first parameter, a column or expression,
-   * has a value from a list passed as the second argument.
-   *
-   * ## Throws
-   *
-   * The argument passed in the second array can't be empty:
-   * if an empty is provided, this method will throw.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select cars made by Ford or GM.
-   * db.select().from(cars)
-   *   .where(inArray(cars.make, ['Ford', 'GM']))
-   * ```
-   *
-   * @see notInArray for the inverse of this test
-   */
+       * Test whether the first parameter, a column or expression,
+       * has a value from a list passed as the second argument.
+       *
+       * ## Throws
+       *
+       * The argument passed in the second array can't be empty:
+       * if an empty is provided, this method will throw.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select cars made by Ford or GM.
+       * db.select().from(cars)
+       *   .where(inArray(cars.make, ['Ford', 'GM']))
+       * ```
+       *
+       * @see notInArray for the inverse of this test
+       */
   inArray?: TValue[];
   /**
-   * Test whether the first parameter, a column or expression,
-   * has a value that is not present in a list passed as the
-   * second argument.
-   *
-   * ## Throws
-   *
-   * The argument passed in the second array can't be empty:
-   * if an empty is provided, this method will throw.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select cars made by any company except Ford or GM.
-   * db.select().from(cars)
-   *   .where(notInArray(cars.make, ['Ford', 'GM']))
-   * ```
-   *
-   * @see inArray for the inverse of this test
-   */
+       * Test whether the first parameter, a column or expression,
+       * has a value that is not present in a list passed as the
+       * second argument.
+       *
+       * ## Throws
+       *
+       * The argument passed in the second array can't be empty:
+       * if an empty is provided, this method will throw.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select cars made by any company except Ford or GM.
+       * db.select().from(cars)
+       *   .where(notInArray(cars.make, ['Ford', 'GM']))
+       * ```
+       *
+       * @see inArray for the inverse of this test
+       */
   notInArray?: TValue[];
   /**
-   * Test whether an expression is not NULL. By the SQL standard,
-   * NULL is neither equal nor not equal to itself, so
-   * it's recommended to use `isNull` and `notIsNull` for
-   * comparisons to NULL.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select cars that have been discontinued.
-   * db.select().from(cars)
-   *   .where(isNotNull(cars.discontinuedAt))
-   * ```
-   *
-   * @see isNull for the inverse of this test
-   */
+       * Test whether an expression is not NULL. By the SQL standard,
+       * NULL is neither equal nor not equal to itself, so
+       * it's recommended to use `isNull` and `notIsNull` for
+       * comparisons to NULL.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select cars that have been discontinued.
+       * db.select().from(cars)
+       *   .where(isNotNull(cars.discontinuedAt))
+       * ```
+       *
+       * @see isNull for the inverse of this test
+       */
   isNotNull?: true;
   /**
-   * Test whether an expression is NULL. By the SQL standard,
-   * NULL is neither equal nor not equal to itself, so
-   * it's recommended to use `isNull` and `notIsNull` for
-   * comparisons to NULL.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select cars that have no discontinuedAt date.
-   * db.select().from(cars)
-   *   .where(isNull(cars.discontinuedAt))
-   * ```
-   *
-   * @see isNotNull for the inverse of this test
-   */
+       * Test whether an expression is NULL. By the SQL standard,
+       * NULL is neither equal nor not equal to itself, so
+       * it's recommended to use `isNull` and `notIsNull` for
+       * comparisons to NULL.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select cars that have no discontinuedAt date.
+       * db.select().from(cars)
+       *   .where(isNull(cars.discontinuedAt))
+       * ```
+       *
+       * @see isNotNull for the inverse of this test
+       */
   isNull?: true;
   /**
-   * Test whether an expression is between two values. This
-   * is an easier way to express range tests, which would be
-   * expressed mathematically as `x <= a <= y` but in SQL
-   * would have to be like `a >= x AND a <= y`.
-   *
-   * Between is inclusive of the endpoints: if `column`
-   * is equal to `min` or `max`, it will be TRUE.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select cars made between 1990 and 2000
-   * db.select().from(cars)
-   *   .where(between(cars.year, 1990, 2000))
-   * ```
-   *
-   * @see notBetween for the inverse of this test
-   */
+       * Test whether an expression is between two values. This
+       * is an easier way to express range tests, which would be
+       * expressed mathematically as `x <= a <= y` but in SQL
+       * would have to be like `a >= x AND a <= y`.
+       *
+       * Between is inclusive of the endpoints: if `column`
+       * is equal to `min` or `max`, it will be TRUE.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select cars made between 1990 and 2000
+       * db.select().from(cars)
+       *   .where(between(cars.year, 1990, 2000))
+       * ```
+       *
+       * @see notBetween for the inverse of this test
+       */
   between?: [number, number];
   /**
-   * Test whether an expression is not between two values.
-   *
-   * This, like `between`, includes its endpoints, so if
-   * the `column` is equal to `min` or `max`, in this case
-   * it will evaluate to FALSE.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Exclude cars made in the 1970s
-   * db.select().from(cars)
-   *   .where(notBetween(cars.year, 1970, 1979))
-   * ```
-   *
-   * @see between for the inverse of this test
-   */
+       * Test whether an expression is not between two values.
+       *
+       * This, like `between`, includes its endpoints, so if
+       * the `column` is equal to `min` or `max`, in this case
+       * it will evaluate to FALSE.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Exclude cars made in the 1970s
+       * db.select().from(cars)
+       *   .where(notBetween(cars.year, 1970, 1979))
+       * ```
+       *
+       * @see between for the inverse of this test
+       */
   notBetween?: [number, number];
   /**
-   * Compare a column to a pattern, which can include `%` and `_`
-   * characters to match multiple variations. Including `%`
-   * in the pattern matches zero or more characters, and including
-   * `_` will match a single character.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select all cars with 'Turbo' in their names.
-   * db.select().from(cars)
-   *   .where(like(cars.name, '%Turbo%'))
-   * ```
-   *
-   * @see ilike for a case-insensitive version of this condition
-   */
+       * Compare a column to a pattern, which can include `%` and `_`
+       * characters to match multiple variations. Including `%`
+       * in the pattern matches zero or more characters, and including
+       * `_` will match a single character.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select all cars with 'Turbo' in their names.
+       * db.select().from(cars)
+       *   .where(like(cars.name, '%Turbo%'))
+       * ```
+       *
+       * @see ilike for a case-insensitive version of this condition
+       */
   like?: string;
   /**
-   * The inverse of like - this tests that a given column
-   * does not match a pattern, which can include `%` and `_`
-   * characters to match multiple variations. Including `%`
-   * in the pattern matches zero or more characters, and including
-   * `_` will match a single character.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select all cars that don't have "ROver" in their name.
-   * db.select().from(cars)
-   *   .where(notLike(cars.name, '%Rover%'))
-   * ```
-   *
-   * @see like for the inverse condition
-   * @see notIlike for a case-insensitive version of this condition
-   */
+       * The inverse of like - this tests that a given column
+       * does not match a pattern, which can include `%` and `_`
+       * characters to match multiple variations. Including `%`
+       * in the pattern matches zero or more characters, and including
+       * `_` will match a single character.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select all cars that don't have "ROver" in their name.
+       * db.select().from(cars)
+       *   .where(notLike(cars.name, '%Rover%'))
+       * ```
+       *
+       * @see like for the inverse condition
+       * @see notIlike for a case-insensitive version of this condition
+       */
   notLike?: string;
   /**
-   * Case-insensitively compare a column to a pattern,
-   * which can include `%` and `_`
-   * characters to match multiple variations. Including `%`
-   * in the pattern matches zero or more characters, and including
-   * `_` will match a single character.
-   *
-   * Unlike like, this performs a case-insensitive comparison.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select all cars with 'Turbo' in their names.
-   * db.select().from(cars)
-   *   .where(ilike(cars.name, '%Turbo%'))
-   * ```
-   *
-   * @see like for a case-sensitive version of this condition
-   */
+       * Case-insensitively compare a column to a pattern,
+       * which can include `%` and `_`
+       * characters to match multiple variations. Including `%`
+       * in the pattern matches zero or more characters, and including
+       * `_` will match a single character.
+       *
+       * Unlike like, this performs a case-insensitive comparison.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select all cars with 'Turbo' in their names.
+       * db.select().from(cars)
+       *   .where(ilike(cars.name, '%Turbo%'))
+       * ```
+       *
+       * @see like for a case-sensitive version of this condition
+       */
   ilike?: string;
   /**
-   * The inverse of ilike - this case-insensitively tests that a given column
-   * does not match a pattern, which can include `%` and `_`
-   * characters to match multiple variations. Including `%`
-   * in the pattern matches zero or more characters, and including
-   * `_` will match a single character.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select all cars that don't have "Rover" in their name.
-   * db.select().from(cars)
-   *   .where(notLike(cars.name, '%Rover%'))
-   * ```
-   *
-   * @see ilike for the inverse condition
-   * @see notLike for a case-sensitive version of this condition
-   */
+       * The inverse of ilike - this case-insensitively tests that a given column
+       * does not match a pattern, which can include `%` and `_`
+       * characters to match multiple variations. Including `%`
+       * in the pattern matches zero or more characters, and including
+       * `_` will match a single character.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select all cars that don't have "Rover" in their name.
+       * db.select().from(cars)
+       *   .where(notLike(cars.name, '%Rover%'))
+       * ```
+       *
+       * @see ilike for the inverse condition
+       * @see notLike for a case-sensitive version of this condition
+       */
   notIlike?: string;
   /**
-   * Syntactic sugar for case-insensitive substring matching.
-   * Automatically wraps the value with `%` wildcards on both sides.
-   *
-   * Equivalent to: `ilike: '%value%'`
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select all cars with "Turbo" anywhere in their name.
-   * db.select().from(cars)
-   *   .where({ name: { contains: 'Turbo' } })
-   * // Same as: .where(ilike(cars.name, '%Turbo%'))
-   * ```
-   *
-   * @see ilike for manual pattern matching
-   * @see startsWith for prefix matching
-   * @see endsWith for suffix matching
-   */
+       * Syntactic sugar for case-insensitive substring matching.
+       * Automatically wraps the value with `%` wildcards on both sides.
+       *
+       * Equivalent to: `ilike: '%value%'`
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select all cars with "Turbo" anywhere in their name.
+       * db.select().from(cars)
+       *   .where({ name: { contains: 'Turbo' } })
+       * // Same as: .where(ilike(cars.name, '%Turbo%'))
+       * ```
+       *
+       * @see ilike for manual pattern matching
+       * @see startsWith for prefix matching
+       * @see endsWith for suffix matching
+       */
   contains?: string;
   /**
-   * Syntactic sugar for case-insensitive prefix matching.
-   * Automatically appends a `%` wildcard to the end of the value.
-   *
-   * Equivalent to: `ilike: 'value%'`
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select all cars whose names start with "Ford".
-   * db.select().from(cars)
-   *   .where({ name: { startsWith: 'Ford' } })
-   * // Same as: .where(ilike(cars.name, 'Ford%'))
-   * ```
-   *
-   * @see ilike for manual pattern matching
-   * @see contains for substring matching
-   * @see endsWith for suffix matching
-   */
+       * Syntactic sugar for case-insensitive prefix matching.
+       * Automatically appends a `%` wildcard to the end of the value.
+       *
+       * Equivalent to: `ilike: 'value%'`
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select all cars whose names start with "Ford".
+       * db.select().from(cars)
+       *   .where({ name: { startsWith: 'Ford' } })
+       * // Same as: .where(ilike(cars.name, 'Ford%'))
+       * ```
+       *
+       * @see ilike for manual pattern matching
+       * @see contains for substring matching
+       * @see endsWith for suffix matching
+       */
   startsWith?: string;
   /**
-   * Syntactic sugar for case-insensitive suffix matching.
-   * Automatically prepends a `%` wildcard to the beginning of the value.
-   *
-   * Equivalent to: `ilike: '%value'`
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select all cars whose names end with "Turbo".
-   * db.select().from(cars)
-   *   .where({ name: { endsWith: 'Turbo' } })
-   * // Same as: .where(ilike(cars.name, '%Turbo'))
-   * ```
-   *
-   * @see ilike for manual pattern matching
-   * @see contains for substring matching
-   * @see startsWith for prefix matching
-   */
+       * Syntactic sugar for case-insensitive suffix matching.
+       * Automatically prepends a `%` wildcard to the beginning of the value.
+       *
+       * Equivalent to: `ilike: '%value'`
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select all cars whose names end with "Turbo".
+       * db.select().from(cars)
+       *   .where({ name: { endsWith: 'Turbo' } })
+       * // Same as: .where(ilike(cars.name, '%Turbo'))
+       * ```
+       *
+       * @see ilike for manual pattern matching
+       * @see contains for substring matching
+       * @see startsWith for prefix matching
+       */
   endsWith?: string;
   /**
-   * Test that a column or expression contains all elements of
-   * the list passed as the second argument.
-   *
-   * ## Throws
-   *
-   * The argument passed in the second array can't be empty:
-   * if an empty is provided, this method will throw.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select posts where its tags contain "Typescript" and "ORM".
-   * db.select().from(posts)
-   *   .where(arrayContains(posts.tags, ['Typescript', 'ORM']))
-   * ```
-   *
-   * @see arrayContained to find if an array contains all elements of a column or expression
-   * @see arrayOverlaps to find if a column or expression contains any elements of an array
-   */
+       * Test that a column or expression contains all elements of
+       * the list passed as the second argument.
+       *
+       * ## Throws
+       *
+       * The argument passed in the second array can't be empty:
+       * if an empty is provided, this method will throw.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select posts where its tags contain "Typescript" and "ORM".
+       * db.select().from(posts)
+       *   .where(arrayContains(posts.tags, ['Typescript', 'ORM']))
+       * ```
+       *
+       * @see arrayContained to find if an array contains all elements of a column or expression
+       * @see arrayOverlaps to find if a column or expression contains any elements of an array
+       */
   arrayContains?: TValue;
   /**
-   * Test that the list passed as the second argument contains
-   * all elements of a column or expression.
-   *
-   * ## Throws
-   *
-   * The argument passed in the second array can't be empty:
-   * if an empty is provided, this method will throw.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select posts where its tags contain "Typescript", "ORM" or both,
-   * // but filtering posts that have additional tags.
-   * db.select().from(posts)
-   *   .where(arrayContained(posts.tags, ['Typescript', 'ORM']))
-   * ```
-   *
-   * @see arrayContains to find if a column or expression contains all elements of an array
-   * @see arrayOverlaps to find if a column or expression contains any elements of an array
-   */
+       * Test that the list passed as the second argument contains
+       * all elements of a column or expression.
+       *
+       * ## Throws
+       *
+       * The argument passed in the second array can't be empty:
+       * if an empty is provided, this method will throw.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select posts where its tags contain "Typescript", "ORM" or both,
+       * // but filtering posts that have additional tags.
+       * db.select().from(posts)
+       *   .where(arrayContained(posts.tags, ['Typescript', 'ORM']))
+       * ```
+       *
+       * @see arrayContains to find if a column or expression contains all elements of an array
+       * @see arrayOverlaps to find if a column or expression contains any elements of an array
+       */
   arrayContained?: TValue;
   /**
-   * Test that a column or expression contains any elements of
-   * the list passed as the second argument.
-   *
-   * ## Throws
-   *
-   * The argument passed in the second array can't be empty:
-   * if an empty is provided, this method will throw.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select posts where its tags contain "Typescript", "ORM" or both.
-   * db.select().from(posts)
-   *   .where(arrayOverlaps(posts.tags, ['Typescript', 'ORM']))
-   * ```
-   *
-   * @see arrayContains to find if a column or expression contains all elements of an array
-   * @see arrayContained to find if an array contains all elements of a column or expression
-   */
+       * Test that a column or expression contains any elements of
+       * the list passed as the second argument.
+       *
+       * ## Throws
+       *
+       * The argument passed in the second array can't be empty:
+       * if an empty is provided, this method will throw.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select posts where its tags contain "Typescript", "ORM" or both.
+       * db.select().from(posts)
+       *   .where(arrayOverlaps(posts.tags, ['Typescript', 'ORM']))
+       * ```
+       *
+       * @see arrayContains to find if a column or expression contains all elements of an array
+       * @see arrayContained to find if an array contains all elements of a column or expression
+       */
   arrayOverlaps?: TValue;
 }
 //#endregion
@@ -748,71 +746,71 @@ type PgQueryWhereOrSQL<T extends TObject, Relations extends PgRelationMap<TObjec
 type PgQueryWhereOperators<T extends TObject> = { [Key in keyof Static<T>]?: FilterOperators<Static<T>[Key]> | Static<T>[Key] };
 type PgQueryWhereConditions<T extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = {
   /**
-   * Combine a list of conditions with the `and` operator. Conditions
-   * that are equal `undefined` are automatically ignored.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * db.select().from(cars)
-   *   .where(
-   *     and(
-   *       eq(cars.make, 'Volvo'),
-   *       eq(cars.year, 1950),
-   *     )
-   *   )
-   * ```
-   */
+       * Combine a list of conditions with the `and` operator. Conditions
+       * that are equal `undefined` are automatically ignored.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * db.select().from(cars)
+       *   .where(
+       *     and(
+       *       eq(cars.make, 'Volvo'),
+       *       eq(cars.year, 1950),
+       *     )
+       *   )
+       * ```
+       */
   and?: Array<PgQueryWhereOrSQL<T, Relations>>;
   /**
-   * Combine a list of conditions with the `or` operator. Conditions
-   * that are equal `undefined` are automatically ignored.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * db.select().from(cars)
-   *   .where(
-   *     or(
-   *       eq(cars.make, 'GM'),
-   *       eq(cars.make, 'Ford'),
-   *     )
-   *   )
-   * ```
-   */
+       * Combine a list of conditions with the `or` operator. Conditions
+       * that are equal `undefined` are automatically ignored.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * db.select().from(cars)
+       *   .where(
+       *     or(
+       *       eq(cars.make, 'GM'),
+       *       eq(cars.make, 'Ford'),
+       *     )
+       *   )
+       * ```
+       */
   or?: Array<PgQueryWhereOrSQL<T, Relations>>;
   /**
-   * Negate the meaning of an expression using the `not` keyword.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Select cars _not_ made by GM or Ford.
-   * db.select().from(cars)
-   *   .where(not(inArray(cars.make, ['GM', 'Ford'])))
-   * ```
-   */
+       * Negate the meaning of an expression using the `not` keyword.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Select cars _not_ made by GM or Ford.
+       * db.select().from(cars)
+       *   .where(not(inArray(cars.make, ['GM', 'Ford'])))
+       * ```
+       */
   not?: PgQueryWhereOrSQL<T, Relations>;
   /**
-   * Test whether a subquery evaluates to have any rows.
-   *
-   * ## Examples
-   *
-   * ```ts
-   * // Users whose `homeCity` column has a match in a cities
-   * // table.
-   * db
-   *   .select()
-   *   .from(users)
-   *   .where(
-   *     exists(db.select()
-   *       .from(cities)
-   *       .where(eq(users.homeCity, cities.id))),
-   *   );
-   * ```
-   *
-   * @see notExists for the inverse of this test
-   */
+       * Test whether a subquery evaluates to have any rows.
+       *
+       * ## Examples
+       *
+       * ```ts
+       * // Users whose `homeCity` column has a match in a cities
+       * // table.
+       * db
+       *   .select()
+       *   .from(users)
+       *   .where(
+       *     exists(db.select()
+       *       .from(cities)
+       *       .where(eq(users.homeCity, cities.id))),
+       *   );
+       * ```
+       *
+       * @see notExists for the inverse of this test
+       */
   exists?: SQLWrapper;
 };
 type PgQueryWhereRelations<Relations extends PgRelationMap<TObject> | undefined = undefined> = Relations extends PgRelationMap<TObject> ? { [K in keyof Relations]?: PgQueryWhere<Relations[K]["join"]["schema"], Relations[K]["with"]> } : {};
@@ -833,8 +831,8 @@ interface PgAttrField {
 //#region ../../src/orm/primitives/$sequence.d.ts
 interface SequencePrimitiveOptions extends PgSequenceOptions {
   /**
-   * The name of the sequence. If not provided, the property key will be used.
-   */
+       * The name of the sequence. If not provided, the property key will be used.
+       */
   name?: string;
   provider?: DatabaseProvider;
 }
@@ -874,33 +872,33 @@ interface TableConfigBuilders<TConfig> {
  */
 declare abstract class ModelBuilder {
   /**
-   * Build a table from an entity primitive.
-   */
+       * Build a table from an entity primitive.
+       */
   abstract buildTable(entity: EntityPrimitive, options: {
     tables: Map<string, unknown>;
     enums: Map<string, unknown>;
     schema: string;
   }): void;
   /**
-   * Build a sequence from a sequence primitive.
-   */
+       * Build a sequence from a sequence primitive.
+       */
   abstract buildSequence(sequence: SequencePrimitive, options: {
     sequences: Map<string, unknown>;
     schema: string;
   }): void;
   /**
-   * Convert camelCase to snake_case for column names.
-   */
+       * Convert camelCase to snake_case for column names.
+       */
   protected toColumnName(str: string): string;
   /**
-   * Build the table configuration function for any database.
-   * This includes indexes, foreign keys, constraints, and custom config.
-   *
-   * @param entity - The entity primitive
-   * @param builders - Database-specific builder functions
-   * @param tableResolver - Function to resolve entity references to table columns
-   * @param customConfigHandler - Optional handler for custom config
-   */
+       * Build the table configuration function for any database.
+       * This includes indexes, foreign keys, constraints, and custom config.
+       *
+       * @param entity - The entity primitive
+       * @param builders - Database-specific builder functions
+       * @param tableResolver - Function to resolve entity references to table columns
+       * @param customConfigHandler - Optional handler for custom config
+       */
   protected buildTableConfig<TConfig, TSelf>(entity: EntityPrimitive, builders: TableConfigBuilders<TConfig>, tableResolver?: (entityName: string) => any, customConfigHandler?: (config: any, self: TSelf) => TConfig[]): ((self: TSelf) => TConfig[]) | undefined;
 }
 //#endregion
@@ -909,44 +907,44 @@ declare class DrizzleKitProvider {
   protected readonly log: alepha_logger5.Logger;
   protected readonly alepha: Alepha;
   /**
-   * Synchronize database with current schema definitions.
-   *
-   * In development mode, it will generate and execute migrations based on the current state.
-   * In testing mode, it will generate migrations from scratch without applying them.
-   *
-   * Does nothing in production mode, you must handle migrations manually.
-   */
+       * Synchronize database with current schema definitions.
+       *
+       * In development mode, it will generate and execute migrations based on the current state.
+       * In testing mode, it will generate migrations from scratch without applying them.
+       *
+       * Does nothing in production mode, you must handle migrations manually.
+       */
   synchronize(provider: DatabaseProvider): Promise<void>;
   /**
-   * Mostly used for testing purposes. You can generate SQL migration statements without executing them.
-   */
+       * Mostly used for testing purposes. You can generate SQL migration statements without executing them.
+       */
   generateMigration(provider: DatabaseProvider, prevSnapshot?: any): Promise<{
     statements: string[];
     models: Record<string, unknown>;
     snapshot?: any;
   }>;
   /**
-   * Load all tables, enums, sequences, etc. from the provider's repositories.
-   */
+       * Load all tables, enums, sequences, etc. from the provider's repositories.
+       */
   getModels(provider: DatabaseProvider): Record<string, unknown>;
   /**
-   * Load the migration snapshot from the database.
-   */
+       * Load the migration snapshot from the database.
+       */
   protected loadDevMigrations(provider: DatabaseProvider): Promise<DevMigrations | undefined>;
   protected saveDevMigrations(provider: DatabaseProvider, curr: Record<string, any>, devMigrations?: DevMigrations): Promise<void>;
   protected executeStatements(statements: string[], provider: DatabaseProvider, catchErrors?: boolean): Promise<void>;
   protected createSchemaIfNotExists(provider: DatabaseProvider, schemaName: string): Promise<void>;
   /**
-   * Try to load the official Drizzle Kit API.
-   * If not available, fallback to the local kit import.
-   */
+       * Try to load the official Drizzle Kit API.
+       * If not available, fallback to the local kit import.
+       */
   importDrizzleKit(): typeof DrizzleKit;
 }
-declare const devMigrationsSchema: alepha1.TObject<{
-  id: alepha1.TNumber;
-  name: alepha1.TString;
-  snapshot: alepha1.TString;
-  created_at: alepha1.TString;
+declare const devMigrationsSchema: alepha23.TObject<{
+  id: alepha23.TNumber;
+  name: alepha23.TString;
+  snapshot: alepha23.TString;
+  created_at: alepha23.TString;
 }>;
 type DevMigrations = Static<typeof devMigrationsSchema>;
 //#endregion
@@ -964,6 +962,7 @@ declare abstract class DatabaseProvider {
   readonly tables: Map<string, unknown>;
   readonly sequences: Map<string, unknown>;
   get name(): string;
+  get driver(): string;
   get schema(): string;
   table<T extends TObject>(entity: EntityPrimitive<T>): PgTableWithColumns<SchemaToTableConfig<T>>;
   registerEntity(entity: EntityPrimitive): void;
@@ -971,39 +970,39 @@ declare abstract class DatabaseProvider {
   abstract execute(statement: SQLLike): Promise<Record<string, unknown>[]>;
   run<T extends TObject>(statement: SQLLike, schema: T): Promise<Array<Static<T>>>;
   /**
-   * Get migrations folder path - can be overridden
-   */
+       * Get migrations folder path - can be overridden
+       */
   protected getMigrationsFolder(): string;
   /**
-   * Base migration orchestration - handles environment logic
-   */
+       * Base migration orchestration - handles environment logic
+       */
   migrate(): Promise<void>;
   /**
-   * Production: run migrations from folder
-   */
+       * Production: run migrations from folder
+       */
   protected runProductionMigration(migrationsFolder: string): Promise<void>;
   /**
-   * Test: always synchronize
-   */
+       * Test: always synchronize
+       */
   protected runTestMigration(): Promise<void>;
   /**
-   * Development: default to synchronize (can be overridden)
-   */
+       * Development: default to synchronize (can be overridden)
+       */
   protected runDevelopmentMigration(migrationsFolder: string): Promise<void>;
   /**
-   * Common synchronization with error handling
-   */
+       * Common synchronization with error handling
+       */
   protected synchronizeSchema(): Promise<void>;
   /**
-   * Provider-specific migration execution
-   * MUST be implemented by each provider
-   */
+       * Provider-specific migration execution
+       * MUST be implemented by each provider
+       */
   protected abstract executeMigrations(migrationsFolder: string): Promise<void>;
   /**
-   * For testing purposes, generate a unique schema name.
-   * The schema name will be generated based on the current date and time.
-   * It will be in the format of `test_YYYYMMDD_HHMMSS_randomSuffix`.
-   */
+       * For testing purposes, generate a unique schema name.
+       * The schema name will be generated based on the current date and time.
+       * It will be in the format of `test_YYYYMMDD_HHMMSS_randomSuffix`.
+       */
   protected generateTestSchemaName(): string;
 }
 //#endregion
@@ -1011,8 +1010,8 @@ declare abstract class DatabaseProvider {
 declare class QueryManager {
   protected readonly alepha: Alepha;
   /**
-   * Convert a query object to a SQL query.
-   */
+       * Convert a query object to a SQL query.
+       */
   toSQL(query: PgQueryWhereOrSQL<TObject>, options: {
     schema: TObject;
     col: (key: string) => PgColumn;
@@ -1020,22 +1019,22 @@ declare class QueryManager {
     dialect: "postgresql" | "sqlite";
   }): SQL | undefined;
   /**
-   * Check if an object has any filter operator properties.
-   */
+       * Check if an object has any filter operator properties.
+       */
   protected hasFilterOperatorProperties(obj: any): boolean;
   /**
-   * Map a filter operator to a SQL query.
-   */
+       * Map a filter operator to a SQL query.
+       */
   mapOperatorToSql(operator: FilterOperators<any> | any, column: PgColumn, columnSchema?: TObject, columnName?: string, dialect?: "postgresql" | "sqlite"): SQL | undefined;
   /**
-   * Parse pagination sort string to orderBy format.
-   * Format: "firstName,-lastName" -> [{ column: "firstName", direction: "asc" }, { column: "lastName", direction: "desc" }]
-   * - Columns separated by comma
-   * - Prefix with '-' for DESC direction
-   *
-   * @param sort Pagination sort string
-   * @returns OrderBy array or single object
-   */
+       * Parse pagination sort string to orderBy format.
+       * Format: "firstName,-lastName" -> [{ column: "firstName", direction: "asc" }, { column: "lastName", direction: "desc" }]
+       * - Columns separated by comma
+       * - Prefix with '-' for DESC direction
+       *
+       * @param sort Pagination sort string
+       * @returns OrderBy array or single object
+       */
   parsePaginationSort(sort: string): Array<{
     column: string;
     direction: "asc" | "desc";
@@ -1044,34 +1043,34 @@ declare class QueryManager {
     direction: "asc" | "desc";
   };
   /**
-   * Normalize orderBy parameter to array format.
-   * Supports 3 modes:
-   * 1. String: "name" -> [{ column: "name", direction: "asc" }]
-   * 2. Object: { column: "name", direction: "desc" } -> [{ column: "name", direction: "desc" }]
-   * 3. Array: [{ column: "name" }, { column: "age", direction: "desc" }] -> normalized array
-   *
-   * @param orderBy The orderBy parameter
-   * @returns Normalized array of order by clauses
-   */
+       * Normalize orderBy parameter to array format.
+       * Supports 3 modes:
+       * 1. String: "name" -> [{ column: "name", direction: "asc" }]
+       * 2. Object: { column: "name", direction: "desc" } -> [{ column: "name", direction: "desc" }]
+       * 3. Array: [{ column: "name" }, { column: "age", direction: "desc" }] -> normalized array
+       *
+       * @param orderBy The orderBy parameter
+       * @returns Normalized array of order by clauses
+       */
   normalizeOrderBy(orderBy: any): Array<{
     column: string;
     direction: "asc" | "desc";
   }>;
   /**
-   * Create a pagination object.
-   *
-   * @deprecated Use `createPagination` from alepha instead.
-   * This method now delegates to the framework-level helper.
-   *
-   * @param entities The entities to paginate.
-   * @param limit The limit of the pagination.
-   * @param offset The offset of the pagination.
-   * @param sort Optional sort metadata to include in response.
-   */
+       * Create a pagination object.
+       *
+       * @deprecated Use `createPagination` from alepha instead.
+       * This method now delegates to the framework-level helper.
+       *
+       * @param entities The entities to paginate.
+       * @param limit The limit of the pagination.
+       * @param offset The offset of the pagination.
+       * @param sort Optional sort metadata to include in response.
+       */
   createPagination<T>(entities: T[], limit?: number, offset?: number, sort?: Array<{
     column: string;
     direction: "asc" | "desc";
-  }>): alepha1.Page<T>;
+  }>): alepha23.Page<T>;
 }
 interface PgJoin {
   table: string;
@@ -1084,20 +1083,20 @@ interface PgJoin {
 //#region ../../src/orm/services/PgRelationManager.d.ts
 declare class PgRelationManager {
   /**
-   * Recursively build joins for the query builder based on the relations map
-   */
+       * Recursively build joins for the query builder based on the relations map
+       */
   buildJoins(provider: DatabaseProvider, builder: PgSelectBase<any, any, any>, joins: Array<PgJoin>, withRelations: PgRelationMap<TObject>, table: PgTableWithColumns<any>, parentKey?: string): void;
   /**
-   * Map a row with its joined relations based on the joins definition
-   */
+       * Map a row with its joined relations based on the joins definition
+       */
   mapRowWithJoins(record: Record<string, unknown>, row: Record<string, unknown>, schema: TObject, joins: PgJoin[], parentKey?: string): Record<string, unknown>;
   /**
-   * Check if all values in an object are null (indicates a left join with no match)
-   */
+       * Check if all values in an object are null (indicates a left join with no match)
+       */
   private isAllNull;
   /**
-   * Build a schema that includes all join properties recursively
-   */
+       * Build a schema that includes all join properties recursively
+       */
   buildSchemaWithJoins(baseSchema: TObject, joins: PgJoin[], parentPath?: string): TObject;
 }
 //#endregion
@@ -1105,216 +1104,217 @@ declare class PgRelationManager {
 declare abstract class Repository$1<T extends TObject> {
   readonly entity: EntityPrimitive<T>;
   readonly provider: DatabaseProvider;
+  protected readonly log: alepha_logger5.Logger;
   protected readonly relationManager: PgRelationManager;
   protected readonly queryManager: QueryManager;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly alepha: Alepha;
   constructor(entity: EntityPrimitive<T>, provider?: typeof DatabaseProvider);
   /**
-   * Represents the primary key of the table.
-   * - Key is the name of the primary key column.
-   * - Type is the type (TypeBox) of the primary key column.
-   *
-   * ID is mandatory. If the table does not have a primary key, it will throw an error.
-   */
+       * Represents the primary key of the table.
+       * - Key is the name of the primary key column.
+       * - Type is the type (TypeBox) of the primary key column.
+       *
+       * ID is mandatory. If the table does not have a primary key, it will throw an error.
+       */
   get id(): {
     type: TSchema;
     key: keyof T["properties"];
     col: PgColumn;
   };
   /**
-   * Get Drizzle table object.
-   */
+       * Get Drizzle table object.
+       */
   get table(): PgTableWithColumns<SchemaToTableConfig<T>>;
   /**
-   * Get SQL table name. (from Drizzle table object)
-   */
+       * Get SQL table name. (from Drizzle table object)
+       */
   get tableName(): string;
   /**
-   * Getter for the database connection from the database provider.
-   */
+       * Getter for the database connection from the database provider.
+       */
   protected get db(): PgDatabase<any>;
   /**
-   * Execute a SQL query.
-   *
-   * This method allows executing raw SQL queries against the database.
-   * This is by far the easiest way to run custom queries that are not covered by the repository's built-in methods!
-   *
-   * You must use the `sql` tagged template function from Drizzle ORM to create the query. https://orm.drizzle.team/docs/sql
-   *
-   * @example
-   * ```ts
-   * class App {
-   *   repository = $repository({ ... });
-   *   async getAdults() {
-   *     const users = repository.table; // Drizzle table object
-   *     await repository.query(sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
-   *     // or better
-   *     await repository.query((users) => sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
-   *   }
-   * }
-   * ```
-   */
+       * Execute a SQL query.
+       *
+       * This method allows executing raw SQL queries against the database.
+       * This is by far the easiest way to run custom queries that are not covered by the repository's built-in methods!
+       *
+       * You must use the `sql` tagged template function from Drizzle ORM to create the query. https://orm.drizzle.team/docs/sql
+       *
+       * @example
+       * ```ts
+       * class App {
+       *   repository = $repository({ ... });
+       *   async getAdults() {
+       *     const users = repository.table; // Drizzle table object
+       *     await repository.query(sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
+       *     // or better
+       *     await repository.query((users) => sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
+       *   }
+       * }
+       * ```
+       */
   query<R extends TObject = T>(query: SQLLike | ((table: PgTableWithColumns<SchemaToTableConfig<T>>, db: PgDatabase<any>) => SQLLike), schema?: R): Promise<Static<R>[]>;
   /**
-   * Map raw database fields to entity fields. (handles column name differences)
-   */
+       * Map raw database fields to entity fields. (handles column name differences)
+       */
   protected mapRawFieldsToEntity(row: Record<string, unknown>): any;
   /**
-   * Get a Drizzle column from the table by his name.
-   */
+       * Get a Drizzle column from the table by his name.
+       */
   protected col(name: keyof StaticEncode<T>): PgColumn;
   /**
-   * Run a transaction.
-   */
+       * Run a transaction.
+       */
   transaction<T>(transaction: (tx: PgTransaction<any, Record<string, any>, any>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
   /**
-   * Start a SELECT query on the table.
-   */
+       * Start a SELECT query on the table.
+       */
   protected rawSelect(opts?: StatementOptions): drizzle_orm_pg_core0.PgSelectBase<string, Record<string, PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
     [x: string]: unknown;
   }[], {
     [x: string]: PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>;
   }>;
   /**
-   * Start a SELECT DISTINCT query on the table.
-   */
+       * Start a SELECT DISTINCT query on the table.
+       */
   protected rawSelectDistinct(opts?: StatementOptions, columns?: (keyof Static<T>)[]): drizzle_orm_pg_core0.PgSelectBase<string, Record<string, any>, "partial", Record<string, "not-null">, false, never, {
     [x: string]: any;
   }[], {
     [x: string]: any;
   }>;
   /**
-   * Start an INSERT query on the table.
-   */
+       * Start an INSERT query on the table.
+       */
   protected rawInsert(opts?: StatementOptions): drizzle_orm_pg_core0.PgInsertBuilder<PgTableWithColumns<SchemaToTableConfig<T>>, any, false>;
   /**
-   * Start an UPDATE query on the table.
-   */
+       * Start an UPDATE query on the table.
+       */
   protected rawUpdate(opts?: StatementOptions): drizzle_orm_pg_core0.PgUpdateBuilder<PgTableWithColumns<SchemaToTableConfig<T>>, any>;
   /**
-   * Start a DELETE query on the table.
-   */
+       * Start a DELETE query on the table.
+       */
   protected rawDelete(opts?: StatementOptions): drizzle_orm_pg_core0.PgDeleteBase<PgTableWithColumns<SchemaToTableConfig<T>>, any, undefined, undefined, false, never>;
   /**
-   * Create a Drizzle `select` query based on a JSON query object.
-   *
-   * > This method is the base for `find`, `findOne`, `findById`, and `paginate`.
-   */
+       * Create a Drizzle `select` query based on a JSON query object.
+       *
+       * > This method is the base for `find`, `findOne`, `findById`, and `paginate`.
+       */
   findMany<R extends PgRelationMap<T>>(query?: PgQueryRelations<T, R>, opts?: StatementOptions): Promise<PgStatic<T, R>[]>;
   /**
-   * Find a single entity.
-   */
+       * Find a single entity.
+       */
   findOne<R extends PgRelationMap<T>>(query: Pick<PgQueryRelations<T, R>, "with" | "where">, opts?: StatementOptions): Promise<PgStatic<T, R>>;
   /**
-   * Find entities with pagination.
-   *
-   * It uses the same parameters as `find()`, but adds pagination metadata to the response.
-   *
-   * > Pagination CAN also do a count query to get the total number of elements.
-   */
+       * Find entities with pagination.
+       *
+       * It uses the same parameters as `find()`, but adds pagination metadata to the response.
+       *
+       * > Pagination CAN also do a count query to get the total number of elements.
+       */
   paginate<R extends PgRelationMap<T>>(pagination?: PageQuery, query?: PgQueryRelations<T, R>, opts?: StatementOptions & {
     count?: boolean;
   }): Promise<Page<PgStatic<T, R>>>;
   /**
-   * Find an entity by ID.
-   *
-   * This is a convenience method for `findOne` with a where clause on the primary key.
-   * If you need more complex queries, use `findOne` instead.
-   */
+       * Find an entity by ID.
+       *
+       * This is a convenience method for `findOne` with a where clause on the primary key.
+       * If you need more complex queries, use `findOne` instead.
+       */
   findById(id: string | number, opts?: StatementOptions): Promise<Static<T>>;
   /**
-   * Helper to create a type-safe query object.
-   */
+       * Helper to create a type-safe query object.
+       */
   createQuery(): PgQuery<T>;
   /**
-   * Helper to create a type-safe where clause.
-   */
+       * Helper to create a type-safe where clause.
+       */
   createQueryWhere(): PgQueryWhere<T>;
   /**
-   * Create an entity.
-   *
-   * @param data The entity to create.
-   * @param opts The options for creating the entity.
-   * @returns The ID of the created entity.
-   */
+       * Create an entity.
+       *
+       * @param data The entity to create.
+       * @param opts The options for creating the entity.
+       * @returns The ID of the created entity.
+       */
   create(data: Static<TObjectInsert<T>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
-   * Create many entities.
-   *
-   * Inserts are batched in chunks of 1000 to avoid hitting database limits.
-   *
-   * @param values The entities to create.
-   * @param opts The statement options.
-   * @returns The created entities.
-   */
+       * Create many entities.
+       *
+       * Inserts are batched in chunks of 1000 to avoid hitting database limits.
+       *
+       * @param values The entities to create.
+       * @param opts The statement options.
+       * @returns The created entities.
+       */
   createMany(values: Array<Static<TObjectInsert<T>>>, opts?: StatementOptions & {
     batchSize?: number;
   }): Promise<Static<T>[]>;
   /**
-   * Find an entity and update it.
-   */
+       * Find an entity and update it.
+       */
   updateOne(where: PgQueryWhereOrSQL<T>, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
-   * Save a given entity.
-   *
-   * @example
-   * ```ts
-   * const entity = await repository.findById(1);
-   * entity.name = "New Name"; // update a field
-   * delete entity.description; // delete a field
-   * await repository.save(entity);
-   * ```
-   *
-   * Difference with `updateById/updateOne`:
-   *
-   * - requires the entity to be fetched first (whole object is expected)
-   * - check pg.version() if present -> optimistic locking
-   * - validate entity against schema
-   * - undefined values will be set to null, not ignored!
-   *
-   * @see {@link DbVersionMismatchError}
-   */
+       * Save a given entity.
+       *
+       * @example
+       * ```ts
+       * const entity = await repository.findById(1);
+       * entity.name = "New Name"; // update a field
+       * delete entity.description; // delete a field
+       * await repository.save(entity);
+       * ```
+       *
+       * Difference with `updateById/updateOne`:
+       *
+       * - requires the entity to be fetched first (whole object is expected)
+       * - check pg.version() if present -> optimistic locking
+       * - validate entity against schema
+       * - undefined values will be set to null, not ignored!
+       *
+       * @see {@link DbVersionMismatchError}
+       */
   save(entity: Static<T>, opts?: StatementOptions): Promise<void>;
   /**
-   * Find an entity by ID and update it.
-   */
+       * Find an entity by ID and update it.
+       */
   updateById(id: string | number, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
-   * Find many entities and update all of them.
-   */
+       * Find many entities and update all of them.
+       */
   updateMany(where: PgQueryWhereOrSQL<T>, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
-   * Find many and delete all of them.
-   * @returns Array of deleted entity IDs
-   */
+       * Find many and delete all of them.
+       * @returns Array of deleted entity IDs
+       */
   deleteMany(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
-   * Delete all entities.
-   * @returns Array of deleted entity IDs
-   */
+       * Delete all entities.
+       * @returns Array of deleted entity IDs
+       */
   clear(opts?: StatementOptions): Promise<Array<number | string>>;
   /**
-   * Delete the given entity.
-   *
-   * You must fetch the entity first in order to delete it.
-   * @returns Array containing the deleted entity ID
-   */
+       * Delete the given entity.
+       *
+       * You must fetch the entity first in order to delete it.
+       * @returns Array containing the deleted entity ID
+       */
   destroy(entity: Static<T>, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
-   * Find an entity and delete it.
-   * @returns Array of deleted entity IDs (should contain at most one ID)
-   */
+       * Find an entity and delete it.
+       * @returns Array of deleted entity IDs (should contain at most one ID)
+       */
   deleteOne(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
-   * Find an entity by ID and delete it.
-   * @returns Array containing the deleted entity ID
-   * @throws DbEntityNotFoundError if the entity is not found
-   */
+       * Find an entity by ID and delete it.
+       * @returns Array containing the deleted entity ID
+       * @throws DbEntityNotFoundError if the entity is not found
+       */
   deleteById(id: string | number, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
-   * Count entities.
-   */
+       * Count entities.
+       */
   count(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<number>;
   protected conflictMessagePattern: string;
   protected handleError(error: unknown, message: string): DbError;
@@ -1323,31 +1323,31 @@ declare abstract class Repository$1<T extends TObject> {
   }): PgQueryWhereOrSQL<T>;
   protected deletedAt(): PgAttrField | undefined;
   /**
-   * Convert something to valid Pg Insert Value.
-   */
+       * Convert something to valid Pg Insert Value.
+       */
   protected cast(data: any, insert: boolean): PgInsertValue<PgTableWithColumns<SchemaToTableConfig<T>>>;
   /**
-   * Transform a row from the database into a clean entity.
-   */
+       * Transform a row from the database into a clean entity.
+       */
   protected clean<T extends TObject>(row: Record<string, unknown>, schema: T): Static<T>;
   /**
-   * Clean a row with joins recursively
-   */
+       * Clean a row with joins recursively
+       */
   protected cleanWithJoins<T extends TObject>(row: Record<string, unknown>, schema: T, joins: PgJoin[], parentPath?: string): Static<T>;
   /**
-   * Convert a where clause to SQL.
-   */
+       * Convert a where clause to SQL.
+       */
   protected toSQL(where: PgQueryWhereOrSQL<T>, joins?: PgJoin[]): SQL | undefined;
   /**
-   * Get the where clause for an ID.
-   *
-   * @param id The ID to get the where clause for.
-   * @returns The where clause for the ID.
-   */
+       * Get the where clause for an ID.
+       *
+       * @param id The ID to get the where clause for.
+       * @returns The where clause for the ID.
+       */
   protected getWhereId(id: string | number): PgQueryWhere<T>;
   /**
-   * Find a primary key in the schema.
-   */
+       * Find a primary key in the schema.
+       */
   protected getPrimaryKey(schema: TObject): {
     key: string;
     col: PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>;
@@ -1359,189 +1359,80 @@ declare abstract class Repository$1<T extends TObject> {
  */
 interface StatementOptions {
   /**
-   * Transaction to use.
-   */
+       * Transaction to use.
+       */
   tx?: PgTransaction<any, Record<string, any>>;
   /**
-   * Lock strength.
-   */
+       * Lock strength.
+       */
   for?: LockStrength | {
     config: LockConfig;
     strength: LockStrength;
   };
   /**
-   * If true, ignore soft delete.
-   */
+       * If true, ignore soft delete.
+       */
   force?: boolean;
   /**
-   * Force the current time.
-   */
+       * Force the current time.
+       */
   now?: DateTime | string;
 }
 //#endregion
-//#region ../../src/orm/providers/drivers/NodePostgresProvider.d.ts
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-}
-declare const envSchema: alepha1.TObject<{
-  /**
-   * Main configuration for database connection.
-   * Accept a string in the format of a Postgres connection URL.
-   * Example: postgres://user:password@localhost:5432/database
-   * or
-   * Example: postgres://user:password@localhost:5432/database?sslmode=require
-   */
-  DATABASE_URL: alepha1.TOptional<alepha1.TString>;
-  /**
-   * In addition to the DATABASE_URL, you can specify the postgres schema name.
-   *
-   * It will monkey patch drizzle tables.
-   */
-  POSTGRES_SCHEMA: alepha1.TOptional<alepha1.TString>;
-}>;
-//#endregion
-//#region ../../src/orm/providers/drivers/NodeSqliteProvider.d.ts
-/**
- * Configuration options for the Node.js SQLite database provider.
- */
-declare const nodeSqliteOptions: alepha1.Atom<alepha1.TObject<{
-  path: alepha1.TOptional<alepha1.TString>;
-}>, "alepha.postgres.node-sqlite.options">;
-type NodeSqliteProviderOptions = Static<typeof nodeSqliteOptions.schema>;
-declare module "alepha" {
-  interface State {
-    [nodeSqliteOptions.key]: NodeSqliteProviderOptions;
-  }
-}
-/**
- * Add a fake support for SQLite in Node.js based on Postgres interfaces.
- *
- * This is NOT a real SQLite provider, it's a workaround to use SQLite with Drizzle ORM.
- * This is NOT recommended for production use.
- */
-//#endregion
-//#region ../../src/orm/index.d.ts
-declare module "alepha" {
-  interface Hooks {
-    /**
-     * Fires before creating an entity in the repository.
-     */
-    "repository:create:before": {
-      tableName: string;
-      data: any;
-    };
-    /**
-     * Fires after creating an entity in the repository.
-     */
-    "repository:create:after": {
-      tableName: string;
-      data: any;
-      entity: any;
-    };
-    /**
-     * Fires before updating entities in the repository.
-     */
-    "repository:update:before": {
-      tableName: string;
-      where: any;
-      data: any;
-    };
-    /**
-     * Fires after updating entities in the repository.
-     */
-    "repository:update:after": {
-      tableName: string;
-      where: any;
-      data: any;
-      entities: any[];
-    };
-    /**
-     * Fires before deleting entities from the repository.
-     */
-    "repository:delete:before": {
-      tableName: string;
-      where: any;
-    };
-    /**
-     * Fires after deleting entities from the repository.
-     */
-    "repository:delete:after": {
-      tableName: string;
-      where: any;
-      ids: Array<string | number>;
-    };
-    /**
-     * Fires before reading entities from the repository.
-     */
-    "repository:read:before": {
-      tableName: string;
-      query: any;
-    };
-    /**
-     * Fires after reading entities from the repository.
-     */
-    "repository:read:after": {
-      tableName: string;
-      query: any;
-      entities: any[];
-    };
-  }
-}
-//#endregion
 //#region ../../src/api/users/entities/identities.d.ts
-declare const identities: alepha_orm0.EntityPrimitive<alepha1.TObject<{
-  id: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_PRIMARY_KEY>, typeof alepha_orm0.PG_DEFAULT>;
-  version: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TInteger, typeof alepha_orm0.PG_VERSION>, typeof alepha_orm0.PG_DEFAULT>;
-  createdAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_CREATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-  updatedAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_UPDATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-  userId: alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_REF>;
-  password: alepha1.TOptional<alepha1.TString>;
-  provider: alepha1.TString;
-  providerUserId: alepha1.TOptional<alepha1.TString>;
-  providerData: alepha1.TOptional<alepha1.TRecord<string, alepha1.TAny>>;
+declare const identities: alepha_orm24.EntityPrimitive<alepha23.TObject<{
+  id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+  version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+  createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+  updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+  userId: alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_REF>;
+  password: alepha23.TOptional<alepha23.TString>;
+  provider: alepha23.TString;
+  providerUserId: alepha23.TOptional<alepha23.TString>;
+  providerData: alepha23.TOptional<alepha23.TRecord<string, alepha23.TAny>>;
 }>>;
 type IdentityEntity = Static<typeof identities.schema>;
 //#endregion
 //#region ../../src/api/users/entities/sessions.d.ts
-declare const sessions: alepha_orm0.EntityPrimitive<alepha1.TObject<{
-  id: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_PRIMARY_KEY>, typeof alepha_orm0.PG_DEFAULT>;
-  version: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TInteger, typeof alepha_orm0.PG_VERSION>, typeof alepha_orm0.PG_DEFAULT>;
-  createdAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_CREATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-  updatedAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_UPDATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-  refreshToken: alepha1.TString;
-  userId: alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_REF>;
-  expiresAt: alepha1.TString;
-  ip: alepha1.TOptional<alepha1.TString>;
-  userAgent: alepha1.TOptional<alepha1.TObject<{
-    os: alepha1.TString;
-    browser: alepha1.TString;
-    device: alepha1.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
+declare const sessions: alepha_orm24.EntityPrimitive<alepha23.TObject<{
+  id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+  version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+  createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+  updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+  refreshToken: alepha23.TString;
+  userId: alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_REF>;
+  expiresAt: alepha23.TString;
+  ip: alepha23.TOptional<alepha23.TString>;
+  userAgent: alepha23.TOptional<alepha23.TObject<{
+    os: alepha23.TString;
+    browser: alepha23.TString;
+    device: alepha23.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
   }>>;
 }>>;
 type SessionEntity = Static<typeof sessions.schema>;
 //#endregion
 //#region ../../src/api/users/entities/users.d.ts
 declare const DEFAULT_USER_REALM_NAME = "default";
-declare const users: alepha_orm0.EntityPrimitive<alepha1.TObject<{
-  id: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_PRIMARY_KEY>, typeof alepha_orm0.PG_DEFAULT>;
-  version: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TInteger, typeof alepha_orm0.PG_VERSION>, typeof alepha_orm0.PG_DEFAULT>;
-  createdAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_CREATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-  updatedAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_UPDATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-  realm: alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_DEFAULT>;
-  username: alepha1.TOptional<alepha1.TString>;
-  email: alepha1.TOptional<alepha1.TString>;
-  phoneNumber: alepha1.TOptional<alepha1.TString>;
-  roles: alepha_orm0.PgAttr<alepha1.TArray<alepha1.TString>, typeof alepha_orm0.PG_DEFAULT>;
-  firstName: alepha1.TOptional<alepha1.TString>;
-  lastName: alepha1.TOptional<alepha1.TString>;
-  picture: alepha1.TOptional<alepha1.TString>;
-  enabled: alepha_orm0.PgAttr<alepha1.TBoolean, typeof alepha_orm0.PG_DEFAULT>;
-  emailVerified: alepha_orm0.PgAttr<alepha1.TBoolean, typeof alepha_orm0.PG_DEFAULT>;
+declare const users: alepha_orm24.EntityPrimitive<alepha23.TObject<{
+  id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+  version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+  createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+  updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+  realm: alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_DEFAULT>;
+  username: alepha23.TOptional<alepha23.TString>;
+  email: alepha23.TOptional<alepha23.TString>;
+  phoneNumber: alepha23.TOptional<alepha23.TString>;
+  roles: alepha_orm24.PgAttr<alepha23.TArray<alepha23.TString>, typeof alepha_orm24.PG_DEFAULT>;
+  firstName: alepha23.TOptional<alepha23.TString>;
+  lastName: alepha23.TOptional<alepha23.TString>;
+  picture: alepha23.TOptional<alepha23.TString>;
+  enabled: alepha_orm24.PgAttr<alepha23.TBoolean, typeof alepha_orm24.PG_DEFAULT>;
+  emailVerified: alepha_orm24.PgAttr<alepha23.TBoolean, typeof alepha_orm24.PG_DEFAULT>;
 }>>;
 type UserEntity = Static<typeof users.schema>;
 //#endregion
-//#region ../../src/api/users/primitives/$userRealm.d.ts
-type UserRealmPrimitive = RealmPrimitive & WithLinkFn & WithLoginFn;
+//#region ../../src/api/users/primitives/$realm.d.ts
+type RealmPrimitive = IssuerPrimitive & WithLinkFn & WithLoginFn;
 /**
  * Already configured realm for user management.
  *
@@ -1555,23 +1446,23 @@ type UserRealmPrimitive = RealmPrimitive & WithLinkFn & WithLoginFn;
  * Environment Variables:
  * - `APP_SECRET`: Secret key for signing tokens (if not provided in options).
  */
-declare const $userRealm: (options?: UserRealmOptions) => UserRealmPrimitive;
-interface UserRealmOptions {
+declare const $realm: (options?: RealmOptions) => RealmPrimitive;
+interface RealmOptions {
   /**
-   * Secret key for signing tokens.
-   *
-   * If not provided, the secret from the SecurityProvider will be used (usually from the APP_SECRET environment variable).
-   */
+       * Secret key for signing tokens.
+       *
+       * If not provided, the secret from the SecurityProvider will be used (usually from the APP_SECRET environment variable).
+       */
   secret?: string;
   /**
-   * Realm configuration options.
-   *
-   * It's already pre-configured for user management with admin and user roles.
-   */
-  realm?: Partial<RealmPrimitiveOptions>;
+       * Issuer configuration options.
+       *
+       * It's already pre-configured for user management with admin and user roles.
+       */
+  issuer?: Partial<IssuerPrimitiveOptions>;
   /**
-   * Override entities.
-   */
+       * Override entities.
+       */
   entities?: {
     users?: Repository<typeof users.schema>;
     identities?: Repository<typeof identities.schema>;
@@ -1590,111 +1481,111 @@ interface UserRealmOptions {
   };
 }
 //#endregion
-//#region ../../src/api/users/providers/UserRealmProvider.d.ts
-interface UserRealmRepositories {
+//#region ../../src/api/users/providers/RealmProvider.d.ts
+interface RealmRepositories {
   identities: Repository<typeof identities.schema>;
   sessions: Repository<typeof sessions.schema>;
   users: Repository<typeof users.schema>;
 }
-interface UserRealm {
+interface Realm {
   name: string;
-  repositories: UserRealmRepositories;
+  repositories: RealmRepositories;
   settings: RealmAuthSettings;
 }
-declare class UserRealmProvider {
+declare class RealmProvider {
   protected readonly alepha: Alepha;
-  protected readonly defaultIdentities: Repository<alepha1.TObject<{
-    id: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_PRIMARY_KEY>, typeof alepha_orm0.PG_DEFAULT>;
-    version: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TInteger, typeof alepha_orm0.PG_VERSION>, typeof alepha_orm0.PG_DEFAULT>;
-    createdAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_CREATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-    updatedAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_UPDATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-    userId: alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_REF>;
-    password: alepha1.TOptional<alepha1.TString>;
-    provider: alepha1.TString;
-    providerUserId: alepha1.TOptional<alepha1.TString>;
-    providerData: alepha1.TOptional<alepha1.TRecord<string, alepha1.TAny>>;
+  protected readonly defaultIdentities: Repository<alepha23.TObject<{
+    id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+    version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+    createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    userId: alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_REF>;
+    password: alepha23.TOptional<alepha23.TString>;
+    provider: alepha23.TString;
+    providerUserId: alepha23.TOptional<alepha23.TString>;
+    providerData: alepha23.TOptional<alepha23.TRecord<string, alepha23.TAny>>;
   }>>;
-  protected readonly defaultSessions: Repository<alepha1.TObject<{
-    id: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_PRIMARY_KEY>, typeof alepha_orm0.PG_DEFAULT>;
-    version: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TInteger, typeof alepha_orm0.PG_VERSION>, typeof alepha_orm0.PG_DEFAULT>;
-    createdAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_CREATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-    updatedAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_UPDATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-    refreshToken: alepha1.TString;
-    userId: alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_REF>;
-    expiresAt: alepha1.TString;
-    ip: alepha1.TOptional<alepha1.TString>;
-    userAgent: alepha1.TOptional<alepha1.TObject<{
-      os: alepha1.TString;
-      browser: alepha1.TString;
-      device: alepha1.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
+  protected readonly defaultSessions: Repository<alepha23.TObject<{
+    id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+    version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+    createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    refreshToken: alepha23.TString;
+    userId: alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_REF>;
+    expiresAt: alepha23.TString;
+    ip: alepha23.TOptional<alepha23.TString>;
+    userAgent: alepha23.TOptional<alepha23.TObject<{
+      os: alepha23.TString;
+      browser: alepha23.TString;
+      device: alepha23.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
     }>>;
   }>>;
-  protected readonly defaultUsers: Repository<alepha1.TObject<{
-    id: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_PRIMARY_KEY>, typeof alepha_orm0.PG_DEFAULT>;
-    version: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TInteger, typeof alepha_orm0.PG_VERSION>, typeof alepha_orm0.PG_DEFAULT>;
-    createdAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_CREATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-    updatedAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_UPDATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-    realm: alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_DEFAULT>;
-    username: alepha1.TOptional<alepha1.TString>;
-    email: alepha1.TOptional<alepha1.TString>;
-    phoneNumber: alepha1.TOptional<alepha1.TString>;
-    roles: alepha_orm0.PgAttr<alepha1.TArray<alepha1.TString>, typeof alepha_orm0.PG_DEFAULT>;
-    firstName: alepha1.TOptional<alepha1.TString>;
-    lastName: alepha1.TOptional<alepha1.TString>;
-    picture: alepha1.TOptional<alepha1.TString>;
-    enabled: alepha_orm0.PgAttr<alepha1.TBoolean, typeof alepha_orm0.PG_DEFAULT>;
-    emailVerified: alepha_orm0.PgAttr<alepha1.TBoolean, typeof alepha_orm0.PG_DEFAULT>;
+  protected readonly defaultUsers: Repository<alepha23.TObject<{
+    id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+    version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+    createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    realm: alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_DEFAULT>;
+    username: alepha23.TOptional<alepha23.TString>;
+    email: alepha23.TOptional<alepha23.TString>;
+    phoneNumber: alepha23.TOptional<alepha23.TString>;
+    roles: alepha_orm24.PgAttr<alepha23.TArray<alepha23.TString>, typeof alepha_orm24.PG_DEFAULT>;
+    firstName: alepha23.TOptional<alepha23.TString>;
+    lastName: alepha23.TOptional<alepha23.TString>;
+    picture: alepha23.TOptional<alepha23.TString>;
+    enabled: alepha_orm24.PgAttr<alepha23.TBoolean, typeof alepha_orm24.PG_DEFAULT>;
+    emailVerified: alepha_orm24.PgAttr<alepha23.TBoolean, typeof alepha_orm24.PG_DEFAULT>;
   }>>;
-  protected realms: Map<string, UserRealm>;
+  protected realms: Map<string, Realm>;
   avatars: alepha_bucket0.BucketPrimitive;
-  protected readonly onConfigure: alepha1.HookPrimitive<"configure">;
-  register(userRealmName: string, userRealmOptions?: UserRealmOptions): UserRealm;
-  /**
-   * Gets a registered realm by name, auto-creating default if needed.
-   */
-  getRealm(userRealmName?: string): UserRealm;
-  identityRepository(userRealmName?: string): Repository<typeof identities.schema>;
-  sessionRepository(userRealmName?: string): Repository<typeof sessions.schema>;
-  userRepository(userRealmName?: string): Repository<typeof users.schema>;
+  protected readonly onConfigure: alepha23.HookPrimitive<"configure">;
+  register(realmName: string, realmOptions?: RealmOptions): Realm;
+  /**
+       * Gets a registered realm by name, auto-creating default if needed.
+       */
+  getRealm(realmName?: string): Realm;
+  identityRepository(realmName?: string): Repository<typeof identities.schema>;
+  sessionRepository(realmName?: string): Repository<typeof sessions.schema>;
+  userRepository(realmName?: string): Repository<typeof users.schema>;
 }
 //#endregion
 //#region ../../src/api/users/schemas/identityQuerySchema.d.ts
-declare const identityQuerySchema: alepha1.TObject<{
-  page: alepha1.TOptional<alepha1.TInteger>;
-  size: alepha1.TOptional<alepha1.TInteger>;
-  sort: alepha1.TOptional<alepha1.TString>;
-  userId: alepha1.TOptional<alepha1.TString>;
-  provider: alepha1.TOptional<alepha1.TString>;
+declare const identityQuerySchema: alepha23.TObject<{
+  page: alepha23.TOptional<alepha23.TInteger>;
+  size: alepha23.TOptional<alepha23.TInteger>;
+  sort: alepha23.TOptional<alepha23.TString>;
+  userId: alepha23.TOptional<alepha23.TString>;
+  provider: alepha23.TOptional<alepha23.TString>;
 }>;
 type IdentityQuery = Static<typeof identityQuerySchema>;
 //#endregion
 //#region ../../src/api/users/services/IdentityService.d.ts
 declare class IdentityService {
   protected readonly log: alepha_logger5.Logger;
-  protected readonly userRealmProvider: UserRealmProvider;
+  protected readonly realmProvider: RealmProvider;
   protected readonly auditService: AuditService;
-  identities(userRealmName?: string): alepha_orm0.Repository<alepha1.TObject<{
-    id: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_PRIMARY_KEY>, typeof alepha_orm0.PG_DEFAULT>;
-    version: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TInteger, typeof alepha_orm0.PG_VERSION>, typeof alepha_orm0.PG_DEFAULT>;
-    createdAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_CREATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-    updatedAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_UPDATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-    userId: alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_REF>;
-    password: alepha1.TOptional<alepha1.TString>;
-    provider: alepha1.TString;
-    providerUserId: alepha1.TOptional<alepha1.TString>;
-    providerData: alepha1.TOptional<alepha1.TRecord<string, alepha1.TAny>>;
+  identities(userRealmName?: string): alepha_orm24.Repository<alepha23.TObject<{
+    id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+    version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+    createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    userId: alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_REF>;
+    password: alepha23.TOptional<alepha23.TString>;
+    provider: alepha23.TString;
+    providerUserId: alepha23.TOptional<alepha23.TString>;
+    providerData: alepha23.TOptional<alepha23.TRecord<string, alepha23.TAny>>;
   }>>;
   /**
-   * Find identities with pagination and filtering.
-   */
+       * Find identities with pagination and filtering.
+       */
   findIdentities(q?: IdentityQuery, userRealmName?: string): Promise<Page$1<IdentityEntity>>;
   /**
-   * Get an identity by ID.
-   */
+       * Get an identity by ID.
+       */
   getIdentityById(id: string, userRealmName?: string): Promise<IdentityEntity>;
   /**
-   * Delete an identity by ID.
-   */
+       * Delete an identity by ID.
+       */
   deleteIdentity(id: string, userRealmName?: string): Promise<void>;
 }
 //#endregion
@@ -1704,106 +1595,106 @@ declare class AdminIdentityController {
   protected readonly group = "admin:identities";
   protected readonly identityService: IdentityService;
   /**
-   * Find identities with pagination and filtering.
-   */
+       * Find identities with pagination and filtering.
+       */
   readonly findIdentities: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      page: alepha1.TOptional<alepha1.TInteger>;
-      size: alepha1.TOptional<alepha1.TInteger>;
-      sort: alepha1.TOptional<alepha1.TString>;
-      userId: alepha1.TOptional<alepha1.TString>;
-      provider: alepha1.TOptional<alepha1.TString>;
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      page: alepha23.TOptional<alepha23.TInteger>;
+      size: alepha23.TOptional<alepha23.TInteger>;
+      sort: alepha23.TOptional<alepha23.TString>;
+      userId: alepha23.TOptional<alepha23.TString>;
+      provider: alepha23.TOptional<alepha23.TString>;
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TPage<alepha1.TObject<{
-      userId: PgAttr<alepha1.TString, typeof PG_REF>;
-      provider: alepha1.TString;
-      id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-      version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-      createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-      updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-      providerUserId: alepha1.TOptional<alepha1.TString>;
-      providerData: alepha1.TOptional<alepha1.TRecord<string, alepha1.TAny>>;
+    response: alepha23.TPage<alepha23.TObject<{
+      id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+      version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+      createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+      updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+      userId: PgAttr<alepha23.TString, typeof PG_REF>;
+      provider: alepha23.TString;
+      providerUserId: alepha23.TOptional<alepha23.TString>;
+      providerData: alepha23.TOptional<alepha23.TRecord<string, alepha23.TAny>>;
     }>>;
   }>;
   /**
-   * Get an identity by ID.
-   */
+       * Get an identity by ID.
+       */
   readonly getIdentity: alepha_server0.ActionPrimitiveFn<{
-    params: alepha1.TObject<{
-      id: alepha1.TString;
+    params: alepha23.TObject<{
+      id: alepha23.TString;
     }>;
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TObject<{
-      userId: PgAttr<alepha1.TString, typeof PG_REF>;
-      provider: alepha1.TString;
-      id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-      version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-      createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-      updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-      providerUserId: alepha1.TOptional<alepha1.TString>;
-      providerData: alepha1.TOptional<alepha1.TRecord<string, alepha1.TAny>>;
+    response: alepha23.TObject<{
+      id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+      version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+      createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+      updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+      userId: PgAttr<alepha23.TString, typeof PG_REF>;
+      provider: alepha23.TString;
+      providerUserId: alepha23.TOptional<alepha23.TString>;
+      providerData: alepha23.TOptional<alepha23.TRecord<string, alepha23.TAny>>;
     }>;
   }>;
   /**
-   * Delete an identity.
-   */
+       * Delete an identity.
+       */
   readonly deleteIdentity: alepha_server0.ActionPrimitiveFn<{
-    params: alepha1.TObject<{
-      id: alepha1.TString;
+    params: alepha23.TObject<{
+      id: alepha23.TString;
     }>;
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TObject<{
-      ok: alepha1.TBoolean;
-      id: alepha1.TOptional<alepha1.TUnion<[alepha1.TString, alepha1.TInteger]>>;
-      count: alepha1.TOptional<alepha1.TNumber>;
+    response: alepha23.TObject<{
+      ok: alepha23.TBoolean;
+      id: alepha23.TOptional<alepha23.TUnion<[alepha23.TString, alepha23.TInteger]>>;
+      count: alepha23.TOptional<alepha23.TNumber>;
     }>;
   }>;
 }
 //#endregion
 //#region ../../src/api/users/schemas/sessionQuerySchema.d.ts
-declare const sessionQuerySchema: alepha1.TObject<{
-  page: alepha1.TOptional<alepha1.TInteger>;
-  size: alepha1.TOptional<alepha1.TInteger>;
-  sort: alepha1.TOptional<alepha1.TString>;
-  userId: alepha1.TOptional<alepha1.TString>;
+declare const sessionQuerySchema: alepha23.TObject<{
+  page: alepha23.TOptional<alepha23.TInteger>;
+  size: alepha23.TOptional<alepha23.TInteger>;
+  sort: alepha23.TOptional<alepha23.TString>;
+  userId: alepha23.TOptional<alepha23.TString>;
 }>;
 type SessionQuery = Static<typeof sessionQuerySchema>;
 //#endregion
 //#region ../../src/api/users/services/SessionCrudService.d.ts
 declare class SessionCrudService {
   protected readonly log: alepha_logger5.Logger;
-  protected readonly userRealmProvider: UserRealmProvider;
-  sessions(userRealmName?: string): alepha_orm0.Repository<alepha1.TObject<{
-    id: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_PRIMARY_KEY>, typeof alepha_orm0.PG_DEFAULT>;
-    version: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TInteger, typeof alepha_orm0.PG_VERSION>, typeof alepha_orm0.PG_DEFAULT>;
-    createdAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_CREATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-    updatedAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_UPDATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-    refreshToken: alepha1.TString;
-    userId: alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_REF>;
-    expiresAt: alepha1.TString;
-    ip: alepha1.TOptional<alepha1.TString>;
-    userAgent: alepha1.TOptional<alepha1.TObject<{
-      os: alepha1.TString;
-      browser: alepha1.TString;
-      device: alepha1.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
+  protected readonly realmProvider: RealmProvider;
+  sessions(userRealmName?: string): alepha_orm24.Repository<alepha23.TObject<{
+    id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+    version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+    createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    refreshToken: alepha23.TString;
+    userId: alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_REF>;
+    expiresAt: alepha23.TString;
+    ip: alepha23.TOptional<alepha23.TString>;
+    userAgent: alepha23.TOptional<alepha23.TObject<{
+      os: alepha23.TString;
+      browser: alepha23.TString;
+      device: alepha23.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
     }>>;
   }>>;
   /**
-   * Find sessions with pagination and filtering.
-   */
+       * Find sessions with pagination and filtering.
+       */
   findSessions(q?: SessionQuery, userRealmName?: string): Promise<Page$1<SessionEntity>>;
   /**
-   * Get a session by ID.
-   */
+       * Get a session by ID.
+       */
   getSessionById(id: string, userRealmName?: string): Promise<SessionEntity>;
   /**
-   * Delete a session by ID.
-   */
+       * Delete a session by ID.
+       */
   deleteSession(id: string, userRealmName?: string): Promise<void>;
 }
 //#endregion
@@ -1813,208 +1704,208 @@ declare class AdminSessionController {
   protected readonly group = "admin:sessions";
   protected readonly sessionService: SessionCrudService;
   /**
-   * Find sessions with pagination and filtering.
-   */
+       * Find sessions with pagination and filtering.
+       */
   readonly findSessions: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      page: alepha1.TOptional<alepha1.TInteger>;
-      size: alepha1.TOptional<alepha1.TInteger>;
-      sort: alepha1.TOptional<alepha1.TString>;
-      userId: alepha1.TOptional<alepha1.TString>;
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      page: alepha23.TOptional<alepha23.TInteger>;
+      size: alepha23.TOptional<alepha23.TInteger>;
+      sort: alepha23.TOptional<alepha23.TString>;
+      userId: alepha23.TOptional<alepha23.TString>;
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TPage<alepha1.TObject<{
-      id: alepha1.TString;
-      version: alepha1.TNumber;
-      createdAt: alepha1.TString;
-      updatedAt: alepha1.TString;
-      refreshToken: alepha1.TString;
-      userId: alepha1.TString;
-      expiresAt: alepha1.TString;
-      ip: alepha1.TOptional<alepha1.TString>;
-      userAgent: alepha1.TOptional<alepha1.TObject<{
-        os: alepha1.TString;
-        browser: alepha1.TString;
-        device: alepha1.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
+    response: alepha23.TPage<alepha23.TObject<{
+      id: alepha23.TString;
+      version: alepha23.TNumber;
+      createdAt: alepha23.TString;
+      updatedAt: alepha23.TString;
+      refreshToken: alepha23.TString;
+      userId: alepha23.TString;
+      expiresAt: alepha23.TString;
+      ip: alepha23.TOptional<alepha23.TString>;
+      userAgent: alepha23.TOptional<alepha23.TObject<{
+        os: alepha23.TString;
+        browser: alepha23.TString;
+        device: alepha23.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
       }>>;
     }>>;
   }>;
   /**
-   * Get a session by ID.
-   */
+       * Get a session by ID.
+       */
   readonly getSession: alepha_server0.ActionPrimitiveFn<{
-    params: alepha1.TObject<{
-      id: alepha1.TString;
+    params: alepha23.TObject<{
+      id: alepha23.TString;
     }>;
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TObject<{
-      id: alepha1.TString;
-      version: alepha1.TNumber;
-      createdAt: alepha1.TString;
-      updatedAt: alepha1.TString;
-      refreshToken: alepha1.TString;
-      userId: alepha1.TString;
-      expiresAt: alepha1.TString;
-      ip: alepha1.TOptional<alepha1.TString>;
-      userAgent: alepha1.TOptional<alepha1.TObject<{
-        os: alepha1.TString;
-        browser: alepha1.TString;
-        device: alepha1.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
+    response: alepha23.TObject<{
+      id: alepha23.TString;
+      version: alepha23.TNumber;
+      createdAt: alepha23.TString;
+      updatedAt: alepha23.TString;
+      refreshToken: alepha23.TString;
+      userId: alepha23.TString;
+      expiresAt: alepha23.TString;
+      ip: alepha23.TOptional<alepha23.TString>;
+      userAgent: alepha23.TOptional<alepha23.TObject<{
+        os: alepha23.TString;
+        browser: alepha23.TString;
+        device: alepha23.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
       }>>;
     }>;
   }>;
   /**
-   * Delete a session.
-   */
+       * Delete a session.
+       */
   readonly deleteSession: alepha_server0.ActionPrimitiveFn<{
-    params: alepha1.TObject<{
-      id: alepha1.TString;
+    params: alepha23.TObject<{
+      id: alepha23.TString;
     }>;
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TObject<{
-      ok: alepha1.TBoolean;
-      id: alepha1.TOptional<alepha1.TUnion<[alepha1.TString, alepha1.TInteger]>>;
-      count: alepha1.TOptional<alepha1.TNumber>;
+    response: alepha23.TObject<{
+      ok: alepha23.TBoolean;
+      id: alepha23.TOptional<alepha23.TUnion<[alepha23.TString, alepha23.TInteger]>>;
+      count: alepha23.TOptional<alepha23.TNumber>;
     }>;
   }>;
 }
 //#endregion
 //#region ../../src/api/users/notifications/UserNotifications.d.ts
 declare class UserNotifications {
-  readonly passwordReset: alepha_api_notifications0.NotificationPrimitive<alepha1.TObject<{
-    email: alepha1.TString;
-    code: alepha1.TString;
-    expiresInMinutes: alepha1.TNumber;
+  readonly passwordReset: alepha_api_notifications0.NotificationPrimitive<alepha23.TObject<{
+    email: alepha23.TString;
+    code: alepha23.TString;
+    expiresInMinutes: alepha23.TNumber;
   }>>;
-  readonly emailVerification: alepha_api_notifications0.NotificationPrimitive<alepha1.TObject<{
-    email: alepha1.TString;
-    code: alepha1.TString;
-    expiresInMinutes: alepha1.TNumber;
+  readonly emailVerification: alepha_api_notifications0.NotificationPrimitive<alepha23.TObject<{
+    email: alepha23.TString;
+    code: alepha23.TString;
+    expiresInMinutes: alepha23.TNumber;
   }>>;
-  readonly phoneVerification: alepha_api_notifications0.NotificationPrimitive<alepha1.TObject<{
-    phoneNumber: alepha1.TString;
-    code: alepha1.TString;
-    expiresInMinutes: alepha1.TNumber;
+  readonly phoneVerification: alepha_api_notifications0.NotificationPrimitive<alepha23.TObject<{
+    phoneNumber: alepha23.TString;
+    code: alepha23.TString;
+    expiresInMinutes: alepha23.TNumber;
   }>>;
-  readonly passwordResetLink: alepha_api_notifications0.NotificationPrimitive<alepha1.TObject<{
-    email: alepha1.TString;
-    resetUrl: alepha1.TString;
-    expiresInMinutes: alepha1.TNumber;
+  readonly passwordResetLink: alepha_api_notifications0.NotificationPrimitive<alepha23.TObject<{
+    email: alepha23.TString;
+    resetUrl: alepha23.TString;
+    expiresInMinutes: alepha23.TNumber;
   }>>;
-  readonly emailVerificationLink: alepha_api_notifications0.NotificationPrimitive<alepha1.TObject<{
-    email: alepha1.TString;
-    verifyUrl: alepha1.TString;
-    expiresInMinutes: alepha1.TNumber;
+  readonly emailVerificationLink: alepha_api_notifications0.NotificationPrimitive<alepha23.TObject<{
+    email: alepha23.TString;
+    verifyUrl: alepha23.TString;
+    expiresInMinutes: alepha23.TNumber;
   }>>;
 }
 //#endregion
 //#region ../../src/api/users/schemas/createUserSchema.d.ts
-declare const createUserSchema: alepha1.TObject<{
-  id: alepha1.TOptional<PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>>;
-  version: alepha1.TOptional<PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>>;
-  email: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-  createdAt: alepha1.TOptional<PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>>;
-  updatedAt: alepha1.TOptional<PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>>;
-  username: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-  phoneNumber: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-  roles: alepha1.TOptional<alepha1.TArray<alepha1.TString>>;
-  firstName: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-  lastName: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-  picture: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-  enabled: alepha1.TOptional<PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>>;
-  emailVerified: alepha1.TOptional<PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>>;
+declare const createUserSchema: alepha23.TObject<{
+  id: alepha23.TOptional<PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>>;
+  version: alepha23.TOptional<PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>>;
+  email: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+  createdAt: alepha23.TOptional<PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>>;
+  updatedAt: alepha23.TOptional<PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>>;
+  username: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+  phoneNumber: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+  roles: alepha23.TOptional<alepha23.TArray<alepha23.TString>>;
+  firstName: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+  lastName: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+  picture: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+  enabled: alepha23.TOptional<PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>>;
+  emailVerified: alepha23.TOptional<PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>>;
 }>;
 type CreateUser = Static<typeof createUserSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/updateUserSchema.d.ts
-declare const updateUserSchema: alepha1.TObject<{
-  email: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-  realm: alepha1.TOptional<PgAttr<alepha1.TString, typeof PG_DEFAULT>>;
-  phoneNumber: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-  roles: alepha1.TOptional<alepha1.TArray<alepha1.TString>>;
-  firstName: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-  lastName: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-  picture: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-  enabled: alepha1.TOptional<PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>>;
+declare const updateUserSchema: alepha23.TObject<{
+  email: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+  realm: alepha23.TOptional<PgAttr<alepha23.TString, typeof PG_DEFAULT>>;
+  phoneNumber: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+  roles: alepha23.TOptional<alepha23.TArray<alepha23.TString>>;
+  firstName: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+  lastName: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+  picture: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+  enabled: alepha23.TOptional<PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>>;
 }>;
 type UpdateUser = Static<typeof updateUserSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/userQuerySchema.d.ts
-declare const userQuerySchema: alepha1.TObject<{
-  page: alepha1.TOptional<alepha1.TInteger>;
-  size: alepha1.TOptional<alepha1.TInteger>;
-  sort: alepha1.TOptional<alepha1.TString>;
-  email: alepha1.TOptional<alepha1.TString>;
-  enabled: alepha1.TOptional<alepha1.TBoolean>;
-  emailVerified: alepha1.TOptional<alepha1.TBoolean>;
-  roles: alepha1.TOptional<alepha1.TArray<alepha1.TString>>;
-  query: alepha1.TOptional<alepha1.TString>;
+declare const userQuerySchema: alepha23.TObject<{
+  page: alepha23.TOptional<alepha23.TInteger>;
+  size: alepha23.TOptional<alepha23.TInteger>;
+  sort: alepha23.TOptional<alepha23.TString>;
+  email: alepha23.TOptional<alepha23.TString>;
+  enabled: alepha23.TOptional<alepha23.TBoolean>;
+  emailVerified: alepha23.TOptional<alepha23.TBoolean>;
+  roles: alepha23.TOptional<alepha23.TArray<alepha23.TString>>;
+  query: alepha23.TOptional<alepha23.TString>;
 }>;
 type UserQuery = Static<typeof userQuerySchema>;
 //#endregion
 //#region ../../src/api/users/services/UserService.d.ts
 declare class UserService {
   protected readonly log: alepha_logger5.Logger;
-  protected readonly verificationController: alepha_server_links2.HttpVirtualClient<VerificationController>;
+  protected readonly verificationController: alepha_server_links0.HttpVirtualClient<VerificationController>;
   protected readonly userNotifications: UserNotifications;
-  protected readonly userRealmProvider: UserRealmProvider;
+  protected readonly realmProvider: RealmProvider;
   protected readonly auditService: AuditService;
-  users(userRealmName?: string): alepha_orm0.Repository<alepha1.TObject<{
-    id: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_PRIMARY_KEY>, typeof alepha_orm0.PG_DEFAULT>;
-    version: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TInteger, typeof alepha_orm0.PG_VERSION>, typeof alepha_orm0.PG_DEFAULT>;
-    createdAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_CREATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-    updatedAt: alepha_orm0.PgAttr<alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_UPDATED_AT>, typeof alepha_orm0.PG_DEFAULT>;
-    realm: alepha_orm0.PgAttr<alepha1.TString, typeof alepha_orm0.PG_DEFAULT>;
-    username: alepha1.TOptional<alepha1.TString>;
-    email: alepha1.TOptional<alepha1.TString>;
-    phoneNumber: alepha1.TOptional<alepha1.TString>;
-    roles: alepha_orm0.PgAttr<alepha1.TArray<alepha1.TString>, typeof alepha_orm0.PG_DEFAULT>;
-    firstName: alepha1.TOptional<alepha1.TString>;
-    lastName: alepha1.TOptional<alepha1.TString>;
-    picture: alepha1.TOptional<alepha1.TString>;
-    enabled: alepha_orm0.PgAttr<alepha1.TBoolean, typeof alepha_orm0.PG_DEFAULT>;
-    emailVerified: alepha_orm0.PgAttr<alepha1.TBoolean, typeof alepha_orm0.PG_DEFAULT>;
+  users(userRealmName?: string): alepha_orm24.Repository<alepha23.TObject<{
+    id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+    version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+    createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    realm: alepha_orm24.PgAttr<alepha23.TString, typeof alepha_orm24.PG_DEFAULT>;
+    username: alepha23.TOptional<alepha23.TString>;
+    email: alepha23.TOptional<alepha23.TString>;
+    phoneNumber: alepha23.TOptional<alepha23.TString>;
+    roles: alepha_orm24.PgAttr<alepha23.TArray<alepha23.TString>, typeof alepha_orm24.PG_DEFAULT>;
+    firstName: alepha23.TOptional<alepha23.TString>;
+    lastName: alepha23.TOptional<alepha23.TString>;
+    picture: alepha23.TOptional<alepha23.TString>;
+    enabled: alepha_orm24.PgAttr<alepha23.TBoolean, typeof alepha_orm24.PG_DEFAULT>;
+    emailVerified: alepha_orm24.PgAttr<alepha23.TBoolean, typeof alepha_orm24.PG_DEFAULT>;
   }>>;
   /**
-   * Request email verification for a user.
-   * @param email - The email address to verify.
-   * @param userRealmName - Optional realm name.
-   * @param method - The verification method: "code" (default) or "link".
-   * @param verifyUrl - Base URL for verification link (required when method is "link").
-   */
+       * Request email verification for a user.
+       * @param email - The email address to verify.
+       * @param userRealmName - Optional realm name.
+       * @param method - The verification method: "code" (default) or "link".
+       * @param verifyUrl - Base URL for verification link (required when method is "link").
+       */
   requestEmailVerification(email: string, userRealmName?: string, method?: "code" | "link", verifyUrl?: string): Promise<boolean>;
   /**
-   * Verify a user's email using a valid verification token.
-   * Supports both code (6-digit) and link (UUID) verification tokens.
-   */
+       * Verify a user's email using a valid verification token.
+       * Supports both code (6-digit) and link (UUID) verification tokens.
+       */
   verifyEmail(email: string, token: string, userRealmName?: string): Promise<void>;
   /**
-   * Check if an email is verified.
-   */
+       * Check if an email is verified.
+       */
   isEmailVerified(email: string, userRealmName?: string): Promise<boolean>;
   /**
-   * Find users with pagination and filtering.
-   */
+       * Find users with pagination and filtering.
+       */
   findUsers(q?: UserQuery, userRealmName?: string): Promise<Page$1<UserEntity>>;
   /**
-   * Get a user by ID.
-   */
+       * Get a user by ID.
+       */
   getUserById(id: string, userRealmName?: string): Promise<UserEntity>;
   /**
-   * Create a new user.
-   */
+       * Create a new user.
+       */
   createUser(data: CreateUser, userRealmName?: string): Promise<UserEntity>;
   /**
-   * Update an existing user.
-   */
+       * Update an existing user.
+       */
   updateUser(id: string, data: UpdateUser, userRealmName?: string): Promise<UserEntity>;
   /**
-   * Delete a user by ID.
-   */
+       * Delete a user by ID.
+       */
   deleteUser(id: string, userRealmName?: string): Promise<void>;
 }
 //#endregion
@@ -2024,154 +1915,218 @@ declare class AdminUserController {
   protected readonly group = "admin:users";
   protected readonly userService: UserService;
   /**
-   * Find users with pagination and filtering.
-   */
+       * Find users with pagination and filtering.
+       */
   readonly findUsers: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      page: alepha1.TOptional<alepha1.TInteger>;
-      size: alepha1.TOptional<alepha1.TInteger>;
-      sort: alepha1.TOptional<alepha1.TString>;
-      email: alepha1.TOptional<alepha1.TString>;
-      enabled: alepha1.TOptional<alepha1.TBoolean>;
-      emailVerified: alepha1.TOptional<alepha1.TBoolean>;
-      roles: alepha1.TOptional<alepha1.TArray<alepha1.TString>>;
-      query: alepha1.TOptional<alepha1.TString>;
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      page: alepha23.TOptional<alepha23.TInteger>;
+      size: alepha23.TOptional<alepha23.TInteger>;
+      sort: alepha23.TOptional<alepha23.TString>;
+      email: alepha23.TOptional<alepha23.TString>;
+      enabled: alepha23.TOptional<alepha23.TBoolean>;
+      emailVerified: alepha23.TOptional<alepha23.TBoolean>;
+      roles: alepha23.TOptional<alepha23.TArray<alepha23.TString>>;
+      query: alepha23.TOptional<alepha23.TString>;
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TPage<alepha1.TObject<{
-      id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-      version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-      createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-      updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-      realm: PgAttr<alepha1.TString, typeof PG_DEFAULT>;
-      username: alepha1.TOptional<alepha1.TString>;
-      email: alepha1.TOptional<alepha1.TString>;
-      phoneNumber: alepha1.TOptional<alepha1.TString>;
-      roles: PgAttr<alepha1.TArray<alepha1.TString>, typeof PG_DEFAULT>;
-      firstName: alepha1.TOptional<alepha1.TString>;
-      lastName: alepha1.TOptional<alepha1.TString>;
-      picture: alepha1.TOptional<alepha1.TString>;
-      enabled: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
-      emailVerified: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
+    response: alepha23.TPage<alepha23.TObject<{
+      id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+      version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+      createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+      updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+      realm: PgAttr<alepha23.TString, typeof PG_DEFAULT>;
+      username: alepha23.TOptional<alepha23.TString>;
+      email: alepha23.TOptional<alepha23.TString>;
+      phoneNumber: alepha23.TOptional<alepha23.TString>;
+      roles: PgAttr<alepha23.TArray<alepha23.TString>, typeof PG_DEFAULT>;
+      firstName: alepha23.TOptional<alepha23.TString>;
+      lastName: alepha23.TOptional<alepha23.TString>;
+      picture: alepha23.TOptional<alepha23.TString>;
+      enabled: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
+      emailVerified: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
     }>>;
   }>;
   /**
-   * Get a user by ID.
-   */
+       * Get a user by ID.
+       */
   readonly getUser: alepha_server0.ActionPrimitiveFn<{
-    params: alepha1.TObject<{
-      id: alepha1.TString;
+    params: alepha23.TObject<{
+      id: alepha23.TString;
     }>;
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TObject<{
-      id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-      version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-      createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-      updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-      realm: PgAttr<alepha1.TString, typeof PG_DEFAULT>;
-      username: alepha1.TOptional<alepha1.TString>;
-      email: alepha1.TOptional<alepha1.TString>;
-      phoneNumber: alepha1.TOptional<alepha1.TString>;
-      roles: PgAttr<alepha1.TArray<alepha1.TString>, typeof PG_DEFAULT>;
-      firstName: alepha1.TOptional<alepha1.TString>;
-      lastName: alepha1.TOptional<alepha1.TString>;
-      picture: alepha1.TOptional<alepha1.TString>;
-      enabled: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
-      emailVerified: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
+    response: alepha23.TObject<{
+      id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+      version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+      createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+      updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+      realm: PgAttr<alepha23.TString, typeof PG_DEFAULT>;
+      username: alepha23.TOptional<alepha23.TString>;
+      email: alepha23.TOptional<alepha23.TString>;
+      phoneNumber: alepha23.TOptional<alepha23.TString>;
+      roles: PgAttr<alepha23.TArray<alepha23.TString>, typeof PG_DEFAULT>;
+      firstName: alepha23.TOptional<alepha23.TString>;
+      lastName: alepha23.TOptional<alepha23.TString>;
+      picture: alepha23.TOptional<alepha23.TString>;
+      enabled: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
+      emailVerified: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
     }>;
   }>;
   /**
-   * Create a new user.
-   */
+       * Create a new user.
+       */
   readonly createUser: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    body: alepha1.TObject<{
-      id: alepha1.TOptional<PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>>;
-      version: alepha1.TOptional<PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>>;
-      email: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-      createdAt: alepha1.TOptional<PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>>;
-      updatedAt: alepha1.TOptional<PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>>;
-      username: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-      phoneNumber: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-      roles: alepha1.TOptional<alepha1.TArray<alepha1.TString>>;
-      firstName: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-      lastName: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-      picture: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-      enabled: alepha1.TOptional<PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>>;
-      emailVerified: alepha1.TOptional<PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>>;
+    body: alepha23.TObject<{
+      id: alepha23.TOptional<PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>>;
+      version: alepha23.TOptional<PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>>;
+      email: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+      createdAt: alepha23.TOptional<PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>>;
+      updatedAt: alepha23.TOptional<PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>>;
+      username: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+      phoneNumber: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+      roles: alepha23.TOptional<alepha23.TArray<alepha23.TString>>;
+      firstName: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+      lastName: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+      picture: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+      enabled: alepha23.TOptional<PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>>;
+      emailVerified: alepha23.TOptional<PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>>;
     }>;
-    response: alepha1.TObject<{
-      id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-      version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-      createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-      updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-      realm: PgAttr<alepha1.TString, typeof PG_DEFAULT>;
-      username: alepha1.TOptional<alepha1.TString>;
-      email: alepha1.TOptional<alepha1.TString>;
-      phoneNumber: alepha1.TOptional<alepha1.TString>;
-      roles: PgAttr<alepha1.TArray<alepha1.TString>, typeof PG_DEFAULT>;
-      firstName: alepha1.TOptional<alepha1.TString>;
-      lastName: alepha1.TOptional<alepha1.TString>;
-      picture: alepha1.TOptional<alepha1.TString>;
-      enabled: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
-      emailVerified: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
+    response: alepha23.TObject<{
+      id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+      version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+      createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+      updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+      realm: PgAttr<alepha23.TString, typeof PG_DEFAULT>;
+      username: alepha23.TOptional<alepha23.TString>;
+      email: alepha23.TOptional<alepha23.TString>;
+      phoneNumber: alepha23.TOptional<alepha23.TString>;
+      roles: PgAttr<alepha23.TArray<alepha23.TString>, typeof PG_DEFAULT>;
+      firstName: alepha23.TOptional<alepha23.TString>;
+      lastName: alepha23.TOptional<alepha23.TString>;
+      picture: alepha23.TOptional<alepha23.TString>;
+      enabled: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
+      emailVerified: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
     }>;
   }>;
   /**
-   * Update a user.
-   */
+       * Update a user.
+       */
   readonly updateUser: alepha_server0.ActionPrimitiveFn<{
-    params: alepha1.TObject<{
-      id: alepha1.TString;
+    params: alepha23.TObject<{
+      id: alepha23.TString;
     }>;
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    body: alepha1.TObject<{
-      email: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-      realm: alepha1.TOptional<PgAttr<alepha1.TString, typeof PG_DEFAULT>>;
-      phoneNumber: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-      roles: alepha1.TOptional<alepha1.TArray<alepha1.TString>>;
-      firstName: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-      lastName: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-      picture: alepha1.TOptional<alepha1.TOptional<alepha1.TString>>;
-      enabled: alepha1.TOptional<PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>>;
+    body: alepha23.TObject<{
+      email: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+      realm: alepha23.TOptional<PgAttr<alepha23.TString, typeof PG_DEFAULT>>;
+      phoneNumber: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+      roles: alepha23.TOptional<alepha23.TArray<alepha23.TString>>;
+      firstName: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+      lastName: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+      picture: alepha23.TOptional<alepha23.TOptional<alepha23.TString>>;
+      enabled: alepha23.TOptional<PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>>;
     }>;
-    response: alepha1.TObject<{
-      id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-      version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-      createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-      updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-      realm: PgAttr<alepha1.TString, typeof PG_DEFAULT>;
-      username: alepha1.TOptional<alepha1.TString>;
-      email: alepha1.TOptional<alepha1.TString>;
-      phoneNumber: alepha1.TOptional<alepha1.TString>;
-      roles: PgAttr<alepha1.TArray<alepha1.TString>, typeof PG_DEFAULT>;
-      firstName: alepha1.TOptional<alepha1.TString>;
-      lastName: alepha1.TOptional<alepha1.TString>;
-      picture: alepha1.TOptional<alepha1.TString>;
-      enabled: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
-      emailVerified: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
+    response: alepha23.TObject<{
+      id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+      version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+      createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+      updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+      realm: PgAttr<alepha23.TString, typeof PG_DEFAULT>;
+      username: alepha23.TOptional<alepha23.TString>;
+      email: alepha23.TOptional<alepha23.TString>;
+      phoneNumber: alepha23.TOptional<alepha23.TString>;
+      roles: PgAttr<alepha23.TArray<alepha23.TString>, typeof PG_DEFAULT>;
+      firstName: alepha23.TOptional<alepha23.TString>;
+      lastName: alepha23.TOptional<alepha23.TString>;
+      picture: alepha23.TOptional<alepha23.TString>;
+      enabled: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
+      emailVerified: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
     }>;
   }>;
   /**
-   * Delete a user.
-   */
+       * Delete a user.
+       */
   readonly deleteUser: alepha_server0.ActionPrimitiveFn<{
-    params: alepha1.TObject<{
-      id: alepha1.TString;
+    params: alepha23.TObject<{
+      id: alepha23.TString;
     }>;
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TObject<{
-      ok: alepha1.TBoolean;
-      id: alepha1.TOptional<alepha1.TUnion<[alepha1.TString, alepha1.TInteger]>>;
-      count: alepha1.TOptional<alepha1.TNumber>;
+    response: alepha23.TObject<{
+      ok: alepha23.TBoolean;
+      id: alepha23.TOptional<alepha23.TUnion<[alepha23.TString, alepha23.TInteger]>>;
+      count: alepha23.TOptional<alepha23.TNumber>;
+    }>;
+  }>;
+}
+//#endregion
+//#region ../../src/api/users/controllers/RealmController.d.ts
+/**
+ * Controller for exposing realm configuration.
+ * Uses $route instead of $action to keep endpoints hidden from API documentation.
+ */
+declare class RealmController {
+  protected readonly url = "/realms";
+  protected readonly group = "realms";
+  protected readonly realmProvider: RealmProvider;
+  protected readonly serverAuthProvider: ServerAuthProvider;
+  /**
+       * Get realm configuration settings.
+       * This endpoint is not exposed in the API documentation.
+       */
+  readonly getRealmConfig: alepha_server0.ActionPrimitiveFn<{
+    query: alepha23.TObject<{
+      realmName: alepha23.TOptional<alepha23.TString>;
+    }>;
+    response: alepha23.TObject<{
+      settings: alepha23.TObject<{
+        displayName: alepha23.TOptional<alepha23.TString>;
+        description: alepha23.TOptional<alepha23.TString>;
+        logoUrl: alepha23.TOptional<alepha23.TString>;
+        registrationAllowed: alepha23.TBoolean;
+        emailEnabled: alepha23.TBoolean;
+        emailRequired: alepha23.TBoolean;
+        usernameEnabled: alepha23.TBoolean;
+        usernameRequired: alepha23.TBoolean;
+        usernameRegExp: alepha23.TString;
+        phoneEnabled: alepha23.TBoolean;
+        phoneRequired: alepha23.TBoolean;
+        verifyEmailRequired: alepha23.TBoolean;
+        verifyPhoneRequired: alepha23.TBoolean;
+        firstNameLastNameEnabled: alepha23.TBoolean;
+        firstNameLastNameRequired: alepha23.TBoolean;
+        resetPasswordAllowed: alepha23.TBoolean;
+        passwordPolicy: alepha23.TObject<{
+          minLength: alepha23.TInteger;
+          requireUppercase: alepha23.TBoolean;
+          requireLowercase: alepha23.TBoolean;
+          requireNumbers: alepha23.TBoolean;
+          requireSpecialCharacters: alepha23.TBoolean;
+        }>;
+      }>;
+      realmName: alepha23.TString;
+      authenticationMethods: alepha23.TArray<alepha23.TObject<{
+        name: alepha23.TString;
+        type: alepha23.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
+      }>>;
+    }>;
+  }>;
+  readonly checkUsernameAvailability: alepha_server0.ActionPrimitiveFn<{
+    query: alepha23.TObject<{
+      realmName: alepha23.TOptional<alepha23.TString>;
+    }>;
+    body: alepha23.TObject<{
+      username: alepha23.TString;
+    }>;
+    response: alepha23.TObject<{
+      available: alepha23.TBoolean;
     }>;
   }>;
 }
@@ -2183,10 +2138,10 @@ declare class AdminUserController {
  * Requires the intent ID from Phase 1, the verification code,
  * and the new password.
  */
-declare const completePasswordResetRequestSchema: alepha1.TObject<{
-  intentId: alepha1.TString;
-  code: alepha1.TString;
-  newPassword: alepha1.TString;
+declare const completePasswordResetRequestSchema: alepha23.TObject<{
+  intentId: alepha23.TString;
+  code: alepha23.TString;
+  newPassword: alepha23.TString;
 }>;
 type CompletePasswordResetRequest = Static<typeof completePasswordResetRequestSchema>;
 //#endregion
@@ -2197,9 +2152,9 @@ type CompletePasswordResetRequest = Static<typeof completePasswordResetRequestSc
  * Contains the intent ID needed for Phase 2 completion,
  * along with expiration time.
  */
-declare const passwordResetIntentResponseSchema: alepha1.TObject<{
-  intentId: alepha1.TString;
-  expiresAt: alepha1.TString;
+declare const passwordResetIntentResponseSchema: alepha23.TObject<{
+  intentId: alepha23.TString;
+  expiresAt: alepha23.TString;
 }>;
 type PasswordResetIntentResponse = Static<typeof passwordResetIntentResponseSchema>;
 //#endregion
@@ -2218,93 +2173,93 @@ declare class CredentialService {
   protected readonly log: alepha_logger5.Logger;
   protected readonly cryptoProvider: CryptoProvider;
   protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly verificationController: alepha_server_links2.HttpVirtualClient<VerificationController>;
+  protected readonly verificationController: alepha_server_links0.HttpVirtualClient<VerificationController>;
   protected readonly userNotifications: UserNotifications;
-  protected readonly userRealmProvider: UserRealmProvider;
+  protected readonly realmProvider: RealmProvider;
   protected readonly auditService: AuditService;
   protected readonly intentCache: alepha_cache0.CachePrimitiveFn<PasswordResetIntent, any[]>;
-  users(userRealmName?: string): Repository$1<alepha1.TObject<{
-    id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-    version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-    createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-    updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-    realm: PgAttr<alepha1.TString, typeof PG_DEFAULT>;
-    username: alepha1.TOptional<alepha1.TString>;
-    email: alepha1.TOptional<alepha1.TString>;
-    phoneNumber: alepha1.TOptional<alepha1.TString>;
-    roles: PgAttr<alepha1.TArray<alepha1.TString>, typeof PG_DEFAULT>;
-    firstName: alepha1.TOptional<alepha1.TString>;
-    lastName: alepha1.TOptional<alepha1.TString>;
-    picture: alepha1.TOptional<alepha1.TString>;
-    enabled: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
-    emailVerified: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
+  users(userRealmName?: string): Repository$1<alepha23.TObject<{
+    id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+    version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+    createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+    updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+    realm: PgAttr<alepha23.TString, typeof PG_DEFAULT>;
+    username: alepha23.TOptional<alepha23.TString>;
+    email: alepha23.TOptional<alepha23.TString>;
+    phoneNumber: alepha23.TOptional<alepha23.TString>;
+    roles: PgAttr<alepha23.TArray<alepha23.TString>, typeof PG_DEFAULT>;
+    firstName: alepha23.TOptional<alepha23.TString>;
+    lastName: alepha23.TOptional<alepha23.TString>;
+    picture: alepha23.TOptional<alepha23.TString>;
+    enabled: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
+    emailVerified: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
   }>>;
-  sessions(userRealmName?: string): Repository$1<alepha1.TObject<{
-    id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-    version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-    createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-    updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-    refreshToken: alepha1.TString;
-    userId: PgAttr<alepha1.TString, typeof PG_REF>;
-    expiresAt: alepha1.TString;
-    ip: alepha1.TOptional<alepha1.TString>;
-    userAgent: alepha1.TOptional<alepha1.TObject<{
-      os: alepha1.TString;
-      browser: alepha1.TString;
-      device: alepha1.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
+  sessions(userRealmName?: string): Repository$1<alepha23.TObject<{
+    id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+    version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+    createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+    updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+    refreshToken: alepha23.TString;
+    userId: PgAttr<alepha23.TString, typeof PG_REF>;
+    expiresAt: alepha23.TString;
+    ip: alepha23.TOptional<alepha23.TString>;
+    userAgent: alepha23.TOptional<alepha23.TObject<{
+      os: alepha23.TString;
+      browser: alepha23.TString;
+      device: alepha23.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
     }>>;
   }>>;
-  identities(userRealmName?: string): Repository$1<alepha1.TObject<{
-    id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-    version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-    createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-    updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-    userId: PgAttr<alepha1.TString, typeof PG_REF>;
-    password: alepha1.TOptional<alepha1.TString>;
-    provider: alepha1.TString;
-    providerUserId: alepha1.TOptional<alepha1.TString>;
-    providerData: alepha1.TOptional<alepha1.TRecord<string, alepha1.TAny>>;
+  identities(userRealmName?: string): Repository$1<alepha23.TObject<{
+    id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+    version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+    createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+    updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+    userId: PgAttr<alepha23.TString, typeof PG_REF>;
+    password: alepha23.TOptional<alepha23.TString>;
+    provider: alepha23.TString;
+    providerUserId: alepha23.TOptional<alepha23.TString>;
+    providerData: alepha23.TOptional<alepha23.TRecord<string, alepha23.TAny>>;
   }>>;
   /**
-   * Phase 1: Create a password reset intent.
-   *
-   * Validates the email, checks for existing user with credentials,
-   * sends verification code, and stores the intent in cache.
-   *
-   * @param email - User's email address
-   * @param userRealmName - Optional realm name
-   * @returns Intent response with intentId and expiration (always returns for security)
-   */
+       * Phase 1: Create a password reset intent.
+       *
+       * Validates the email, checks for existing user with credentials,
+       * sends verification code, and stores the intent in cache.
+       *
+       * @param email - User's email address
+       * @param userRealmName - Optional realm name
+       * @returns Intent response with intentId and expiration (always returns for security)
+       */
   createPasswordResetIntent(email: string, userRealmName?: string): Promise<PasswordResetIntentResponse>;
   /**
-   * Phase 2: Complete password reset using an intent.
-   *
-   * Validates the verification code, updates the password,
-   * and invalidates all existing sessions.
-   *
-   * @param body - Request body with intentId, code, and newPassword
-   */
+       * Phase 2: Complete password reset using an intent.
+       *
+       * Validates the verification code, updates the password,
+       * and invalidates all existing sessions.
+       *
+       * @param body - Request body with intentId, code, and newPassword
+       */
   completePasswordReset(body: CompletePasswordResetRequest): Promise<void>;
   /**
-   * @deprecated Use createPasswordResetIntent instead
-   */
+       * @deprecated Use createPasswordResetIntent instead
+       */
   requestPasswordReset(email: string, userRealmName?: string): Promise<boolean>;
   /**
-   * @deprecated Use completePasswordReset instead
-   */
+       * @deprecated Use completePasswordReset instead
+       */
   validateResetToken(email: string, token: string, _userRealmName?: string): Promise<string>;
   /**
-   * @deprecated Use completePasswordReset instead
-   */
+       * @deprecated Use completePasswordReset instead
+       */
   resetPassword(email: string, token: string, newPassword: string, userRealmName?: string): Promise<void>;
 }
 //#endregion
 //#region ../../src/api/users/schemas/completeRegistrationRequestSchema.d.ts
-declare const completeRegistrationRequestSchema: alepha1.TObject<{
-  intentId: alepha1.TString;
-  emailCode: alepha1.TOptional<alepha1.TString>;
-  phoneCode: alepha1.TOptional<alepha1.TString>;
-  captchaToken: alepha1.TOptional<alepha1.TString>;
+declare const completeRegistrationRequestSchema: alepha23.TObject<{
+  intentId: alepha23.TString;
+  emailCode: alepha23.TOptional<alepha23.TString>;
+  phoneCode: alepha23.TOptional<alepha23.TString>;
+  captchaToken: alepha23.TOptional<alepha23.TString>;
 }>;
 type CompleteRegistrationRequest = Static<typeof completeRegistrationRequestSchema>;
 //#endregion
@@ -2313,24 +2268,24 @@ type CompleteRegistrationRequest = Static<typeof completeRegistrationRequestSche
  * Schema for user registration request body.
  * Password is always required, other fields depend on realm settings.
  */
-declare const registerRequestSchema: alepha1.TObject<{
-  password: alepha1.TString;
-  username: alepha1.TOptional<alepha1.TString>;
-  email: alepha1.TOptional<alepha1.TString>;
-  phoneNumber: alepha1.TOptional<alepha1.TString>;
-  firstName: alepha1.TOptional<alepha1.TString>;
-  lastName: alepha1.TOptional<alepha1.TString>;
-  picture: alepha1.TOptional<alepha1.TString>;
+declare const registerRequestSchema: alepha23.TObject<{
+  password: alepha23.TString;
+  username: alepha23.TOptional<alepha23.TString>;
+  email: alepha23.TOptional<alepha23.TString>;
+  phoneNumber: alepha23.TOptional<alepha23.TString>;
+  firstName: alepha23.TOptional<alepha23.TString>;
+  lastName: alepha23.TOptional<alepha23.TString>;
+  picture: alepha23.TOptional<alepha23.TString>;
 }>;
 type RegisterRequest = Static<typeof registerRequestSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/registrationIntentResponseSchema.d.ts
-declare const registrationIntentResponseSchema: alepha1.TObject<{
-  intentId: alepha1.TString;
-  expectCaptcha: alepha1.TBoolean;
-  expectEmailVerification: alepha1.TBoolean;
-  expectPhoneVerification: alepha1.TBoolean;
-  expiresAt: alepha1.TString;
+declare const registrationIntentResponseSchema: alepha23.TObject<{
+  intentId: alepha23.TString;
+  expectCaptcha: alepha23.TBoolean;
+  expectEmailVerification: alepha23.TBoolean;
+  expectPhoneVerification: alepha23.TBoolean;
+  expiresAt: alepha23.TString;
 }>;
 type RegistrationIntentResponse = Static<typeof registrationIntentResponseSchema>;
 //#endregion
@@ -2360,44 +2315,44 @@ declare class RegistrationService {
   protected readonly log: alepha_logger5.Logger;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly cryptoProvider: CryptoProvider;
-  protected readonly verificationController: alepha_server_links2.HttpVirtualClient<VerificationController>;
+  protected readonly verificationController: alepha_server_links0.HttpVirtualClient<VerificationController>;
   protected readonly userNotifications: UserNotifications;
-  protected readonly userRealmProvider: UserRealmProvider;
+  protected readonly realmProvider: RealmProvider;
   protected readonly auditService: AuditService;
   protected readonly intentCache: alepha_cache0.CachePrimitiveFn<RegistrationIntent, any[]>;
   /**
-   * Phase 1: Create a registration intent.
-   *
-   * Validates the registration data, checks for existing users,
-   * creates verification sessions, and stores the intent in cache.
-   */
+       * Phase 1: Create a registration intent.
+       *
+       * Validates the registration data, checks for existing users,
+       * creates verification sessions, and stores the intent in cache.
+       */
   createRegistrationIntent(body: RegisterRequest, userRealmName?: string): Promise<RegistrationIntentResponse>;
   /**
-   * Phase 2: Complete registration using an intent.
-   *
-   * Validates all requirements (verification codes, captcha),
-   * creates the user and credentials, and returns the user.
-   */
+       * Phase 2: Complete registration using an intent.
+       *
+       * Validates all requirements (verification codes, captcha),
+       * creates the user and credentials, and returns the user.
+       */
   completeRegistration(body: CompleteRegistrationRequest): Promise<UserEntity>;
   /**
-   * Check if username, email, and phone are available.
-   */
+       * Check if username, email, and phone are available.
+       */
   protected checkUserAvailability(body: Pick<RegisterRequest, "username" | "email" | "phoneNumber">, userRealmName?: string): Promise<void>;
   /**
-   * Send email verification code.
-   */
+       * Send email verification code.
+       */
   protected sendEmailVerification(email: string): Promise<void>;
   /**
-   * Send phone verification code.
-   */
+       * Send phone verification code.
+       */
   protected sendPhoneVerification(phoneNumber: string): Promise<void>;
   /**
-   * Verify email code using verification service.
-   */
+       * Verify email code using verification service.
+       */
   protected verifyEmailCode(email: string, code: string): Promise<void>;
   /**
-   * Verify phone code using verification service.
-   */
+       * Verify phone code using verification service.
+       */
   protected verifyPhoneCode(phoneNumber: string, code: string): Promise<void>;
 }
 //#endregion
@@ -2409,361 +2364,299 @@ declare class UserController {
   protected readonly userService: UserService;
   protected readonly registrationService: RegistrationService;
   /**
-   * Phase 1: Create a registration intent.
-   * Validates data, creates verification sessions, and stores intent in cache.
-   */
+       * Phase 1: Create a registration intent.
+       * Validates data, creates verification sessions, and stores intent in cache.
+       */
   readonly createRegistrationIntent: alepha_server0.ActionPrimitiveFn<{
-    body: alepha1.TObject<{
-      password: alepha1.TString;
-      username: alepha1.TOptional<alepha1.TString>;
-      email: alepha1.TOptional<alepha1.TString>;
-      phoneNumber: alepha1.TOptional<alepha1.TString>;
-      firstName: alepha1.TOptional<alepha1.TString>;
-      lastName: alepha1.TOptional<alepha1.TString>;
-      picture: alepha1.TOptional<alepha1.TString>;
+    body: alepha23.TObject<{
+      password: alepha23.TString;
+      username: alepha23.TOptional<alepha23.TString>;
+      email: alepha23.TOptional<alepha23.TString>;
+      phoneNumber: alepha23.TOptional<alepha23.TString>;
+      firstName: alepha23.TOptional<alepha23.TString>;
+      lastName: alepha23.TOptional<alepha23.TString>;
+      picture: alepha23.TOptional<alepha23.TString>;
     }>;
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TObject<{
-      intentId: alepha1.TString;
-      expectCaptcha: alepha1.TBoolean;
-      expectEmailVerification: alepha1.TBoolean;
-      expectPhoneVerification: alepha1.TBoolean;
-      expiresAt: alepha1.TString;
+    response: alepha23.TObject<{
+      intentId: alepha23.TString;
+      expectCaptcha: alepha23.TBoolean;
+      expectEmailVerification: alepha23.TBoolean;
+      expectPhoneVerification: alepha23.TBoolean;
+      expiresAt: alepha23.TString;
     }>;
   }>;
   /**
-   * Phase 2: Complete registration using an intent.
-   * Validates verification codes and creates the user.
-   */
+       * Phase 2: Complete registration using an intent.
+       * Validates verification codes and creates the user.
+       */
   readonly createUserFromIntent: alepha_server0.ActionPrimitiveFn<{
-    body: alepha1.TObject<{
-      intentId: alepha1.TString;
-      emailCode: alepha1.TOptional<alepha1.TString>;
-      phoneCode: alepha1.TOptional<alepha1.TString>;
-      captchaToken: alepha1.TOptional<alepha1.TString>;
+    body: alepha23.TObject<{
+      intentId: alepha23.TString;
+      emailCode: alepha23.TOptional<alepha23.TString>;
+      phoneCode: alepha23.TOptional<alepha23.TString>;
+      captchaToken: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TObject<{
-      id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-      version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-      createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-      updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-      realm: PgAttr<alepha1.TString, typeof PG_DEFAULT>;
-      username: alepha1.TOptional<alepha1.TString>;
-      email: alepha1.TOptional<alepha1.TString>;
-      phoneNumber: alepha1.TOptional<alepha1.TString>;
-      roles: PgAttr<alepha1.TArray<alepha1.TString>, typeof PG_DEFAULT>;
-      firstName: alepha1.TOptional<alepha1.TString>;
-      lastName: alepha1.TOptional<alepha1.TString>;
-      picture: alepha1.TOptional<alepha1.TString>;
-      enabled: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
-      emailVerified: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
+    response: alepha23.TObject<{
+      id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+      version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+      createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+      updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+      realm: PgAttr<alepha23.TString, typeof PG_DEFAULT>;
+      username: alepha23.TOptional<alepha23.TString>;
+      email: alepha23.TOptional<alepha23.TString>;
+      phoneNumber: alepha23.TOptional<alepha23.TString>;
+      roles: PgAttr<alepha23.TArray<alepha23.TString>, typeof PG_DEFAULT>;
+      firstName: alepha23.TOptional<alepha23.TString>;
+      lastName: alepha23.TOptional<alepha23.TString>;
+      picture: alepha23.TOptional<alepha23.TString>;
+      enabled: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
+      emailVerified: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
     }>;
   }>;
   /**
-   * Phase 1: Create a password reset intent.
-   * Validates email, sends verification code, and stores intent in cache.
-   */
+       * Phase 1: Create a password reset intent.
+       * Validates email, sends verification code, and stores intent in cache.
+       */
   readonly createPasswordResetIntent: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    body: alepha1.TObject<{
-      email: alepha1.TString;
+    body: alepha23.TObject<{
+      email: alepha23.TString;
     }>;
-    response: alepha1.TObject<{
-      intentId: alepha1.TString;
-      expiresAt: alepha1.TString;
+    response: alepha23.TObject<{
+      intentId: alepha23.TString;
+      expiresAt: alepha23.TString;
     }>;
   }>;
   /**
-   * Phase 2: Complete password reset using an intent.
-   * Validates verification code, updates password, and invalidates sessions.
-   */
+       * Phase 2: Complete password reset using an intent.
+       * Validates verification code, updates password, and invalidates sessions.
+       */
   readonly completePasswordReset: alepha_server0.ActionPrimitiveFn<{
-    body: alepha1.TObject<{
-      intentId: alepha1.TString;
-      code: alepha1.TString;
-      newPassword: alepha1.TString;
+    body: alepha23.TObject<{
+      intentId: alepha23.TString;
+      code: alepha23.TString;
+      newPassword: alepha23.TString;
     }>;
-    response: alepha1.TObject<{
-      ok: alepha1.TBoolean;
-      id: alepha1.TOptional<alepha1.TUnion<[alepha1.TString, alepha1.TInteger]>>;
-      count: alepha1.TOptional<alepha1.TNumber>;
+    response: alepha23.TObject<{
+      ok: alepha23.TBoolean;
+      id: alepha23.TOptional<alepha23.TUnion<[alepha23.TString, alepha23.TInteger]>>;
+      count: alepha23.TOptional<alepha23.TNumber>;
     }>;
   }>;
   /**
-   * @deprecated Use createPasswordResetIntent instead
-   */
+       * @deprecated Use createPasswordResetIntent instead
+       */
   requestPasswordReset: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    body: alepha1.TObject<{
-      email: alepha1.TString;
+    body: alepha23.TObject<{
+      email: alepha23.TString;
     }>;
-    response: alepha1.TObject<{
-      success: alepha1.TBoolean;
-      message: alepha1.TString;
+    response: alepha23.TObject<{
+      success: alepha23.TBoolean;
+      message: alepha23.TString;
     }>;
   }>;
   /**
-   * @deprecated Use completePasswordReset instead
-   */
+       * @deprecated Use completePasswordReset instead
+       */
   validateResetToken: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      email: alepha1.TString;
-      token: alepha1.TString;
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      email: alepha23.TString;
+      token: alepha23.TString;
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TObject<{
-      valid: alepha1.TBoolean;
-      email: alepha1.TOptional<alepha1.TString>;
+    response: alepha23.TObject<{
+      valid: alepha23.TBoolean;
+      email: alepha23.TOptional<alepha23.TString>;
     }>;
   }>;
   /**
-   * @deprecated Use completePasswordReset instead
-   */
+       * @deprecated Use completePasswordReset instead
+       */
   resetPassword: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    body: alepha1.TObject<{
-      email: alepha1.TString;
-      token: alepha1.TString;
-      newPassword: alepha1.TString;
+    body: alepha23.TObject<{
+      email: alepha23.TString;
+      token: alepha23.TString;
+      newPassword: alepha23.TString;
     }>;
-    response: alepha1.TObject<{
-      success: alepha1.TBoolean;
-      message: alepha1.TString;
+    response: alepha23.TObject<{
+      success: alepha23.TBoolean;
+      message: alepha23.TString;
     }>;
   }>;
   /**
-   * Request email verification.
-   * Generates a verification token using verification service and sends an email to the user.
-   * @param method - The verification method: "code" (default) sends a 6-digit code, "link" sends a clickable verification link.
-   * @param verifyUrl - Required when method is "link". The base URL for the verification link. Token and email will be appended as query params.
-   */
+       * Request email verification.
+       * Generates a verification token using verification service and sends an email to the user.
+       * @param method - The verification method: "code" (default) sends a 6-digit code, "link" sends a clickable verification link.
+       * @param verifyUrl - Required when method is "link". The base URL for the verification link. Token and email will be appended as query params.
+       */
   requestEmailVerification: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
-      method: alepha1.TOptional<alepha1.TUnsafe<"link" | "code">>;
-      verifyUrl: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
+      method: alepha23.TOptional<alepha23.TUnsafe<"link" | "code">>;
+      verifyUrl: alepha23.TOptional<alepha23.TString>;
     }>;
-    body: alepha1.TObject<{
-      email: alepha1.TString;
+    body: alepha23.TObject<{
+      email: alepha23.TString;
     }>;
-    response: alepha1.TObject<{
-      success: alepha1.TBoolean;
-      message: alepha1.TString;
+    response: alepha23.TObject<{
+      success: alepha23.TBoolean;
+      message: alepha23.TString;
     }>;
   }>;
   /**
-   * Verify email with a valid token.
-   * Updates the user's emailVerified status.
-   */
+       * Verify email with a valid token.
+       * Updates the user's emailVerified status.
+       */
   verifyEmail: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
+    query: alepha23.TObject<{
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    body: alepha1.TObject<{
-      email: alepha1.TString;
-      token: alepha1.TString;
+    body: alepha23.TObject<{
+      email: alepha23.TString;
+      token: alepha23.TString;
     }>;
-    response: alepha1.TObject<{
-      success: alepha1.TBoolean;
-      message: alepha1.TString;
+    response: alepha23.TObject<{
+      success: alepha23.TBoolean;
+      message: alepha23.TString;
     }>;
   }>;
   /**
-   * Check if an email is verified.
-   */
+       * Check if an email is verified.
+       */
   checkEmailVerification: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      email: alepha1.TString;
-      userRealmName: alepha1.TOptional<alepha1.TString>;
-    }>;
-    response: alepha1.TObject<{
-      verified: alepha1.TBoolean;
-    }>;
-  }>;
-}
-//#endregion
-//#region ../../src/api/users/controllers/UserRealmController.d.ts
-/**
- * Controller for exposing realm configuration.
- * Uses $route instead of $action to keep endpoints hidden from API documentation.
- */
-declare class UserRealmController {
-  protected readonly url = "/realms";
-  protected readonly group = "realms";
-  protected readonly userRealmProvider: UserRealmProvider;
-  protected readonly serverAuthProvider: ServerAuthProvider;
-  /**
-   * Get realm configuration settings.
-   * This endpoint is not exposed in the API documentation.
-   */
-  readonly getRealmConfig: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
-    }>;
-    response: alepha1.TObject<{
-      settings: alepha1.TObject<{
-        displayName: alepha1.TOptional<alepha1.TString>;
-        description: alepha1.TOptional<alepha1.TString>;
-        logoUrl: alepha1.TOptional<alepha1.TString>;
-        registrationAllowed: alepha1.TBoolean;
-        emailEnabled: alepha1.TBoolean;
-        emailRequired: alepha1.TBoolean;
-        usernameEnabled: alepha1.TBoolean;
-        usernameRequired: alepha1.TBoolean;
-        phoneEnabled: alepha1.TBoolean;
-        phoneRequired: alepha1.TBoolean;
-        verifyEmailRequired: alepha1.TBoolean;
-        verifyPhoneRequired: alepha1.TBoolean;
-        firstNameLastNameEnabled: alepha1.TBoolean;
-        firstNameLastNameRequired: alepha1.TBoolean;
-        resetPasswordAllowed: alepha1.TBoolean;
-        passwordPolicy: alepha1.TObject<{
-          minLength: alepha1.TInteger;
-          requireUppercase: alepha1.TBoolean;
-          requireLowercase: alepha1.TBoolean;
-          requireNumbers: alepha1.TBoolean;
-          requireSpecialCharacters: alepha1.TBoolean;
-        }>;
-      }>;
-      realmName: alepha1.TString;
-      authenticationMethods: alepha1.TArray<alepha1.TObject<{
-        name: alepha1.TString;
-        type: alepha1.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
-      }>>;
-    }>;
-  }>;
-  readonly checkUsernameAvailability: alepha_server0.ActionPrimitiveFn<{
-    query: alepha1.TObject<{
-      userRealmName: alepha1.TOptional<alepha1.TString>;
-    }>;
-    body: alepha1.TObject<{
-      username: alepha1.TString;
+    query: alepha23.TObject<{
+      email: alepha23.TString;
+      userRealmName: alepha23.TOptional<alepha23.TString>;
     }>;
-    response: alepha1.TObject<{
-      available: alepha1.TBoolean;
+    response: alepha23.TObject<{
+      verified: alepha23.TBoolean;
     }>;
   }>;
 }
 //#endregion
 //#region ../../src/api/users/schemas/identityResourceSchema.d.ts
-declare const identityResourceSchema: alepha1.TObject<{
-  userId: PgAttr<alepha1.TString, typeof PG_REF>;
-  provider: alepha1.TString;
-  id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-  version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-  createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-  updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-  providerUserId: alepha1.TOptional<alepha1.TString>;
-  providerData: alepha1.TOptional<alepha1.TRecord<string, alepha1.TAny>>;
+declare const identityResourceSchema: alepha23.TObject<{
+  id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+  version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+  createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+  updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+  userId: PgAttr<alepha23.TString, typeof PG_REF>;
+  provider: alepha23.TString;
+  providerUserId: alepha23.TOptional<alepha23.TString>;
+  providerData: alepha23.TOptional<alepha23.TRecord<string, alepha23.TAny>>;
 }>;
 type IdentityResource = Static<typeof identityResourceSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/loginSchema.d.ts
-declare const loginSchema: alepha1.TObject<{
-  username: alepha1.TString;
-  password: alepha1.TString;
+declare const loginSchema: alepha23.TObject<{
+  username: alepha23.TString;
+  password: alepha23.TString;
 }>;
 type LoginInput = Static<typeof loginSchema>;
 //#endregion
+//#region ../../src/api/users/schemas/realmConfigSchema.d.ts
+declare const realmConfigSchema: alepha23.TObject<{
+  settings: alepha23.TObject<{
+    displayName: alepha23.TOptional<alepha23.TString>;
+    description: alepha23.TOptional<alepha23.TString>;
+    logoUrl: alepha23.TOptional<alepha23.TString>;
+    registrationAllowed: alepha23.TBoolean;
+    emailEnabled: alepha23.TBoolean;
+    emailRequired: alepha23.TBoolean;
+    usernameEnabled: alepha23.TBoolean;
+    usernameRequired: alepha23.TBoolean;
+    usernameRegExp: alepha23.TString;
+    phoneEnabled: alepha23.TBoolean;
+    phoneRequired: alepha23.TBoolean;
+    verifyEmailRequired: alepha23.TBoolean;
+    verifyPhoneRequired: alepha23.TBoolean;
+    firstNameLastNameEnabled: alepha23.TBoolean;
+    firstNameLastNameRequired: alepha23.TBoolean;
+    resetPasswordAllowed: alepha23.TBoolean;
+    passwordPolicy: alepha23.TObject<{
+      minLength: alepha23.TInteger;
+      requireUppercase: alepha23.TBoolean;
+      requireLowercase: alepha23.TBoolean;
+      requireNumbers: alepha23.TBoolean;
+      requireSpecialCharacters: alepha23.TBoolean;
+    }>;
+  }>;
+  realmName: alepha23.TString;
+  authenticationMethods: alepha23.TArray<alepha23.TObject<{
+    name: alepha23.TString;
+    type: alepha23.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
+  }>>;
+}>;
+type RealmConfig = Static<typeof realmConfigSchema>;
+//#endregion
 //#region ../../src/api/users/schemas/registerSchema.d.ts
-declare const registerSchema: alepha1.TObject<{
-  username: alepha1.TString;
-  email: alepha1.TString;
-  password: alepha1.TString;
-  confirmPassword: alepha1.TString;
-  firstName: alepha1.TOptional<alepha1.TString>;
-  lastName: alepha1.TOptional<alepha1.TString>;
+declare const registerSchema: alepha23.TObject<{
+  username: alepha23.TString;
+  email: alepha23.TString;
+  password: alepha23.TString;
+  confirmPassword: alepha23.TString;
+  firstName: alepha23.TOptional<alepha23.TString>;
+  lastName: alepha23.TOptional<alepha23.TString>;
 }>;
 type RegisterInput = Static<typeof registerSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/resetPasswordSchema.d.ts
-declare const resetPasswordRequestSchema: alepha1.TObject<{
-  email: alepha1.TString;
+declare const resetPasswordRequestSchema: alepha23.TObject<{
+  email: alepha23.TString;
 }>;
-declare const resetPasswordSchema: alepha1.TObject<{
-  token: alepha1.TString;
-  password: alepha1.TString;
-  confirmPassword: alepha1.TString;
+declare const resetPasswordSchema: alepha23.TObject<{
+  token: alepha23.TString;
+  password: alepha23.TString;
+  confirmPassword: alepha23.TString;
 }>;
 type ResetPasswordRequest = Static<typeof resetPasswordRequestSchema>;
 type ResetPasswordInput = Static<typeof resetPasswordSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/sessionResourceSchema.d.ts
-declare const sessionResourceSchema: alepha1.TObject<{
-  id: alepha1.TString;
-  version: alepha1.TNumber;
-  createdAt: alepha1.TString;
-  updatedAt: alepha1.TString;
-  refreshToken: alepha1.TString;
-  userId: alepha1.TString;
-  expiresAt: alepha1.TString;
-  ip: alepha1.TOptional<alepha1.TString>;
-  userAgent: alepha1.TOptional<alepha1.TObject<{
-    os: alepha1.TString;
-    browser: alepha1.TString;
-    device: alepha1.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
+declare const sessionResourceSchema: alepha23.TObject<{
+  id: alepha23.TString;
+  version: alepha23.TNumber;
+  createdAt: alepha23.TString;
+  updatedAt: alepha23.TString;
+  refreshToken: alepha23.TString;
+  userId: alepha23.TString;
+  expiresAt: alepha23.TString;
+  ip: alepha23.TOptional<alepha23.TString>;
+  userAgent: alepha23.TOptional<alepha23.TObject<{
+    os: alepha23.TString;
+    browser: alepha23.TString;
+    device: alepha23.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
   }>>;
 }>;
 type SessionResource = Static<typeof sessionResourceSchema>;
 //#endregion
-//#region ../../src/api/users/schemas/userRealmConfigSchema.d.ts
-declare const userRealmConfigSchema: alepha1.TObject<{
-  settings: alepha1.TObject<{
-    displayName: alepha1.TOptional<alepha1.TString>;
-    description: alepha1.TOptional<alepha1.TString>;
-    logoUrl: alepha1.TOptional<alepha1.TString>;
-    registrationAllowed: alepha1.TBoolean;
-    emailEnabled: alepha1.TBoolean;
-    emailRequired: alepha1.TBoolean;
-    usernameEnabled: alepha1.TBoolean;
-    usernameRequired: alepha1.TBoolean;
-    phoneEnabled: alepha1.TBoolean;
-    phoneRequired: alepha1.TBoolean;
-    verifyEmailRequired: alepha1.TBoolean;
-    verifyPhoneRequired: alepha1.TBoolean;
-    firstNameLastNameEnabled: alepha1.TBoolean;
-    firstNameLastNameRequired: alepha1.TBoolean;
-    resetPasswordAllowed: alepha1.TBoolean;
-    passwordPolicy: alepha1.TObject<{
-      minLength: alepha1.TInteger;
-      requireUppercase: alepha1.TBoolean;
-      requireLowercase: alepha1.TBoolean;
-      requireNumbers: alepha1.TBoolean;
-      requireSpecialCharacters: alepha1.TBoolean;
-    }>;
-  }>;
-  realmName: alepha1.TString;
-  authenticationMethods: alepha1.TArray<alepha1.TObject<{
-    name: alepha1.TString;
-    type: alepha1.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
-  }>>;
-}>;
-type UserRealmConfig = Static<typeof userRealmConfigSchema>;
-//#endregion
 //#region ../../src/api/users/schemas/userResourceSchema.d.ts
-declare const userResourceSchema: alepha1.TObject<{
-  id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-  version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-  createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-  updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-  realm: PgAttr<alepha1.TString, typeof PG_DEFAULT>;
-  username: alepha1.TOptional<alepha1.TString>;
-  email: alepha1.TOptional<alepha1.TString>;
-  phoneNumber: alepha1.TOptional<alepha1.TString>;
-  roles: PgAttr<alepha1.TArray<alepha1.TString>, typeof PG_DEFAULT>;
-  firstName: alepha1.TOptional<alepha1.TString>;
-  lastName: alepha1.TOptional<alepha1.TString>;
-  picture: alepha1.TOptional<alepha1.TString>;
-  enabled: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
-  emailVerified: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
+declare const userResourceSchema: alepha23.TObject<{
+  id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+  version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+  createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+  updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+  realm: PgAttr<alepha23.TString, typeof PG_DEFAULT>;
+  username: alepha23.TOptional<alepha23.TString>;
+  email: alepha23.TOptional<alepha23.TString>;
+  phoneNumber: alepha23.TOptional<alepha23.TString>;
+  roles: PgAttr<alepha23.TArray<alepha23.TString>, typeof PG_DEFAULT>;
+  firstName: alepha23.TOptional<alepha23.TString>;
+  lastName: alepha23.TOptional<alepha23.TString>;
+  picture: alepha23.TOptional<alepha23.TString>;
+  enabled: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
+  emailVerified: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
 }>;
 type UserResource = Static<typeof userResourceSchema>;
 //#endregion
@@ -2774,95 +2667,95 @@ declare class SessionService {
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly cryptoProvider: CryptoProvider;
   protected readonly log: alepha_logger5.Logger;
-  protected readonly userRealmProvider: UserRealmProvider;
-  protected readonly fileController: alepha_server_links2.HttpVirtualClient<FileController>;
+  protected readonly realmProvider: RealmProvider;
+  protected readonly fileController: alepha_server_links0.HttpVirtualClient<FileController>;
   protected readonly auditService: AuditService;
-  users(userRealmName?: string): Repository$1<alepha1.TObject<{
-    id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-    version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-    createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-    updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-    realm: PgAttr<alepha1.TString, typeof PG_DEFAULT>;
-    username: alepha1.TOptional<alepha1.TString>;
-    email: alepha1.TOptional<alepha1.TString>;
-    phoneNumber: alepha1.TOptional<alepha1.TString>;
-    roles: PgAttr<alepha1.TArray<alepha1.TString>, typeof PG_DEFAULT>;
-    firstName: alepha1.TOptional<alepha1.TString>;
-    lastName: alepha1.TOptional<alepha1.TString>;
-    picture: alepha1.TOptional<alepha1.TString>;
-    enabled: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
-    emailVerified: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
+  users(userRealmName?: string): Repository$1<alepha23.TObject<{
+    id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+    version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+    createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+    updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+    realm: PgAttr<alepha23.TString, typeof PG_DEFAULT>;
+    username: alepha23.TOptional<alepha23.TString>;
+    email: alepha23.TOptional<alepha23.TString>;
+    phoneNumber: alepha23.TOptional<alepha23.TString>;
+    roles: PgAttr<alepha23.TArray<alepha23.TString>, typeof PG_DEFAULT>;
+    firstName: alepha23.TOptional<alepha23.TString>;
+    lastName: alepha23.TOptional<alepha23.TString>;
+    picture: alepha23.TOptional<alepha23.TString>;
+    enabled: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
+    emailVerified: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
   }>>;
-  sessions(userRealmName?: string): Repository$1<alepha1.TObject<{
-    id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-    version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-    createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-    updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-    refreshToken: alepha1.TString;
-    userId: PgAttr<alepha1.TString, typeof PG_REF>;
-    expiresAt: alepha1.TString;
-    ip: alepha1.TOptional<alepha1.TString>;
-    userAgent: alepha1.TOptional<alepha1.TObject<{
-      os: alepha1.TString;
-      browser: alepha1.TString;
-      device: alepha1.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
+  sessions(userRealmName?: string): Repository$1<alepha23.TObject<{
+    id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+    version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+    createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+    updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+    refreshToken: alepha23.TString;
+    userId: PgAttr<alepha23.TString, typeof PG_REF>;
+    expiresAt: alepha23.TString;
+    ip: alepha23.TOptional<alepha23.TString>;
+    userAgent: alepha23.TOptional<alepha23.TObject<{
+      os: alepha23.TString;
+      browser: alepha23.TString;
+      device: alepha23.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
     }>>;
   }>>;
-  identities(userRealmName?: string): Repository$1<alepha1.TObject<{
-    id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-    version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-    createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-    updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-    userId: PgAttr<alepha1.TString, typeof PG_REF>;
-    password: alepha1.TOptional<alepha1.TString>;
-    provider: alepha1.TString;
-    providerUserId: alepha1.TOptional<alepha1.TString>;
-    providerData: alepha1.TOptional<alepha1.TRecord<string, alepha1.TAny>>;
+  identities(userRealmName?: string): Repository$1<alepha23.TObject<{
+    id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+    version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+    createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+    updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+    userId: PgAttr<alepha23.TString, typeof PG_REF>;
+    password: alepha23.TOptional<alepha23.TString>;
+    provider: alepha23.TString;
+    providerUserId: alepha23.TOptional<alepha23.TString>;
+    providerData: alepha23.TOptional<alepha23.TRecord<string, alepha23.TAny>>;
   }>>;
   /**
-   * Random delay to prevent timing attacks (50-200ms)
-   * Uses cryptographically secure random number generation
-   */
+       * Random delay to prevent timing attacks (50-200ms)
+       * Uses cryptographically secure random number generation
+       */
   protected randomDelay(): Promise<void>;
   /**
-   * Validate user credentials and return the user if valid.
-   */
+       * Validate user credentials and return the user if valid.
+       */
   login(provider: string, username: string, password: string, userRealmName?: string): Promise<UserEntity>;
   createSession(user: UserAccount, expiresIn: number, userRealmName?: string): Promise<{
     refreshToken: string;
     sessionId: string;
   }>;
   refreshSession(refreshToken: string, userRealmName?: string): Promise<{
-    user: PgStatic<alepha1.TObject<{
-      id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-      version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-      createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-      updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-      realm: PgAttr<alepha1.TString, typeof PG_DEFAULT>;
-      username: alepha1.TOptional<alepha1.TString>;
-      email: alepha1.TOptional<alepha1.TString>;
-      phoneNumber: alepha1.TOptional<alepha1.TString>;
-      roles: PgAttr<alepha1.TArray<alepha1.TString>, typeof PG_DEFAULT>;
-      firstName: alepha1.TOptional<alepha1.TString>;
-      lastName: alepha1.TOptional<alepha1.TString>;
-      picture: alepha1.TOptional<alepha1.TString>;
-      enabled: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
-      emailVerified: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
-    }>, PgRelationMap<alepha1.TObject<{
-      id: PgAttr<PgAttr<alepha1.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-      version: PgAttr<PgAttr<alepha1.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-      createdAt: PgAttr<PgAttr<alepha1.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-      updatedAt: PgAttr<PgAttr<alepha1.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-      realm: PgAttr<alepha1.TString, typeof PG_DEFAULT>;
-      username: alepha1.TOptional<alepha1.TString>;
-      email: alepha1.TOptional<alepha1.TString>;
-      phoneNumber: alepha1.TOptional<alepha1.TString>;
-      roles: PgAttr<alepha1.TArray<alepha1.TString>, typeof PG_DEFAULT>;
-      firstName: alepha1.TOptional<alepha1.TString>;
-      lastName: alepha1.TOptional<alepha1.TString>;
-      picture: alepha1.TOptional<alepha1.TString>;
-      enabled: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
-      emailVerified: PgAttr<alepha1.TBoolean, typeof PG_DEFAULT>;
+    user: PgStatic<alepha23.TObject<{
+      id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+      version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+      createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+      updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+      realm: PgAttr<alepha23.TString, typeof PG_DEFAULT>;
+      username: alepha23.TOptional<alepha23.TString>;
+      email: alepha23.TOptional<alepha23.TString>;
+      phoneNumber: alepha23.TOptional<alepha23.TString>;
+      roles: PgAttr<alepha23.TArray<alepha23.TString>, typeof PG_DEFAULT>;
+      firstName: alepha23.TOptional<alepha23.TString>;
+      lastName: alepha23.TOptional<alepha23.TString>;
+      picture: alepha23.TOptional<alepha23.TString>;
+      enabled: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
+      emailVerified: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
+    }>, PgRelationMap<alepha23.TObject<{
+      id: PgAttr<PgAttr<alepha23.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+      version: PgAttr<PgAttr<alepha23.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+      createdAt: PgAttr<PgAttr<alepha23.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+      updatedAt: PgAttr<PgAttr<alepha23.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+      realm: PgAttr<alepha23.TString, typeof PG_DEFAULT>;
+      username: alepha23.TOptional<alepha23.TString>;
+      email: alepha23.TOptional<alepha23.TString>;
+      phoneNumber: alepha23.TOptional<alepha23.TString>;
+      roles: PgAttr<alepha23.TArray<alepha23.TString>, typeof PG_DEFAULT>;
+      firstName: alepha23.TOptional<alepha23.TString>;
+      lastName: alepha23.TOptional<alepha23.TString>;
+      picture: alepha23.TOptional<alepha23.TString>;
+      enabled: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
+      emailVerified: PgAttr<alepha23.TBoolean, typeof PG_DEFAULT>;
     }>>>;
     expiresIn: number;
     sessionId: string;
@@ -2924,7 +2817,7 @@ declare class SessionService {
  *
  * @module alepha.api.users
  */
-declare const AlephaApiUsers: alepha1.Service<alepha1.Module>;
+declare const AlephaApiUsers: alepha23.Service<alepha23.Module>;
 //#endregion
-export { $userRealm, AdminIdentityController, AdminSessionController, AdminUserController, AlephaApiUsers, CompletePasswordResetRequest, CompleteRegistrationRequest, CreateUser, CredentialService, DEFAULT_USER_REALM_NAME, IdentityEntity, IdentityQuery, IdentityResource, IdentityService, LoginInput, PasswordResetIntentResponse, RealmAuthSettings, RegisterInput, RegistrationIntentResponse, RegistrationService, ResetPasswordInput, ResetPasswordRequest, SessionCrudService, SessionEntity, SessionQuery, SessionResource, SessionService, UpdateUser, UserController, UserEntity, UserQuery, UserRealm, UserRealmConfig, UserRealmController, UserRealmOptions, UserRealmPrimitive, UserRealmProvider, UserRealmRepositories, UserResource, UserService, completePasswordResetRequestSchema, completeRegistrationRequestSchema, createUserSchema, identities, identityQuerySchema, identityResourceSchema, loginSchema, passwordResetIntentResponseSchema, realmAuthSettingsAtom, registerSchema, registrationIntentResponseSchema, resetPasswordRequestSchema, resetPasswordSchema, sessionQuerySchema, sessionResourceSchema, sessions, updateUserSchema, userQuerySchema, userRealmConfigSchema, userResourceSchema, users };
+export { $realm, AdminIdentityController, AdminSessionController, AdminUserController, AlephaApiUsers, CompletePasswordResetRequest, CompleteRegistrationRequest, CreateUser, CredentialService, DEFAULT_USER_REALM_NAME, IdentityEntity, IdentityQuery, IdentityResource, IdentityService, LoginInput, PasswordResetIntentResponse, Realm, RealmAuthSettings, RealmConfig, RealmController, RealmOptions, RealmPrimitive, RealmProvider, RealmRepositories, RegisterInput, RegistrationIntentResponse, RegistrationService, ResetPasswordInput, ResetPasswordRequest, SessionCrudService, SessionEntity, SessionQuery, SessionResource, SessionService, UpdateUser, UserController, UserEntity, UserQuery, UserResource, UserService, completePasswordResetRequestSchema, completeRegistrationRequestSchema, createUserSchema, identities, identityQuerySchema, identityResourceSchema, loginSchema, passwordResetIntentResponseSchema, realmAuthSettingsAtom, realmConfigSchema, registerSchema, registrationIntentResponseSchema, resetPasswordRequestSchema, resetPasswordSchema, sessionQuerySchema, sessionResourceSchema, sessions, updateUserSchema, userQuerySchema, userResourceSchema, users };
 //# sourceMappingURL=index.d.ts.map