alepha 0.15.0 → 0.15.1

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

@@ -1,4 +1,4 @@
-import * as alepha23 from "alepha";
+import * as alepha1 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";
@@ -26,29 +26,29 @@ import "alepha/retry";
 import "drizzle-orm/sqlite-core";
 
 //#region ../../src/api/users/atoms/realmAuthSettingsAtom.d.ts
-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;
+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;
+  usernameRegExp: alepha1.TString;
+  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;
   }>;
 }>, "alepha.api.users.realmAuthSettings">;
 type RealmAuthSettings = Static<typeof realmAuthSettingsAtom.schema>;
@@ -83,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> {
@@ -244,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;
@@ -278,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
@@ -746,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"]> } : {};
@@ -831,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;
 }
@@ -872,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
@@ -907,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: alepha23.TObject<{
-  id: alepha23.TNumber;
-  name: alepha23.TString;
-  snapshot: alepha23.TString;
-  created_at: alepha23.TString;
+declare const devMigrationsSchema: alepha1.TObject<{
+  id: alepha1.TNumber;
+  name: alepha1.TString;
+  snapshot: alepha1.TString;
+  created_at: alepha1.TString;
 }>;
 type DevMigrations = Static<typeof devMigrationsSchema>;
 //#endregion
@@ -970,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
@@ -1010,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;
@@ -1019,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";
@@ -1043,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";
-  }>): alepha23.Page<T>;
+  }>): alepha1.Page<T>;
 }
 interface PgJoin {
   table: string;
@@ -1083,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
@@ -1109,212 +1109,213 @@ declare abstract class Repository$1<T extends TObject> {
   protected readonly queryManager: QueryManager;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly alepha: Alepha;
+  static of<T extends TObject>(entity: EntityPrimitive<T>, provider?: typeof DatabaseProvider): new () => Repository$1<T>;
   constructor(entity: EntityPrimitive<T>, provider?: typeof DatabaseProvider);
   /**
-       * Represents the primary key of the table.
-       * - Key is the name of the primary key column.
-       * - Type is the type (TypeBox) of the primary key column.
-       *
-       * ID is mandatory. If the table does not have a primary key, it will throw an error.
-       */
+   * Represents the primary key of the table.
+   * - Key is the name of the primary key column.
+   * - Type is the type (TypeBox) of the primary key column.
+   *
+   * ID is mandatory. If the table does not have a primary key, it will throw an error.
+   */
   get id(): {
     type: TSchema;
     key: keyof T["properties"];
     col: PgColumn;
   };
   /**
-       * Get Drizzle table object.
-       */
+   * Get Drizzle table object.
+   */
   get table(): PgTableWithColumns<SchemaToTableConfig<T>>;
   /**
-       * Get SQL table name. (from Drizzle table object)
-       */
+   * Get SQL table name. (from Drizzle table object)
+   */
   get tableName(): string;
   /**
-       * Getter for the database connection from the database provider.
-       */
+   * Getter for the database connection from the database provider.
+   */
   protected get db(): PgDatabase<any>;
   /**
-       * Execute a SQL query.
-       *
-       * This method allows executing raw SQL queries against the database.
-       * This is by far the easiest way to run custom queries that are not covered by the repository's built-in methods!
-       *
-       * You must use the `sql` tagged template function from Drizzle ORM to create the query. https://orm.drizzle.team/docs/sql
-       *
-       * @example
-       * ```ts
-       * class App {
-       *   repository = $repository({ ... });
-       *   async getAdults() {
-       *     const users = repository.table; // Drizzle table object
-       *     await repository.query(sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
-       *     // or better
-       *     await repository.query((users) => sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
-       *   }
-       * }
-       * ```
-       */
+   * Execute a SQL query.
+   *
+   * This method allows executing raw SQL queries against the database.
+   * This is by far the easiest way to run custom queries that are not covered by the repository's built-in methods!
+   *
+   * You must use the `sql` tagged template function from Drizzle ORM to create the query. https://orm.drizzle.team/docs/sql
+   *
+   * @example
+   * ```ts
+   * class App {
+   *   repository = $repository({ ... });
+   *   async getAdults() {
+   *     const users = repository.table; // Drizzle table object
+   *     await repository.query(sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
+   *     // or better
+   *     await repository.query((users) => sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
+   *   }
+   * }
+   * ```
+   */
   query<R extends TObject = T>(query: SQLLike | ((table: PgTableWithColumns<SchemaToTableConfig<T>>, db: PgDatabase<any>) => SQLLike), schema?: R): Promise<Static<R>[]>;
   /**
-       * Map raw database fields to entity fields. (handles column name differences)
-       */
+   * Map raw database fields to entity fields. (handles column name differences)
+   */
   protected mapRawFieldsToEntity(row: Record<string, unknown>): any;
   /**
-       * Get a Drizzle column from the table by his name.
-       */
+   * Get a Drizzle column from the table by his name.
+   */
   protected col(name: keyof StaticEncode<T>): PgColumn;
   /**
-       * Run a transaction.
-       */
+   * Run a transaction.
+   */
   transaction<T>(transaction: (tx: PgTransaction<any, Record<string, any>, any>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
   /**
-       * Start a SELECT query on the table.
-       */
+   * Start a SELECT query on the table.
+   */
   protected rawSelect(opts?: StatementOptions): drizzle_orm_pg_core0.PgSelectBase<string, Record<string, PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
     [x: string]: unknown;
   }[], {
     [x: string]: PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>;
   }>;
   /**
-       * Start a SELECT DISTINCT query on the table.
-       */
+   * Start a SELECT DISTINCT query on the table.
+   */
   protected rawSelectDistinct(opts?: StatementOptions, columns?: (keyof Static<T>)[]): drizzle_orm_pg_core0.PgSelectBase<string, Record<string, any>, "partial", Record<string, "not-null">, false, never, {
     [x: string]: any;
   }[], {
     [x: string]: any;
   }>;
   /**
-       * Start an INSERT query on the table.
-       */
+   * Start an INSERT query on the table.
+   */
   protected rawInsert(opts?: StatementOptions): drizzle_orm_pg_core0.PgInsertBuilder<PgTableWithColumns<SchemaToTableConfig<T>>, any, false>;
   /**
-       * Start an UPDATE query on the table.
-       */
+   * Start an UPDATE query on the table.
+   */
   protected rawUpdate(opts?: StatementOptions): drizzle_orm_pg_core0.PgUpdateBuilder<PgTableWithColumns<SchemaToTableConfig<T>>, any>;
   /**
-       * Start a DELETE query on the table.
-       */
+   * Start a DELETE query on the table.
+   */
   protected rawDelete(opts?: StatementOptions): drizzle_orm_pg_core0.PgDeleteBase<PgTableWithColumns<SchemaToTableConfig<T>>, any, undefined, undefined, false, never>;
   /**
-       * Create a Drizzle `select` query based on a JSON query object.
-       *
-       * > This method is the base for `find`, `findOne`, `findById`, and `paginate`.
-       */
+   * Create a Drizzle `select` query based on a JSON query object.
+   *
+   * > This method is the base for `find`, `findOne`, `findById`, and `paginate`.
+   */
   findMany<R extends PgRelationMap<T>>(query?: PgQueryRelations<T, R>, opts?: StatementOptions): Promise<PgStatic<T, R>[]>;
   /**
-       * Find a single entity.
-       */
+   * Find a single entity.
+   */
   findOne<R extends PgRelationMap<T>>(query: Pick<PgQueryRelations<T, R>, "with" | "where">, opts?: StatementOptions): Promise<PgStatic<T, R>>;
   /**
-       * Find entities with pagination.
-       *
-       * It uses the same parameters as `find()`, but adds pagination metadata to the response.
-       *
-       * > Pagination CAN also do a count query to get the total number of elements.
-       */
+   * Find entities with pagination.
+   *
+   * It uses the same parameters as `find()`, but adds pagination metadata to the response.
+   *
+   * > Pagination CAN also do a count query to get the total number of elements.
+   */
   paginate<R extends PgRelationMap<T>>(pagination?: PageQuery, 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 +1324,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,75 +1360,75 @@ 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/api/users/entities/identities.d.ts
-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>>;
+declare const identities: alepha_orm24.EntityPrimitive<alepha1.TObject<{
+  id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+  version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+  createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+  updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+  userId: alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_REF>;
+  password: alepha1.TOptional<alepha1.TString>;
+  provider: alepha1.TString;
+  providerUserId: alepha1.TOptional<alepha1.TString>;
+  providerData: alepha1.TOptional<alepha1.TRecord<string, alepha1.TAny>>;
 }>>;
 type IdentityEntity = Static<typeof identities.schema>;
 //#endregion
 //#region ../../src/api/users/entities/sessions.d.ts
-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">;
+declare const sessions: alepha_orm24.EntityPrimitive<alepha1.TObject<{
+  id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+  version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+  createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+  updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+  refreshToken: alepha1.TString;
+  userId: alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.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">;
   }>>;
 }>>;
 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_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>;
+declare const users: alepha_orm24.EntityPrimitive<alepha1.TObject<{
+  id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+  version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+  createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+  updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+  realm: alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_DEFAULT>;
+  username: alepha1.TOptional<alepha1.TString>;
+  email: alepha1.TOptional<alepha1.TString>;
+  phoneNumber: alepha1.TOptional<alepha1.TString>;
+  roles: alepha_orm24.PgAttr<alepha1.TArray<alepha1.TString>, typeof alepha_orm24.PG_DEFAULT>;
+  firstName: alepha1.TOptional<alepha1.TString>;
+  lastName: alepha1.TOptional<alepha1.TString>;
+  picture: alepha1.TOptional<alepha1.TString>;
+  enabled: alepha_orm24.PgAttr<alepha1.TBoolean, typeof alepha_orm24.PG_DEFAULT>;
+  emailVerified: alepha_orm24.PgAttr<alepha1.TBoolean, typeof alepha_orm24.PG_DEFAULT>;
 }>>;
 type UserEntity = Static<typeof users.schema>;
 //#endregion
@@ -1449,20 +1450,20 @@ type RealmPrimitive = IssuerPrimitive & WithLinkFn & WithLoginFn;
 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;
   /**
-       * Issuer configuration options.
-       *
-       * It's already pre-configured for user management with admin and user roles.
-       */
+   * 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>;
@@ -1494,55 +1495,55 @@ interface Realm {
 }
 declare class RealmProvider {
   protected readonly alepha: Alepha;
-  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 defaultIdentities: Repository<alepha1.TObject<{
+    id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+    version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+    createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    userId: alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.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 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 defaultSessions: Repository<alepha1.TObject<{
+    id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+    version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+    createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    refreshToken: alepha1.TString;
+    userId: alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.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 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 readonly defaultUsers: Repository<alepha1.TObject<{
+    id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+    version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+    createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    realm: alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_DEFAULT>;
+    username: alepha1.TOptional<alepha1.TString>;
+    email: alepha1.TOptional<alepha1.TString>;
+    phoneNumber: alepha1.TOptional<alepha1.TString>;
+    roles: alepha_orm24.PgAttr<alepha1.TArray<alepha1.TString>, typeof alepha_orm24.PG_DEFAULT>;
+    firstName: alepha1.TOptional<alepha1.TString>;
+    lastName: alepha1.TOptional<alepha1.TString>;
+    picture: alepha1.TOptional<alepha1.TString>;
+    enabled: alepha_orm24.PgAttr<alepha1.TBoolean, typeof alepha_orm24.PG_DEFAULT>;
+    emailVerified: alepha_orm24.PgAttr<alepha1.TBoolean, typeof alepha_orm24.PG_DEFAULT>;
   }>>;
   protected realms: Map<string, Realm>;
   avatars: alepha_bucket0.BucketPrimitive;
-  protected readonly onConfigure: alepha23.HookPrimitive<"configure">;
+  protected readonly onConfigure: alepha1.HookPrimitive<"configure">;
   register(realmName: string, realmOptions?: RealmOptions): Realm;
   /**
-       * Gets a registered realm by name, auto-creating default if needed.
-       */
+   * 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>;
@@ -1550,12 +1551,12 @@ declare class RealmProvider {
 }
 //#endregion
 //#region ../../src/api/users/schemas/identityQuerySchema.d.ts
-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>;
+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>;
 }>;
 type IdentityQuery = Static<typeof identityQuerySchema>;
 //#endregion
@@ -1564,28 +1565,28 @@ declare class IdentityService {
   protected readonly log: alepha_logger5.Logger;
   protected readonly realmProvider: RealmProvider;
   protected readonly auditService: AuditService;
-  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>>;
+  identities(userRealmName?: string): alepha_orm24.Repository<alepha1.TObject<{
+    id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+    version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+    createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    userId: alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_REF>;
+    password: alepha1.TOptional<alepha1.TString>;
+    provider: alepha1.TString;
+    providerUserId: alepha1.TOptional<alepha1.TString>;
+    providerData: alepha1.TOptional<alepha1.TRecord<string, alepha1.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
@@ -1595,73 +1596,73 @@ 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: 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>;
+    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>;
     }>;
-    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>>;
+    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>>;
     }>>;
   }>;
   /**
-       * Get an identity by ID.
-       */
+   * Get an identity by ID.
+   */
   readonly getIdentity: alepha_server0.ActionPrimitiveFn<{
-    params: alepha23.TObject<{
-      id: alepha23.TString;
+    params: alepha1.TObject<{
+      id: alepha1.TString;
     }>;
-    query: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    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>>;
+    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>>;
     }>;
   }>;
   /**
-       * Delete an identity.
-       */
+   * Delete an identity.
+   */
   readonly deleteIdentity: alepha_server0.ActionPrimitiveFn<{
-    params: alepha23.TObject<{
-      id: alepha23.TString;
+    params: alepha1.TObject<{
+      id: alepha1.TString;
     }>;
-    query: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    response: alepha23.TObject<{
-      ok: alepha23.TBoolean;
-      id: alepha23.TOptional<alepha23.TUnion<[alepha23.TString, alepha23.TInteger]>>;
-      count: alepha23.TOptional<alepha23.TNumber>;
+    response: alepha1.TObject<{
+      ok: alepha1.TBoolean;
+      id: alepha1.TOptional<alepha1.TUnion<[alepha1.TString, alepha1.TInteger]>>;
+      count: alepha1.TOptional<alepha1.TNumber>;
     }>;
   }>;
 }
 //#endregion
 //#region ../../src/api/users/schemas/sessionQuerySchema.d.ts
-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>;
+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>;
 }>;
 type SessionQuery = Static<typeof sessionQuerySchema>;
 //#endregion
@@ -1669,32 +1670,32 @@ type SessionQuery = Static<typeof sessionQuerySchema>;
 declare class SessionCrudService {
   protected readonly log: alepha_logger5.Logger;
   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">;
+  sessions(userRealmName?: string): alepha_orm24.Repository<alepha1.TObject<{
+    id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+    version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+    createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    refreshToken: alepha1.TString;
+    userId: alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.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">;
     }>>;
   }>>;
   /**
-       * 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
@@ -1704,146 +1705,146 @@ 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: 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>;
+    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>;
     }>;
-    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">;
+    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">;
       }>>;
     }>>;
   }>;
   /**
-       * Get a session by ID.
-       */
+   * Get a session by ID.
+   */
   readonly getSession: alepha_server0.ActionPrimitiveFn<{
-    params: alepha23.TObject<{
-      id: alepha23.TString;
+    params: alepha1.TObject<{
+      id: alepha1.TString;
     }>;
-    query: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    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">;
+    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">;
       }>>;
     }>;
   }>;
   /**
-       * Delete a session.
-       */
+   * Delete a session.
+   */
   readonly deleteSession: alepha_server0.ActionPrimitiveFn<{
-    params: alepha23.TObject<{
-      id: alepha23.TString;
+    params: alepha1.TObject<{
+      id: alepha1.TString;
     }>;
-    query: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    response: alepha23.TObject<{
-      ok: alepha23.TBoolean;
-      id: alepha23.TOptional<alepha23.TUnion<[alepha23.TString, alepha23.TInteger]>>;
-      count: alepha23.TOptional<alepha23.TNumber>;
+    response: alepha1.TObject<{
+      ok: alepha1.TBoolean;
+      id: alepha1.TOptional<alepha1.TUnion<[alepha1.TString, alepha1.TInteger]>>;
+      count: alepha1.TOptional<alepha1.TNumber>;
     }>;
   }>;
 }
 //#endregion
 //#region ../../src/api/users/notifications/UserNotifications.d.ts
 declare class UserNotifications {
-  readonly passwordReset: alepha_api_notifications0.NotificationPrimitive<alepha23.TObject<{
-    email: alepha23.TString;
-    code: alepha23.TString;
-    expiresInMinutes: alepha23.TNumber;
+  readonly passwordReset: 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 emailVerification: alepha_api_notifications0.NotificationPrimitive<alepha1.TObject<{
+    email: 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 phoneVerification: alepha_api_notifications0.NotificationPrimitive<alepha1.TObject<{
+    phoneNumber: alepha1.TString;
+    code: alepha1.TString;
+    expiresInMinutes: alepha1.TNumber;
   }>>;
-  readonly passwordResetLink: alepha_api_notifications0.NotificationPrimitive<alepha23.TObject<{
-    email: alepha23.TString;
-    resetUrl: alepha23.TString;
-    expiresInMinutes: alepha23.TNumber;
+  readonly passwordResetLink: alepha_api_notifications0.NotificationPrimitive<alepha1.TObject<{
+    email: alepha1.TString;
+    resetUrl: alepha1.TString;
+    expiresInMinutes: alepha1.TNumber;
   }>>;
-  readonly emailVerificationLink: alepha_api_notifications0.NotificationPrimitive<alepha23.TObject<{
-    email: alepha23.TString;
-    verifyUrl: alepha23.TString;
-    expiresInMinutes: alepha23.TNumber;
+  readonly emailVerificationLink: alepha_api_notifications0.NotificationPrimitive<alepha1.TObject<{
+    email: alepha1.TString;
+    verifyUrl: alepha1.TString;
+    expiresInMinutes: alepha1.TNumber;
   }>>;
 }
 //#endregion
 //#region ../../src/api/users/schemas/createUserSchema.d.ts
-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>>;
+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>>;
 }>;
 type CreateUser = Static<typeof createUserSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/updateUserSchema.d.ts
-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>>;
+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>>;
 }>;
 type UpdateUser = Static<typeof updateUserSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/userQuerySchema.d.ts
-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>;
+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>;
 }>;
 type UserQuery = Static<typeof userQuerySchema>;
 //#endregion
@@ -1854,58 +1855,58 @@ declare class UserService {
   protected readonly userNotifications: UserNotifications;
   protected readonly realmProvider: RealmProvider;
   protected readonly auditService: AuditService;
-  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>;
+  users(userRealmName?: string): alepha_orm24.Repository<alepha1.TObject<{
+    id: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_PRIMARY_KEY>, typeof alepha_orm24.PG_DEFAULT>;
+    version: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TInteger, typeof alepha_orm24.PG_VERSION>, typeof alepha_orm24.PG_DEFAULT>;
+    createdAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_CREATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    updatedAt: alepha_orm24.PgAttr<alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_UPDATED_AT>, typeof alepha_orm24.PG_DEFAULT>;
+    realm: alepha_orm24.PgAttr<alepha1.TString, typeof alepha_orm24.PG_DEFAULT>;
+    username: alepha1.TOptional<alepha1.TString>;
+    email: alepha1.TOptional<alepha1.TString>;
+    phoneNumber: alepha1.TOptional<alepha1.TString>;
+    roles: alepha_orm24.PgAttr<alepha1.TArray<alepha1.TString>, typeof alepha_orm24.PG_DEFAULT>;
+    firstName: alepha1.TOptional<alepha1.TString>;
+    lastName: alepha1.TOptional<alepha1.TString>;
+    picture: alepha1.TOptional<alepha1.TString>;
+    enabled: alepha_orm24.PgAttr<alepha1.TBoolean, typeof alepha_orm24.PG_DEFAULT>;
+    emailVerified: alepha_orm24.PgAttr<alepha1.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
@@ -1915,154 +1916,154 @@ 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: 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>;
+    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>;
     }>;
-    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>;
+    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>;
     }>>;
   }>;
   /**
-       * Get a user by ID.
-       */
+   * Get a user by ID.
+   */
   readonly getUser: alepha_server0.ActionPrimitiveFn<{
-    params: alepha23.TObject<{
-      id: alepha23.TString;
+    params: alepha1.TObject<{
+      id: alepha1.TString;
     }>;
-    query: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    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>;
+    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>;
     }>;
   }>;
   /**
-       * Create a new user.
-       */
+   * Create a new user.
+   */
   readonly createUser: alepha_server0.ActionPrimitiveFn<{
-    query: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    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>>;
+    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>>;
     }>;
-    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>;
+    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>;
     }>;
   }>;
   /**
-       * Update a user.
-       */
+   * Update a user.
+   */
   readonly updateUser: alepha_server0.ActionPrimitiveFn<{
-    params: alepha23.TObject<{
-      id: alepha23.TString;
+    params: alepha1.TObject<{
+      id: alepha1.TString;
     }>;
-    query: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    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>>;
+    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>>;
     }>;
-    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>;
+    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>;
     }>;
   }>;
   /**
-       * Delete a user.
-       */
+   * Delete a user.
+   */
   readonly deleteUser: alepha_server0.ActionPrimitiveFn<{
-    params: alepha23.TObject<{
-      id: alepha23.TString;
+    params: alepha1.TObject<{
+      id: alepha1.TString;
     }>;
-    query: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    response: alepha23.TObject<{
-      ok: alepha23.TBoolean;
-      id: alepha23.TOptional<alepha23.TUnion<[alepha23.TString, alepha23.TInteger]>>;
-      count: alepha23.TOptional<alepha23.TNumber>;
+    response: alepha1.TObject<{
+      ok: alepha1.TBoolean;
+      id: alepha1.TOptional<alepha1.TUnion<[alepha1.TString, alepha1.TInteger]>>;
+      count: alepha1.TOptional<alepha1.TNumber>;
     }>;
   }>;
 }
@@ -2078,55 +2079,55 @@ declare class RealmController {
   protected readonly realmProvider: RealmProvider;
   protected readonly serverAuthProvider: ServerAuthProvider;
   /**
-       * Get realm configuration settings.
-       * This endpoint is not exposed in the API documentation.
-       */
+   * 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>;
+    query: alepha1.TObject<{
+      realmName: alepha1.TOptional<alepha1.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;
+    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;
+        usernameRegExp: alepha1.TString;
+        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: alepha23.TString;
-      authenticationMethods: alepha23.TArray<alepha23.TObject<{
-        name: alepha23.TString;
-        type: alepha23.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
+      realmName: alepha1.TString;
+      authenticationMethods: alepha1.TArray<alepha1.TObject<{
+        name: alepha1.TString;
+        type: alepha1.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
       }>>;
     }>;
   }>;
   readonly checkUsernameAvailability: alepha_server0.ActionPrimitiveFn<{
-    query: alepha23.TObject<{
-      realmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      realmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    body: alepha23.TObject<{
-      username: alepha23.TString;
+    body: alepha1.TObject<{
+      username: alepha1.TString;
     }>;
-    response: alepha23.TObject<{
-      available: alepha23.TBoolean;
+    response: alepha1.TObject<{
+      available: alepha1.TBoolean;
     }>;
   }>;
 }
@@ -2138,10 +2139,10 @@ declare class RealmController {
  * Requires the intent ID from Phase 1, the verification code,
  * and the new password.
  */
-declare const completePasswordResetRequestSchema: alepha23.TObject<{
-  intentId: alepha23.TString;
-  code: alepha23.TString;
-  newPassword: alepha23.TString;
+declare const completePasswordResetRequestSchema: alepha1.TObject<{
+  intentId: alepha1.TString;
+  code: alepha1.TString;
+  newPassword: alepha1.TString;
 }>;
 type CompletePasswordResetRequest = Static<typeof completePasswordResetRequestSchema>;
 //#endregion
@@ -2152,9 +2153,9 @@ type CompletePasswordResetRequest = Static<typeof completePasswordResetRequestSc
  * Contains the intent ID needed for Phase 2 completion,
  * along with expiration time.
  */
-declare const passwordResetIntentResponseSchema: alepha23.TObject<{
-  intentId: alepha23.TString;
-  expiresAt: alepha23.TString;
+declare const passwordResetIntentResponseSchema: alepha1.TObject<{
+  intentId: alepha1.TString;
+  expiresAt: alepha1.TString;
 }>;
 type PasswordResetIntentResponse = Static<typeof passwordResetIntentResponseSchema>;
 //#endregion
@@ -2178,88 +2179,88 @@ declare class CredentialService {
   protected readonly realmProvider: RealmProvider;
   protected readonly auditService: AuditService;
   protected readonly intentCache: alepha_cache0.CachePrimitiveFn<PasswordResetIntent, any[]>;
-  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>;
+  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>;
   }>>;
-  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">;
+  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">;
     }>>;
   }>>;
-  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>>;
+  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>>;
   }>>;
   /**
-       * 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: alepha23.TObject<{
-  intentId: alepha23.TString;
-  emailCode: alepha23.TOptional<alepha23.TString>;
-  phoneCode: alepha23.TOptional<alepha23.TString>;
-  captchaToken: alepha23.TOptional<alepha23.TString>;
+declare const completeRegistrationRequestSchema: alepha1.TObject<{
+  intentId: alepha1.TString;
+  emailCode: alepha1.TOptional<alepha1.TString>;
+  phoneCode: alepha1.TOptional<alepha1.TString>;
+  captchaToken: alepha1.TOptional<alepha1.TString>;
 }>;
 type CompleteRegistrationRequest = Static<typeof completeRegistrationRequestSchema>;
 //#endregion
@@ -2268,24 +2269,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: 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>;
+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>;
 }>;
 type RegisterRequest = Static<typeof registerRequestSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/registrationIntentResponseSchema.d.ts
-declare const registrationIntentResponseSchema: alepha23.TObject<{
-  intentId: alepha23.TString;
-  expectCaptcha: alepha23.TBoolean;
-  expectEmailVerification: alepha23.TBoolean;
-  expectPhoneVerification: alepha23.TBoolean;
-  expiresAt: alepha23.TString;
+declare const registrationIntentResponseSchema: alepha1.TObject<{
+  intentId: alepha1.TString;
+  expectCaptcha: alepha1.TBoolean;
+  expectEmailVerification: alepha1.TBoolean;
+  expectPhoneVerification: alepha1.TBoolean;
+  expiresAt: alepha1.TString;
 }>;
 type RegistrationIntentResponse = Static<typeof registrationIntentResponseSchema>;
 //#endregion
@@ -2321,38 +2322,38 @@ declare class RegistrationService {
   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
@@ -2364,299 +2365,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: 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>;
+    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>;
     }>;
-    query: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    response: alepha23.TObject<{
-      intentId: alepha23.TString;
-      expectCaptcha: alepha23.TBoolean;
-      expectEmailVerification: alepha23.TBoolean;
-      expectPhoneVerification: alepha23.TBoolean;
-      expiresAt: alepha23.TString;
+    response: alepha1.TObject<{
+      intentId: alepha1.TString;
+      expectCaptcha: alepha1.TBoolean;
+      expectEmailVerification: alepha1.TBoolean;
+      expectPhoneVerification: alepha1.TBoolean;
+      expiresAt: alepha1.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: alepha23.TObject<{
-      intentId: alepha23.TString;
-      emailCode: alepha23.TOptional<alepha23.TString>;
-      phoneCode: alepha23.TOptional<alepha23.TString>;
-      captchaToken: alepha23.TOptional<alepha23.TString>;
+    body: alepha1.TObject<{
+      intentId: alepha1.TString;
+      emailCode: alepha1.TOptional<alepha1.TString>;
+      phoneCode: alepha1.TOptional<alepha1.TString>;
+      captchaToken: alepha1.TOptional<alepha1.TString>;
     }>;
-    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>;
+    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>;
     }>;
   }>;
   /**
-       * 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: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    body: alepha23.TObject<{
-      email: alepha23.TString;
+    body: alepha1.TObject<{
+      email: alepha1.TString;
     }>;
-    response: alepha23.TObject<{
-      intentId: alepha23.TString;
-      expiresAt: alepha23.TString;
+    response: alepha1.TObject<{
+      intentId: alepha1.TString;
+      expiresAt: alepha1.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: alepha23.TObject<{
-      intentId: alepha23.TString;
-      code: alepha23.TString;
-      newPassword: alepha23.TString;
+    body: alepha1.TObject<{
+      intentId: alepha1.TString;
+      code: alepha1.TString;
+      newPassword: alepha1.TString;
     }>;
-    response: alepha23.TObject<{
-      ok: alepha23.TBoolean;
-      id: alepha23.TOptional<alepha23.TUnion<[alepha23.TString, alepha23.TInteger]>>;
-      count: alepha23.TOptional<alepha23.TNumber>;
+    response: alepha1.TObject<{
+      ok: alepha1.TBoolean;
+      id: alepha1.TOptional<alepha1.TUnion<[alepha1.TString, alepha1.TInteger]>>;
+      count: alepha1.TOptional<alepha1.TNumber>;
     }>;
   }>;
   /**
-       * @deprecated Use createPasswordResetIntent instead
-       */
+   * @deprecated Use createPasswordResetIntent instead
+   */
   requestPasswordReset: alepha_server0.ActionPrimitiveFn<{
-    query: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    body: alepha23.TObject<{
-      email: alepha23.TString;
+    body: alepha1.TObject<{
+      email: alepha1.TString;
     }>;
-    response: alepha23.TObject<{
-      success: alepha23.TBoolean;
-      message: alepha23.TString;
+    response: alepha1.TObject<{
+      success: alepha1.TBoolean;
+      message: alepha1.TString;
     }>;
   }>;
   /**
-       * @deprecated Use completePasswordReset instead
-       */
+   * @deprecated Use completePasswordReset instead
+   */
   validateResetToken: alepha_server0.ActionPrimitiveFn<{
-    query: alepha23.TObject<{
-      email: alepha23.TString;
-      token: alepha23.TString;
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      email: alepha1.TString;
+      token: alepha1.TString;
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    response: alepha23.TObject<{
-      valid: alepha23.TBoolean;
-      email: alepha23.TOptional<alepha23.TString>;
+    response: alepha1.TObject<{
+      valid: alepha1.TBoolean;
+      email: alepha1.TOptional<alepha1.TString>;
     }>;
   }>;
   /**
-       * @deprecated Use completePasswordReset instead
-       */
+   * @deprecated Use completePasswordReset instead
+   */
   resetPassword: alepha_server0.ActionPrimitiveFn<{
-    query: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    body: alepha23.TObject<{
-      email: alepha23.TString;
-      token: alepha23.TString;
-      newPassword: alepha23.TString;
+    body: alepha1.TObject<{
+      email: alepha1.TString;
+      token: alepha1.TString;
+      newPassword: alepha1.TString;
     }>;
-    response: alepha23.TObject<{
-      success: alepha23.TBoolean;
-      message: alepha23.TString;
+    response: alepha1.TObject<{
+      success: alepha1.TBoolean;
+      message: alepha1.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: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
-      method: alepha23.TOptional<alepha23.TUnsafe<"link" | "code">>;
-      verifyUrl: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
+      method: alepha1.TOptional<alepha1.TUnsafe<"link" | "code">>;
+      verifyUrl: alepha1.TOptional<alepha1.TString>;
     }>;
-    body: alepha23.TObject<{
-      email: alepha23.TString;
+    body: alepha1.TObject<{
+      email: alepha1.TString;
     }>;
-    response: alepha23.TObject<{
-      success: alepha23.TBoolean;
-      message: alepha23.TString;
+    response: alepha1.TObject<{
+      success: alepha1.TBoolean;
+      message: alepha1.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: alepha23.TObject<{
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    body: alepha23.TObject<{
-      email: alepha23.TString;
-      token: alepha23.TString;
+    body: alepha1.TObject<{
+      email: alepha1.TString;
+      token: alepha1.TString;
     }>;
-    response: alepha23.TObject<{
-      success: alepha23.TBoolean;
-      message: alepha23.TString;
+    response: alepha1.TObject<{
+      success: alepha1.TBoolean;
+      message: alepha1.TString;
     }>;
   }>;
   /**
-       * Check if an email is verified.
-       */
+   * Check if an email is verified.
+   */
   checkEmailVerification: alepha_server0.ActionPrimitiveFn<{
-    query: alepha23.TObject<{
-      email: alepha23.TString;
-      userRealmName: alepha23.TOptional<alepha23.TString>;
+    query: alepha1.TObject<{
+      email: alepha1.TString;
+      userRealmName: alepha1.TOptional<alepha1.TString>;
     }>;
-    response: alepha23.TObject<{
-      verified: alepha23.TBoolean;
+    response: alepha1.TObject<{
+      verified: alepha1.TBoolean;
     }>;
   }>;
 }
 //#endregion
 //#region ../../src/api/users/schemas/identityResourceSchema.d.ts
-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>>;
+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>>;
 }>;
 type IdentityResource = Static<typeof identityResourceSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/loginSchema.d.ts
-declare const loginSchema: alepha23.TObject<{
-  username: alepha23.TString;
-  password: alepha23.TString;
+declare const loginSchema: alepha1.TObject<{
+  username: alepha1.TString;
+  password: alepha1.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;
+declare const realmConfigSchema: 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;
+    usernameRegExp: alepha1.TString;
+    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: alepha23.TString;
-  authenticationMethods: alepha23.TArray<alepha23.TObject<{
-    name: alepha23.TString;
-    type: alepha23.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
+  realmName: alepha1.TString;
+  authenticationMethods: alepha1.TArray<alepha1.TObject<{
+    name: alepha1.TString;
+    type: alepha1.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
   }>>;
 }>;
 type RealmConfig = Static<typeof realmConfigSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/registerSchema.d.ts
-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>;
+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>;
 }>;
 type RegisterInput = Static<typeof registerSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/resetPasswordSchema.d.ts
-declare const resetPasswordRequestSchema: alepha23.TObject<{
-  email: alepha23.TString;
+declare const resetPasswordRequestSchema: alepha1.TObject<{
+  email: alepha1.TString;
 }>;
-declare const resetPasswordSchema: alepha23.TObject<{
-  token: alepha23.TString;
-  password: alepha23.TString;
-  confirmPassword: alepha23.TString;
+declare const resetPasswordSchema: alepha1.TObject<{
+  token: alepha1.TString;
+  password: alepha1.TString;
+  confirmPassword: alepha1.TString;
 }>;
 type ResetPasswordRequest = Static<typeof resetPasswordRequestSchema>;
 type ResetPasswordInput = Static<typeof resetPasswordSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/sessionResourceSchema.d.ts
-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">;
+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">;
   }>>;
 }>;
 type SessionResource = Static<typeof sessionResourceSchema>;
 //#endregion
 //#region ../../src/api/users/schemas/userResourceSchema.d.ts
-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>;
+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>;
 }>;
 type UserResource = Static<typeof userResourceSchema>;
 //#endregion
@@ -2670,92 +2671,92 @@ declare class SessionService {
   protected readonly realmProvider: RealmProvider;
   protected readonly fileController: alepha_server_links0.HttpVirtualClient<FileController>;
   protected readonly auditService: AuditService;
-  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>;
+  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>;
   }>>;
-  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">;
+  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">;
     }>>;
   }>>;
-  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>>;
+  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>>;
   }>>;
   /**
-       * 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<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>;
+    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>;
     }>>>;
     expiresIn: number;
     sessionId: string;
@@ -2817,7 +2818,7 @@ declare class SessionService {
  *
  * @module alepha.api.users
  */
-declare const AlephaApiUsers: alepha23.Service<alepha23.Module>;
+declare const AlephaApiUsers: alepha1.Service<alepha1.Module>;
 //#endregion
 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