@alepha/ui 0.13.0 → 0.13.2

package/dist/auth/index.d.ts

@@ -1,12 +1,11 @@
-import * as alepha1223 from "alepha";
-import { Alepha, AlephaError, Async, Descriptor, DescriptorArgs, FileLike, InstantiableClass, LogLevel, LoggerInterface, Page, PageQuery, Service, Static, StaticEncode, StreamLike, TArray, TFile, TNull, TObject, TOptional, TRecord, TSchema, TStream, TString, TUnion, TVoid, TypeBoxError } from "alepha";
-import { AnchorProps, AutocompleteProps, ButtonProps, ColorInputProps, FileInputProps, MenuProps, MenuTargetProps, MultiSelectProps, NumberInputProps, PasswordInputProps, SegmentedControlProps, SelectProps, SliderProps, SwitchProps, TagsInputProps, TextInputProps, TextareaProps, ThemeIconProps, TooltipProps } from "@mantine/core";
-import "@mantine/modals";
-import "@mantine/notifications";
-import "@mantine/nprogress";
+import { ActionMenuConfig, ActionMenuItem, ActionProps } from "@alepha/ui";
+import * as alepha1672 from "alepha";
+import { Alepha, AlephaError, Async, FileLike, InstantiableClass, LogLevel, LoggerInterface, Page, PageQuery, Primitive, PrimitiveArgs, Service, Static, StaticEncode, StreamLike, TArray, TFile, TNull, TObject, TOptional, TRecord, TSchema, TStream, TString, TUnion, TVoid } from "alepha";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
-import { ComponentType, FC, InputHTMLAttributes, ReactElement, ReactNode } from "react";
-import { DateInputProps, DateTimePickerProps, TimeInputProps } from "@mantine/dates";
+import { FC, ReactNode } from "react";
+import { IncomingMessage, Server, ServerResponse } from "node:http";
+import { Readable } from "node:stream";
+import { ReadableStream } from "node:stream/web";
 import "dayjs/plugin/relativeTime.js";
 import dayjsDuration from "dayjs/plugin/duration.js";
 import "dayjs/plugin/utc.js";
@@ -17,9 +16,6 @@ import "dayjs/locale/fr.js";
 import DayjsApi, { Dayjs, ManipulateType, PluginFunc } from "dayjs";
 import { CryptoKey, FlattenedJWSInput, JSONWebKeySet, JWSHeaderParameters, JWTHeaderParameters, JWTPayload, JWTVerifyResult, KeyObject } from "jose";
 import { JWTVerifyOptions } from "jose/jwt/verify";
-import { IncomingMessage, Server, ServerResponse } from "node:http";
-import { Readable } from "node:stream";
-import { ReadableStream } from "node:stream/web";
 import * as drizzle_orm0 from "drizzle-orm";
 import { BuildExtraConfigColumns, SQL, SQLWrapper } from "drizzle-orm";
 import * as drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
@@ -29,28 +25,275 @@ import * as DrizzleKit from "drizzle-kit/api";
 import { Configuration } from "openid-client";
 
 //#region ../alepha/src/security/schemas/userAccountInfoSchema.d.ts
-declare const userAccountInfoSchema: alepha1223.TObject<{
-  id: alepha1223.TString;
-  name: alepha1223.TOptional<alepha1223.TString>;
-  email: alepha1223.TOptional<alepha1223.TString>;
-  username: alepha1223.TOptional<alepha1223.TString>;
-  picture: alepha1223.TOptional<alepha1223.TString>;
-  sessionId: alepha1223.TOptional<alepha1223.TString>;
-  organizations: alepha1223.TOptional<alepha1223.TArray<alepha1223.TString>>;
-  roles: alepha1223.TOptional<alepha1223.TArray<alepha1223.TString>>;
+declare const userAccountInfoSchema: alepha1672.TObject<{
+  id: alepha1672.TString;
+  name: alepha1672.TOptional<alepha1672.TString>;
+  email: alepha1672.TOptional<alepha1672.TString>;
+  username: alepha1672.TOptional<alepha1672.TString>;
+  picture: alepha1672.TOptional<alepha1672.TString>;
+  sessionId: alepha1672.TOptional<alepha1672.TString>;
+  organizations: alepha1672.TOptional<alepha1672.TArray<alepha1672.TString>>;
+  roles: alepha1672.TOptional<alepha1672.TArray<alepha1672.TString>>;
 }>;
 type UserAccount = Static<typeof userAccountInfoSchema>;
 //#endregion
+//#region ../alepha/src/server/schemas/errorSchema.d.ts
+declare const errorSchema: alepha1672.TObject<{
+  error: alepha1672.TString;
+  status: alepha1672.TInteger;
+  message: alepha1672.TString;
+  details: alepha1672.TOptional<alepha1672.TString>;
+  requestId: alepha1672.TOptional<alepha1672.TString>;
+  cause: alepha1672.TOptional<alepha1672.TObject<{
+    name: alepha1672.TString;
+    message: alepha1672.TString;
+  }>>;
+}>;
+type ErrorSchema = Static<typeof errorSchema>;
+//#endregion
+//#region ../alepha/src/server/errors/HttpError.d.ts
+declare class HttpError extends AlephaError {
+  name: string;
+  static is: (error: unknown, status?: number) => error is HttpErrorLike;
+  static toJSON(error: HttpError): ErrorSchema;
+  readonly error: string;
+  readonly status: number;
+  readonly requestId?: string;
+  readonly details?: string;
+  readonly reason?: {
+    name: string;
+    message: string;
+  };
+  constructor(options: Partial<ErrorSchema>, cause?: unknown);
+}
+interface HttpErrorLike extends Error {
+  status: number;
+}
+//#endregion
+//#region ../alepha/src/router/providers/RouterProvider.d.ts
+declare abstract class RouterProvider<T$1 extends Route = Route> {
+  protected routePathRegex: RegExp;
+  protected tree: Tree<T$1>;
+  protected cache: Map<string, RouteMatch<T$1>>;
+  match(path: string): RouteMatch<T$1>;
+  protected test(path: string): void;
+  protected push(route: T$1): void;
+  protected createRouteMatch(path: string): RouteMatch<T$1>;
+  protected mapParams(match: RouteMatch<T$1>): RouteMatch<T$1>;
+  protected createParts(path: string): string[];
+}
+interface RouteMatch<T$1 extends Route> {
+  route?: T$1;
+  params?: Record<string, string>;
+}
+interface Route {
+  path: string;
+  /**
+   * Rename a param in the route.
+   * This is automatically filled when you have scenarios like:
+   * `/customers/:id` and `/customers/:userId/payments`
+   *
+   * In this case, `:id` will be renamed to `:userId` in the second route.
+   */
+  mapParams?: Record<string, string>;
+}
+interface Tree<T$1 extends Route> {
+  route?: T$1;
+  children: {
+    [key: string]: Tree<T$1>;
+  };
+  param?: {
+    route?: T$1;
+    name: string;
+    children: {
+      [key: string]: Tree<T$1>;
+    };
+  };
+  wildcard?: {
+    route: T$1;
+  };
+}
+//#endregion
+//#region ../alepha/src/server/constants/routeMethods.d.ts
+declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
+type RouteMethod = (typeof routeMethods)[number];
+//#endregion
+//#region ../alepha/src/server/helpers/ServerReply.d.ts
+/**
+ * Helper for building server replies.
+ */
+declare class ServerReply {
+  headers: Record<string, string> & {
+    "set-cookie"?: string[];
+  };
+  status?: number;
+  body?: any;
+  /**
+   * Redirect to a given URL with optional status code (default 302).
+   */
+  redirect(url: string, status?: number): void;
+  /**
+   * Set the response status code.
+   */
+  setStatus(status: number): this;
+  /**
+   * Set a response header.
+   */
+  setHeader(name: string, value: string): this;
+  /**
+   * Set the response body.
+   */
+  setBody(body: any): this;
+}
+//#endregion
+//#region ../alepha/src/server/services/UserAgentParser.d.ts
+interface UserAgentInfo {
+  os: "Windows" | "Android" | "Ubuntu" | "MacOS" | "iOS" | "Linux" | "FreeBSD" | "OpenBSD" | "ChromeOS" | "BlackBerry" | "Symbian" | "Windows Phone";
+  browser: "Chrome" | "Firefox" | "Safari" | "Edge" | "Opera" | "Internet Explorer" | "Brave" | "Vivaldi" | "Samsung Browser" | "UC Browser" | "Yandex";
+  device: "MOBILE" | "DESKTOP" | "TABLET";
+}
+/**
+ * Simple User-Agent parser to detect OS, browser, and device type.
+ * This parser is not exhaustive and may not cover all edge cases.
+ *
+ * Use result for non
+ */
+declare class UserAgentParser {
+  parse(userAgent?: string): UserAgentInfo;
+}
+//#endregion
+//#region ../alepha/src/server/interfaces/ServerRequest.d.ts
+type TRequestBody = TObject | TString | TArray | TRecord | TStream;
+type TResponseBody = TObject | TString | TRecord | TFile | TArray | TStream | TVoid;
+interface RequestConfigSchema {
+  body?: TRequestBody;
+  params?: TObject;
+  query?: TObject;
+  headers?: TObject;
+  response?: TResponseBody;
+}
+interface ServerRequestConfig<TConfig extends RequestConfigSchema = RequestConfigSchema> {
+  body: TConfig["body"] extends TRequestBody ? Static<TConfig["body"]> : any;
+  headers: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : Record<string, string>;
+  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : Record<string, string>;
+  query: TConfig["query"] extends TObject ? Static<TConfig["query"]> : Record<string, any>;
+}
+type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
+interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
+  /**
+   * HTTP method used for this request.
+   */
+  method: RouteMethod;
+  /**
+   * Full request URL.
+   */
+  url: URL;
+  /**
+   * Unique request ID assigned to this request.
+   */
+  requestId: string;
+  /**
+   * Client IP address.
+   * Will parse `X-Forwarded-For` header if present.
+   */
+  ip?: string;
+  /**
+   * Value of the `Host` header sent by the client.
+   */
+  host?: string;
+  /**
+   * Browser user agent information.
+   * Information are not guaranteed to be accurate. Use with caution.
+   *
+   * @see {@link UserAgentParser}
+   */
+  userAgent: UserAgentInfo;
+  /**
+   * Arbitrary metadata attached to the request. Can be used by middlewares to store information.
+   */
+  metadata: Record<string, any>;
+  /**
+   * Reply object to be used to send response.
+   */
+  reply: ServerReply;
+  /**
+   * The raw underlying request object (Web Request).
+   */
+  raw: ServerRawRequest;
+}
+interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
+  /**
+   * Handler function for this route.
+   */
+  handler: ServerHandler<TConfig>;
+  /**
+   * HTTP method for this route.
+   */
+  method?: RouteMethod;
+  /**
+   * Request/response schema for this route.
+   *
+   * Request schema contains:
+   * - body, for POST/PUT/PATCH requests
+   * - params, for URL parameters (e.g. /user/:id)
+   * - query, for URL query parameters (e.g. /user?id=123)
+   * - headers, for HTTP headers
+   *
+   * Response schema contains:
+   * - response
+   *
+   * Response schema is used to validate and serialize the response sent by the handler.
+   */
+  schema?: TConfig;
+  /**
+   * @see ServerLoggerProvider
+   */
+  silent?: boolean;
+}
+type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TResponseBody ? Static<TConfig["response"]> : ResponseBodyType;
+type ResponseKind = "json" | "text" | "void" | "file" | "any";
+type ResponseBodyType = string | Buffer | StreamLike | undefined | null | void;
+type ServerHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
+interface ServerResponse$1 {
+  body: string | Buffer | ArrayBuffer | Readable | ReadableStream;
+  headers: Record<string, string>;
+  status: number;
+}
+type ServerRouteRequestHandler = (request: ServerRequestData) => Promise<ServerResponse$1>;
+interface ServerRouteMatcher extends Route {
+  handler: ServerRouteRequestHandler;
+}
+interface ServerRequestData {
+  method: RouteMethod;
+  url: URL;
+  headers: Record<string, string>;
+  query: Record<string, string>;
+  params: Record<string, string>;
+  raw: ServerRawRequest;
+}
+interface ServerRawRequest {
+  node?: NodeRequestEvent;
+  web?: WebRequestEvent;
+}
+interface NodeRequestEvent {
+  req: IncomingMessage;
+  res: ServerResponse;
+}
+interface WebRequestEvent {
+  req: Request;
+  res?: Response;
+}
+//#endregion
 //#region ../alepha/src/logger/schemas/logEntrySchema.d.ts
-declare const logEntrySchema: alepha1223.TObject<{
-  level: alepha1223.TUnsafe<"TRACE" | "SILENT" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
-  message: alepha1223.TString;
-  service: alepha1223.TString;
-  module: alepha1223.TString;
-  context: alepha1223.TOptional<alepha1223.TString>;
-  app: alepha1223.TOptional<alepha1223.TString>;
-  data: alepha1223.TOptional<alepha1223.TAny>;
-  timestamp: alepha1223.TNumber;
+declare const logEntrySchema: alepha1672.TObject<{
+  level: alepha1672.TUnsafe<"TRACE" | "SILENT" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+  message: alepha1672.TString;
+  service: alepha1672.TString;
+  module: alepha1672.TString;
+  context: alepha1672.TOptional<alepha1672.TString>;
+  app: alepha1672.TOptional<alepha1672.TString>;
+  data: alepha1672.TOptional<alepha1672.TAny>;
+  timestamp: alepha1672.TNumber;
 }>;
 type LogEntry = Static<typeof logEntrySchema>;
 //#endregion
@@ -65,8 +308,8 @@ declare class DateTimeProvider {
   protected readonly timeouts: Timeout[];
   protected readonly intervals: Interval[];
   constructor();
-  protected readonly onStart: alepha1223.HookDescriptor<"start">;
-  protected readonly onStop: alepha1223.HookDescriptor<"stop">;
+  protected readonly onStart: alepha1672.HookPrimitive<"start">;
+  protected readonly onStop: alepha1672.HookPrimitive<"stop">;
   setLocale(locale: string): void;
   isDateTime(value: unknown): value is DateTime;
   /**
@@ -198,7 +441,7 @@ declare class Logger implements LoggerInterface {
 }
 //#endregion
 //#region ../alepha/src/logger/index.d.ts
-declare const envSchema$9: alepha1223.TObject<{
+declare const envSchema$9: alepha1672.TObject<{
   /**
    * Default log level for the application.
    *
@@ -215,14 +458,14 @@ declare const envSchema$9: alepha1223.TObject<{
    * LOG_LEVEL=my.module.name:debug,info # Set debug level for my.module.name and info for all other modules
    * LOG_LEVEL=alepha:trace, info # Set trace level for all alepha modules and info for all other modules
    */
-  LOG_LEVEL: alepha1223.TOptional<alepha1223.TString>;
+  LOG_LEVEL: alepha1672.TOptional<alepha1672.TString>;
   /**
    * Built-in log formats.
    * - "json" - JSON format, useful for structured logging and log aggregation. {@link JsonFormatterProvider}
    * - "pretty" - Simple text format, human-readable, with colors. {@link SimpleFormatterProvider}
    * - "raw" - Raw format, no formatting, just the message.  {@link RawFormatterProvider}
    */
-  LOG_FORMAT: alepha1223.TOptional<alepha1223.TUnsafe<"json" | "pretty" | "raw">>;
+  LOG_FORMAT: alepha1672.TOptional<alepha1672.TUnsafe<"json" | "pretty" | "raw">>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$9>> {}
@@ -240,1142 +483,895 @@ declare module "alepha" {
   }
 }
 //#endregion
-//#region ../alepha/src/security/interfaces/UserAccountToken.d.ts
-/**
- * Add contextual metadata to a user account info.
- * E.g. UserAccountToken is a UserAccountInfo during a request.
- */
-interface UserAccountToken extends UserAccount {
-  /**
-   * Access token for the user.
-   */
-  token?: string;
-  /**
-   * Realm name of the user.
-   */
-  realm?: string;
-  /**
-   * Is user dedicated to his own resources for this scope ?
-   * Mostly, Admin is false and Customer is true.
-   */
-  ownership?: string | boolean;
+//#region ../alepha/src/server/services/ServerRequestParser.d.ts
+declare class ServerRequestParser {
+  protected readonly alepha: Alepha;
+  protected readonly userAgentParser: UserAgentParser;
+  createServerRequest(rawRequest: ServerRequestData): ServerRequest;
+  getRequestId(request: ServerRequestData): string | undefined;
+  getRequestUserAgent(request: ServerRequestData): UserAgentInfo;
+  getRequestIp(request: ServerRequestData): string | undefined;
 }
 //#endregion
-//#region ../alepha/src/security/schemas/permissionSchema.d.ts
-declare const permissionSchema: alepha1223.TObject<{
-  name: alepha1223.TString;
-  group: alepha1223.TOptional<alepha1223.TString>;
-  description: alepha1223.TOptional<alepha1223.TString>;
-  method: alepha1223.TOptional<alepha1223.TString>;
-  path: alepha1223.TOptional<alepha1223.TString>;
-}>;
-type Permission = Static<typeof permissionSchema>;
-//#endregion
-//#region ../alepha/src/security/schemas/roleSchema.d.ts
-declare const roleSchema: alepha1223.TObject<{
-  name: alepha1223.TString;
-  description: alepha1223.TOptional<alepha1223.TString>;
-  default: alepha1223.TOptional<alepha1223.TBoolean>;
-  permissions: alepha1223.TArray<alepha1223.TObject<{
-    name: alepha1223.TString;
-    ownership: alepha1223.TOptional<alepha1223.TBoolean>;
-    exclude: alepha1223.TOptional<alepha1223.TArray<alepha1223.TString>>;
-  }>>;
-}>;
-type Role = Static<typeof roleSchema>;
+//#region ../alepha/src/server/providers/ServerTimingProvider.d.ts
+type TimingMap = Record<string, [number, number]>;
+declare class ServerTimingProvider {
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  options: {
+    prefix: string;
+    disabled: boolean;
+  };
+  readonly onRequest: alepha1672.HookPrimitive<"server:onRequest">;
+  readonly onResponse: alepha1672.HookPrimitive<"server:onResponse">;
+  protected get handlerName(): string;
+  beginTiming(name: string): void;
+  endTiming(name: string): void;
+  protected setDuration(name: string, timing: TimingMap): void;
+}
 //#endregion
-//#region ../alepha/src/security/providers/JwtProvider.d.ts
+//#region ../alepha/src/server/providers/ServerRouterProvider.d.ts
 /**
- * Provides utilities for working with JSON Web Tokens (JWT).
+ * Main router for all routes on the server side.
+ *
+ * - $route => generic route
+ * - $action => action route (for API calls)
+ * - $page => React route (for SSR)
  */
-declare class JwtProvider {
+declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
   protected readonly log: Logger;
-  protected readonly keystore: KeyLoaderHolder[];
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly encoder: TextEncoder;
-  /**
-   * Adds a key loader to the embedded keystore.
-   *
-   * @param name
-   * @param secretKeyOrJwks
-   */
-  setKeyLoader(name: string, secretKeyOrJwks: string | JSONWebKeySet): void;
-  /**
-   * Retrieves the payload from a JSON Web Token (JWT).
-   *
-   * @param token - The JWT to extract the payload from.
-   *
-   * @return A Promise that resolves with the payload object from the token.
-   */
-  parse(token: string, keyName?: string, options?: JWTVerifyOptions): Promise<JwtParseResult>;
-  /**
-   * Creates a JWT token with the provided payload and secret key.
-   *
-   * @param payload - The payload to be encoded in the token.
-   * 	It should include the `realm_access` property which contains an array of roles.
-   * @param keyName - The name of the key to use when signing the token.
-   *
-   * @returns The signed JWT token.
-   */
-  create(payload: ExtendedJWTPayload, keyName?: string, signOptions?: JwtSignOptions): Promise<string>;
+  protected readonly alepha: Alepha;
+  protected readonly routes: ServerRoute[];
+  protected readonly serverTimingProvider: ServerTimingProvider;
+  protected readonly serverRequestParser: ServerRequestParser;
   /**
-   * Determines if the provided key is a secret key.
+   * Get all registered routes, optionally filtered by a pattern.
    *
-   * @param key
-   * @protected
+   * Pattern accept simple wildcard '*' at the end.
+   * Example: '/api/*' will match all routes starting with '/api/' but '/api/' will match only that exact route.
    */
-  protected isSecretKey(key: string): boolean;
-}
-type KeyLoader = (protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput) => Promise<CryptoKey | KeyObject>;
-interface KeyLoaderHolder {
-  name: string;
-  keyLoader: KeyLoader;
-  secretKey?: string;
-}
-interface JwtSignOptions {
-  header?: Partial<JWTHeaderParameters>;
-}
-interface ExtendedJWTPayload extends JWTPayload {
-  sid?: string;
-  name?: string;
-  roles?: string[];
-  email?: string;
-  organizations?: string[];
-  realm_access?: {
-    roles: string[];
-  };
-}
-interface JwtParseResult {
-  keyName: string;
-  result: JWTVerifyResult<ExtendedJWTPayload>;
+  getRoutes(pattern?: string): ServerRoute[];
+  createRoute<TConfig extends RequestConfigSchema = RequestConfigSchema>(route: ServerRoute<TConfig>): void;
+  protected getContextId(headers: Record<string, string>): string;
+  protected processRequest(request: ServerRequest, route: ServerRoute, responseKind: ResponseKind): Promise<{
+    status: number;
+    headers: Record<string, string> & {
+      "set-cookie"?: string[];
+    };
+    body: any;
+  }>;
+  protected runRouteHandler(route: ServerRoute, request: ServerRequest, responseKind: ResponseKind): Promise<void>;
+  serializeResponse(route: ServerRoute, reply: ServerReply, responseKind: ResponseKind): void;
+  protected getResponseType(schema?: RequestConfigSchema): ResponseKind;
+  protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
+  validateRequest(route: {
+    schema?: RequestConfigSchema;
+  }, request: ServerRequestConfig): void;
 }
 //#endregion
-//#region ../alepha/src/security/providers/SecurityProvider.d.ts
-declare const envSchema$8: alepha1223.TObject<{
-  APP_SECRET: alepha1223.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$8>> {}
-}
-declare class SecurityProvider {
-  protected readonly UNKNOWN_USER_NAME = "Anonymous User";
-  protected readonly PERMISSION_REGEXP: RegExp;
-  protected readonly PERMISSION_REGEXP_WILDCARD: RegExp;
+//#region ../alepha/src/server/providers/ServerProvider.d.ts
+/**
+ * Base server provider to handle incoming requests and route them.
+ *
+ * This is the default implementation for serverless environments.
+ *
+ * ServerProvider supports both Node.js HTTP requests and Web (Fetch API) requests.
+ */
+declare class ServerProvider {
   protected readonly log: Logger;
-  protected readonly jwt: JwtProvider;
-  protected readonly env: {
-    APP_SECRET: string;
-  };
   protected readonly alepha: Alepha;
-  get secretKey(): string;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly router: ServerRouterProvider;
+  protected readonly internalServerErrorMessage = "Internal Server Error";
+  get hostname(): string;
   /**
-   * The permissions configured for the security provider.
+   * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
    */
-  protected readonly permissions: Permission[];
+  protected readonly onNodeRequest: alepha1672.HookPrimitive<"node:request">;
   /**
-   * The realms configured for the security provider.
+   * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
    */
-  protected readonly realms: Realm[];
-  protected start: alepha1223.HookDescriptor<"start">;
+  protected readonly onWebRequest: alepha1672.HookPrimitive<"web:request">;
   /**
-   * Adds a role to one or more realms.
+   * Handle Node.js HTTP request event.
    *
-   * @param role
-   * @param realms
+   * Technically, we just convert Node.js request to Web Standard Request.
    */
-  createRole(role: Role, ...realms: string[]): Role;
+  handleNodeRequest(nodeRequestEvent: NodeRequestEvent): Promise<void>;
   /**
-   * Adds a permission to the security provider.
-   *
-   * @param raw - The permission to add.
+   * Handle Web (Fetch API) request event.
    */
-  createPermission(raw: Permission | string): Permission;
-  createRealm(realm: Realm): void;
+  handleWebRequest(ev: WebRequestEvent): Promise<void>;
   /**
-   * Updates the roles for a realm then synchronizes the user account provider if available.
-   *
-   * Only available when the app is started.
-   *
-   * @param realm - The realm to update the roles for.
-   * @param roles - The roles to update.
+   * Helper for Vite development mode to let Vite handle (or not) 404.
    */
-  updateRealm(realm: string, roles: Role[]): Promise<void>;
+  protected isViteNotFound(url?: string, route?: Route, params?: Record<string, string>): boolean;
+}
+//#endregion
+//#region ../alepha/src/cache/providers/CacheProvider.d.ts
+/**
+ * Cache provider interface.
+ *
+ * All methods are asynchronous and return promises.
+ * Values are stored as Uint8Array.
+ */
+declare abstract class CacheProvider {
   /**
-   * Creates a user account from the provided payload.
+   * Get the value of a key.
    *
-   * @param payload - The payload to create the user account from.
-   * @param [realmName] - The realm containing the roles. Default is all.
+   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+   * @param key The key of the value to get.
    *
-   * @returns The user info created from the payload.
+   * @return The value of the key, or undefined if the key does not exist.
    */
-  createUserFromPayload(payload: JWTPayload, realmName?: string): UserAccount;
+  abstract get(name: string, key: string): Promise<Uint8Array | undefined>;
   /**
-   * Checks if the user has the specified permission.
+   * Set the string value of a key.
    *
-   * Bonus: we check also if the user has "ownership" flag.
+   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+   * @param key The key of the value to set.
+   * @param value The value to set.
+   * @param ttl The time-to-live of the key, in milliseconds.
    *
-   * @param permissionLike - The permission to check for.
-   * @param roleEntries - The roles to check for the permission.
-   */
-  checkPermission(permissionLike: string | Permission, ...roleEntries: string[]): SecurityCheckResult;
-  /**
-   * Creates a user account from the provided payload.
+   * @return The value of the key.
    */
-  createUserFromToken(headerOrToken?: string, options?: {
-    permission?: Permission | string;
-    realm?: string;
-    verify?: JWTVerifyOptions;
-  }): Promise<UserAccountToken>;
+  abstract set(name: string, key: string, value: Uint8Array, ttl?: number): Promise<Uint8Array>;
   /**
-   * Checks if a user has a specific role.
+   * Remove the specified keys.
    *
-   * @param roleName - The role to check for.
-   * @param permission - The permission to check for.
-   * @returns True if the user has the role, false otherwise.
+   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+   * @param keys The keys to delete.
    */
-  can(roleName: string, permission: string | Permission): boolean;
+  abstract del(name: string, ...keys: string[]): Promise<void>;
+  abstract has(name: string, key: string): Promise<boolean>;
+  abstract keys(name: string, filter?: string): Promise<string[]>;
   /**
-   * Checks if a user has ownership of a specific permission.
+   * Remove all keys from all cache names.
    */
-  ownership(roleName: string, permission: string | Permission): string | boolean | undefined;
+  abstract clear(): Promise<void>;
+}
+//#endregion
+//#region ../alepha/src/cache/primitives/$cache.d.ts
+interface CachePrimitiveOptions<TReturn = any, TParameter extends any[] = any[]> {
   /**
-   * Converts a permission object to a string.
+   * The cache name. This is useful for invalidating multiple caches at once.
    *
-   * @param permission
+   * Store key as `cache:$name:$key`.
+   *
+   * @default Name of the key of the class.
    */
-  permissionToString(permission: Permission | string): string;
-  getRealms(): Realm[];
+  name?: string;
   /**
-   * Retrieves the user account from the provided user ID.
-   *
-   * @param realm
+   * Function which returns cached data.
    */
-  getRoles(realm?: string): Role[];
+  handler?: (...args: TParameter) => TReturn;
   /**
-   * Returns all permissions.
-   *
-   * @param user - Filter permissions by user.
-   *
-   * @return An array containing all permissions.
+   * The key generator for the cache.
+   * If not provided, the arguments will be json.stringify().
    */
-  getPermissions(user?: {
-    roles?: Array<Role | string>;
-    realm?: string;
-  }): Permission[];
+  key?: (...args: TParameter) => string;
   /**
-   * Retrieves the user ID from the provided payload object.
+   * The store provider for the cache.
+   * If not provided, the default store provider will be used.
+   */
+  provider?: InstantiableClass<CacheProvider> | "memory";
+  /**
+   * The time-to-live for the cache in seconds.
+   * Set 0 to skip expiration.
    *
-   * @param payload - The payload object from which to extract the user ID.
-   * @return The user ID as a string.
+   * @default 300 (5 minutes).
    */
-  getIdFromPayload(payload: Record<string, any>): string;
-  getSessionIdFromPayload(payload: Record<string, any>): string | undefined;
+  ttl?: DurationLike;
   /**
-   * Retrieves the roles from the provided payload object.
-   * @param payload - The payload object from which to extract the roles.
-   * @return An array of role strings.
+   * If the cache is disabled.
    */
-  getRolesFromPayload(payload: Record<string, any>): string[];
-  getPictureFromPayload(payload: Record<string, any>): string | undefined;
-  getUsernameFromPayload(payload: Record<string, any>): string | undefined;
-  getEmailFromPayload(payload: Record<string, any>): string | undefined;
+  disabled?: boolean;
+}
+declare class CachePrimitive<TReturn = any, TParameter extends any[] = any[]> extends Primitive<CachePrimitiveOptions<TReturn, TParameter>> {
+  protected readonly env: {
+    CACHE_ENABLED: boolean;
+    CACHE_DEFAULT_TTL: number;
+  };
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly provider: CacheProvider;
+  protected encoder: TextEncoder;
+  protected decoder: TextDecoder;
+  protected codes: {
+    BINARY: number;
+    JSON: number;
+    STRING: number;
+  };
+  get container(): string;
+  run(...args: TParameter): Promise<TReturn>;
+  key(...args: TParameter): string;
+  invalidate(...keys: string[]): Promise<void>;
+  set(key: string, value: TReturn, ttl?: DurationLike): Promise<void>;
+  get(key: string): Promise<TReturn | undefined>;
+  protected serialize<TReturn>(value: TReturn): Uint8Array;
+  protected deserialize<TReturn>(uint8Array: Uint8Array): Promise<TReturn>;
+  protected $provider(): CacheProvider;
+}
+interface CachePrimitiveFn<TReturn = any, TParameter extends any[] = any[]> extends CachePrimitive<TReturn, TParameter> {
   /**
-   * Returns the name from the given payload.
-   *
-   * @param payload - The payload object.
-   * @returns The name extracted from the payload, or an empty string if the payload is falsy or no name is found.
+   * Run the cache primitive with the provided arguments.
    */
-  getNameFromPayload(payload: Record<string, any>): string;
-  getOrganizationsFromPayload(payload: Record<string, any>): string[] | undefined;
+  (...args: TParameter): Promise<TReturn>;
 }
-/**
- * A realm definition.
- */
-interface Realm {
-  name: string;
-  roles: Role[];
+//#endregion
+//#region ../alepha/src/server/services/HttpClient.d.ts
+declare class HttpClient {
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  readonly cache: CachePrimitiveFn<HttpClientCache, any[]>;
+  protected readonly pendingRequests: HttpClientPendingRequests;
+  fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
+  fetch<T$1 extends TSchema>(url: string, request?: RequestInitWithOptions<T$1>): Promise<FetchResponse<Static<T$1>>>;
+  protected url(host: string, action: HttpAction, args: ServerRequestConfigEntry): string;
+  protected body(init: RequestInit, headers: Record<string, string>, action: HttpAction, args?: ServerRequestConfigEntry): Promise<void>;
+  protected responseData(response: Response, options: FetchOptions): Promise<any>;
+  protected isMaybeFile(response: Response): boolean;
+  protected createFileLike(response: Response, defaultFileName?: string): FileLike;
+  pathVariables(url: string, action: {
+    schema?: {
+      params?: TObject;
+    };
+  }, args?: ServerRequestConfigEntry): string;
+  queryParams(url: string, action: {
+    schema?: {
+      query?: TObject;
+    };
+  }, args?: ServerRequestConfigEntry): string;
+}
+interface FetchOptions<T$1 extends TSchema = TSchema> {
   /**
-   * The secret key for the realm.
-   *
-   * Can be also a JWKS URL.
+   * Key to identify the request in the pending requests.
    */
-  secret?: string | JSONWebKeySet | (() => string);
+  key?: string;
   /**
-   * Create the user account info based on the raw JWT payload.
-   * By default, SecurityProvider has his own implementation, but this method allow to override it.
+   * The schema to validate the response against.
    */
-  profile?: (raw: Record<string, any>) => UserAccount;
+  schema?: {
+    response?: T$1;
+  };
+  /**
+   * Built-in cache options.
+   */
+  localCache?: boolean | number | DurationLike;
 }
-interface SecurityCheckResult {
-  isAuthorized: boolean;
-  ownership: string | boolean | undefined;
+type RequestInitWithOptions<T$1 extends TSchema = TSchema> = RequestInit & FetchOptions<T$1>;
+interface FetchResponse<T$1 = any> {
+  data: T$1;
+  status: number;
+  statusText: string;
+  headers: Headers;
+  raw?: Response;
+}
+type HttpClientPendingRequests = Record<string, Promise<any> | undefined>;
+interface HttpClientCache {
+  data: any;
+  etag?: string;
+}
+interface FetchActionArgs {
+  action: HttpAction;
+  host?: string;
+  config?: ServerRequestConfigEntry;
+  options?: ClientRequestOptions;
+}
+interface HttpAction {
+  method?: string;
+  prefix?: string;
+  path: string;
+  requestBodyType?: string;
+  schema?: {
+    params?: TObject;
+    query?: TObject;
+    body?: TRequestBody;
+    response?: TResponseBody;
+  };
 }
 //#endregion
-//#region ../alepha/src/security/descriptors/$realm.d.ts
-type RealmDescriptorOptions = {
+//#region ../alepha/src/server/primitives/$action.d.ts
+interface ActionPrimitiveOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
   /**
-   * Define the realm name.
-   * If not provided, it will use the property key.
+   * Name of the action.
+   *
+   * - It will be used to generate the route path if `path` is not provided.
+   * - It will be used to generate the permission name if `security` is enabled.
    */
   name?: string;
   /**
-   * Short description about the realm.
+   * Group actions together.
+   *
+   * - If not provided, the service name containing the route will be used.
+   * - It will be used as Tag for documentation purposes.
+   * - It will be used for permission name generation if `security` is enabled.
+   *
+   * @example
+   * ```ts
+   * // group = "MyController"
+   * class MyController {
+   * 	hello = $action({ handler: () => "Hello World" });
+   * }
+   *
+   * // group = "users"
+   * class MyOtherController {
+   *   group = "users";
+   *   a1 = $action({ handler: () => "Action 1", group: this.group });
+   *   a2 = $action({ handler: () => "Action 2", group: this.group });
+   * }
+   * ```
    */
-  description?: string;
+  group?: string;
   /**
-   * All roles available in the realm. Role is a string (role name) or a Role object (embedded role).
+   * Pathname of the route. If not provided, property key is used.
    */
-  roles?: Array<string | Role>;
+  path?: string;
   /**
-   * Realm settings.
+   * The route method.
+   *
+   * - If not provided, it will be set to "GET" by default.
+   * - If not provider and a body is provided, it will be set to "POST".
+   *
+   * Wildcard methods are not supported for now. (e.g. "ALL", "ANY", etc.)
    */
-  settings?: RealmSettings;
+  method?: RouteMethod;
   /**
-   * Parse the JWT payload to create a user account info.
+   * The config schema of the route.
+   * - body: The request body schema.
+   * - params: Path variables schema.
+   * - query: The request query-params schema.
+   * - response: The response schema.
    */
-  profile?: (jwtPayload: Record<string, any>) => UserAccount;
-} & (RealmInternal | RealmExternal);
-interface RealmSettings {
-  accessToken?: {
-    /**
-     * Lifetime of the access token.
-     * @default 15 minutes
-     */
-    expiration?: DurationLike;
-  };
-  refreshToken?: {
-    /**
-     * Lifetime of the refresh token.
-     * @default 30 days
-     */
-    expiration?: DurationLike;
-  };
-  onCreateSession?: (user: UserAccount, config: {
-    expiresIn: number;
-  }) => Promise<{
-    refreshToken: string;
-    sessionId?: string;
-  }>;
-  onRefreshSession?: (refreshToken: string) => Promise<{
-    user: UserAccount;
-    expiresIn: number;
-    sessionId?: string;
-  }>;
-  onDeleteSession?: (refreshToken: string) => Promise<void>;
-}
-type RealmInternal = {
+  schema?: TConfig;
   /**
-   * Internal secret to sign JWT tokens and verify them.
+   * A short description of the action. Used for documentation purposes.
    */
-  secret: string;
-};
-interface RealmExternal {
+  description?: string;
   /**
-   * URL to the JWKS (JSON Web Key Set) to verify JWT tokens from external providers.
+   * Disable the route. Useful with env variables do disable one specific route.
+   * Route won't be available in the API but can still be called locally!
    */
-  jwks: (() => string) | JSONWebKeySet;
+  disabled?: boolean;
+  /**
+   * Main route handler. This is where the route logic is implemented.
+   */
+  handler: ServerActionHandler<TConfig>;
 }
-declare class RealmDescriptor extends Descriptor<RealmDescriptorOptions> {
-  protected readonly securityProvider: SecurityProvider;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly jwt: JwtProvider;
+declare class ActionPrimitive<TConfig extends RequestConfigSchema> extends Primitive<ActionPrimitiveOptions<TConfig>> {
   protected readonly log: Logger;
-  get name(): string;
-  get accessTokenExpiration(): Duration;
-  get refreshTokenExpiration(): Duration;
+  protected readonly env: {
+    SERVER_API_PREFIX: string;
+  };
+  protected readonly httpClient: HttpClient;
+  protected readonly serverProvider: ServerProvider;
+  protected readonly serverRouterProvider: ServerRouterProvider;
   protected onInit(): void;
+  get prefix(): string;
+  get route(): ServerRoute;
   /**
-   * Get all roles in the realm.
+   * Returns the name of the action.
    */
-  getRoles(): Role[];
-  /**
-   * Set all roles in the realm.
-   */
-  setRoles(roles: Role[]): Promise<void>;
+  get name(): string;
   /**
-   * Get a role by name, throws an error if not found.
+   * Returns the group of the action. (e.g. "orders", "admin", etc.)
    */
-  getRoleByName(name: string): Role;
-  parseToken(token: string): Promise<JWTPayload>;
+  get group(): string;
   /**
-   * Create a token for the subject.
+   * Returns the HTTP method of the action.
    */
-  createToken(user: UserAccount, refreshToken?: {
-    sid?: string;
-    refresh_token?: string;
-    refresh_token_expires_in?: number;
-  }): Promise<AccessTokenResponse>;
-  refreshToken(refreshToken: string, accessToken?: string): Promise<{
-    tokens: AccessTokenResponse;
-    user: UserAccount;
-  }>;
-}
-interface AccessTokenResponse {
-  access_token: string;
-  token_type: string;
-  expires_in?: number;
-  issued_at: number;
-  refresh_token?: string;
-  refresh_token_expires_in?: number;
-  scope?: string;
-}
-//#endregion
-//#region ../alepha/src/security/descriptors/$serviceAccount.d.ts
-interface ServiceAccountDescriptor {
-  token: () => Promise<string>;
-}
-//#endregion
-//#region ../alepha/src/server/constants/routeMethods.d.ts
-declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
-type RouteMethod = (typeof routeMethods)[number];
-//#endregion
-//#region ../alepha/src/router/providers/RouterProvider.d.ts
-declare abstract class RouterProvider<T$1 extends Route = Route> {
-  protected routePathRegex: RegExp;
-  protected tree: Tree<T$1>;
-  protected cache: Map<string, RouteMatch<T$1>>;
-  match(path: string): RouteMatch<T$1>;
-  protected test(path: string): void;
-  protected push(route: T$1): void;
-  protected createRouteMatch(path: string): RouteMatch<T$1>;
-  protected mapParams(match: RouteMatch<T$1>): RouteMatch<T$1>;
-  protected createParts(path: string): string[];
-}
-interface RouteMatch<T$1 extends Route> {
-  route?: T$1;
-  params?: Record<string, string>;
-}
-interface Route {
-  path: string;
+  get method(): RouteMethod;
   /**
-   * Rename a param in the route.
-   * This is automatically filled when you have scenarios like:
-   * `/customers/:id` and `/customers/:userId/payments`
+   * Returns the path of the action.
    *
-   * In this case, `:id` will be renamed to `:userId` in the second route.
-   */
-  mapParams?: Record<string, string>;
-}
-interface Tree<T$1 extends Route> {
-  route?: T$1;
-  children: {
-    [key: string]: Tree<T$1>;
-  };
-  param?: {
-    route?: T$1;
-    name: string;
-    children: {
-      [key: string]: Tree<T$1>;
-    };
-  };
-  wildcard?: {
-    route: T$1;
-  };
-}
-//#endregion
-//#region ../alepha/src/server/helpers/ServerReply.d.ts
-/**
- * Helper for building server replies.
- */
-declare class ServerReply {
-  headers: Record<string, string> & {
-    "set-cookie"?: string[];
-  };
-  status?: number;
-  body?: any;
-  /**
-   * Redirect to a given URL with optional status code (default 302).
+   * Path is prefixed by `/api` by default.
    */
-  redirect(url: string, status?: number): void;
+  get path(): string;
+  get schema(): TConfig | undefined;
+  getBodyContentType(): string | undefined;
   /**
-   * Set the response status code.
+   * Call the action handler directly.
+   * There is no HTTP layer involved.
    */
-  setStatus(status: number): this;
+  run(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
   /**
-   * Set a response header.
+   * Works like `run`, but always fetches (http request) the route.
    */
-  setHeader(name: string, value: string): this;
+  fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
+}
+interface ActionPrimitiveFn<TConfig extends RequestConfigSchema> extends ActionPrimitive<TConfig> {
+  (config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
+}
+type ClientRequestEntry<TConfig extends RequestConfigSchema, T$1 = ClientRequestEntryContainer<TConfig>> = { [K in keyof T$1 as T$1[K] extends undefined ? never : K]: T$1[K] };
+type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
+  body: TConfig["body"] extends TObject ? Static<TConfig["body"]> : undefined;
+  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : undefined;
+  headers?: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : undefined;
+  query?: TConfig["query"] extends TObject ? Partial<Static<TConfig["query"]>> : undefined;
+};
+interface ClientRequestOptions extends FetchOptions {
   /**
-   * Set the response body.
+   * Standard request fetch options.
    */
-  setBody(body: any): this;
-}
-//#endregion
-//#region ../alepha/src/server/services/UserAgentParser.d.ts
-interface UserAgentInfo {
-  os: "Windows" | "Android" | "Ubuntu" | "MacOS" | "iOS" | "Linux" | "FreeBSD" | "OpenBSD" | "ChromeOS" | "BlackBerry" | "Symbian" | "Windows Phone";
-  browser: "Chrome" | "Firefox" | "Safari" | "Edge" | "Opera" | "Internet Explorer" | "Brave" | "Vivaldi" | "Samsung Browser" | "UC Browser" | "Yandex";
-  device: "MOBILE" | "DESKTOP" | "TABLET";
+  request?: RequestInit;
 }
+type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : any;
 /**
- * Simple User-Agent parser to detect OS, browser, and device type.
- * This parser is not exhaustive and may not cover all edge cases.
+ * Specific handler for server actions.
+ */
+type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerActionRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
+/**
+ * Server Action Request Interface
  *
- * Use result for non
+ * Can be extended with module augmentation to add custom properties (like `user` in Server Security).
+ *
+ * This is NOT Server Request, but a specific type for actions.
  */
-declare class UserAgentParser {
-  parse(userAgent?: string): UserAgentInfo;
+interface ServerActionRequest<TConfig extends RequestConfigSchema> extends ServerRequest<TConfig> {}
+//#endregion
+//#region ../alepha/src/server/primitives/$route.d.ts
+interface RoutePrimitiveOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {}
+declare class RoutePrimitive<TConfig extends RequestConfigSchema> extends Primitive<RoutePrimitiveOptions<TConfig>> {
+  protected readonly serverRouterProvider: ServerRouterProvider;
+  protected onInit(): void;
 }
 //#endregion
-//#region ../alepha/src/server/interfaces/ServerRequest.d.ts
-type TRequestBody = TObject | TString | TArray | TRecord | TStream;
-type TResponseBody = TObject | TString | TRecord | TFile | TArray | TStream | TVoid;
-interface RequestConfigSchema {
-  body?: TRequestBody;
-  params?: TObject;
-  query?: TObject;
-  headers?: TObject;
-  response?: TResponseBody;
+//#region ../alepha/src/server/providers/BunHttpServerProvider.d.ts
+declare const envSchema$8: alepha1672.TObject<{
+  SERVER_PORT: alepha1672.TInteger;
+  SERVER_HOST: alepha1672.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$8>> {}
 }
-interface ServerRequestConfig<TConfig extends RequestConfigSchema = RequestConfigSchema> {
-  body: TConfig["body"] extends TRequestBody ? Static<TConfig["body"]> : any;
-  headers: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : Record<string, string>;
-  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : Record<string, string>;
-  query: TConfig["query"] extends TObject ? Static<TConfig["query"]> : Record<string, any>;
+//#endregion
+//#region ../alepha/src/server/providers/NodeHttpServerProvider.d.ts
+declare const envSchema$7: alepha1672.TObject<{
+  SERVER_PORT: alepha1672.TInteger;
+  SERVER_HOST: alepha1672.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$7>> {}
 }
-type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
-interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
-  /**
-   * HTTP method used for this request.
-   */
-  method: RouteMethod;
-  /**
-   * Full request URL.
-   */
-  url: URL;
-  /**
-   * Unique request ID assigned to this request.
-   */
-  requestId: string;
-  /**
-   * Client IP address.
-   * Will parse `X-Forwarded-For` header if present.
-   */
-  ip?: string;
-  /**
-   * Value of the `Host` header sent by the client.
-   */
-  host?: string;
-  /**
-   * Browser user agent information.
-   * Information are not guaranteed to be accurate. Use with caution.
-   *
-   * @see {@link UserAgentParser}
-   */
-  userAgent: UserAgentInfo;
+//#endregion
+//#region ../alepha/src/server/index.d.ts
+declare module "alepha" {
+  interface State {
+    "alepha.node.server"?: Server;
+  }
+  interface Hooks {
+    "action:onRequest": {
+      action: ActionPrimitive<RequestConfigSchema>;
+      request: ServerRequest;
+      options: ClientRequestOptions;
+    };
+    "action:onResponse": {
+      action: ActionPrimitive<RequestConfigSchema>;
+      request: ServerRequest;
+      options: ClientRequestOptions;
+      response: any;
+    };
+    "server:onRequest": {
+      route: ServerRoute;
+      request: ServerRequest;
+    };
+    "server:onError": {
+      route: ServerRoute;
+      request: ServerRequest;
+      error: Error;
+    };
+    "server:onSend": {
+      route: ServerRoute;
+      request: ServerRequest;
+    };
+    "server:onResponse": {
+      route: ServerRoute;
+      request: ServerRequest;
+      response: ServerResponse$1;
+    };
+    "client:onRequest": {
+      route: HttpAction;
+      config: ServerRequestConfigEntry;
+      options: ClientRequestOptions;
+      headers: Record<string, string>;
+      request: RequestInit;
+    };
+    "client:beforeFetch": {
+      url: string;
+      options: FetchOptions;
+      request: RequestInit;
+    };
+    "client:onError": {
+      route?: HttpAction;
+      error: HttpError;
+    };
+    "node:request": NodeRequestEvent;
+    "web:request": WebRequestEvent;
+  }
+}
+//#endregion
+//#region ../alepha/src/security/interfaces/UserAccountToken.d.ts
+/**
+ * Add contextual metadata to a user account info.
+ * E.g. UserAccountToken is a UserAccountInfo during a request.
+ */
+interface UserAccountToken extends UserAccount {
   /**
-   * Arbitrary metadata attached to the request. Can be used by middlewares to store information.
+   * Access token for the user.
    */
-  metadata: Record<string, any>;
+  token?: string;
   /**
-   * Reply object to be used to send response.
+   * Realm name of the user.
    */
-  reply: ServerReply;
+  realm?: string;
   /**
-   * The raw underlying request object (Web Request).
+   * Is user dedicated to his own resources for this scope ?
+   * Mostly, Admin is false and Customer is true.
    */
-  raw: ServerRawRequest;
+  ownership?: string | boolean;
 }
-interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
+//#endregion
+//#region ../alepha/src/security/schemas/permissionSchema.d.ts
+declare const permissionSchema: alepha1672.TObject<{
+  name: alepha1672.TString;
+  group: alepha1672.TOptional<alepha1672.TString>;
+  description: alepha1672.TOptional<alepha1672.TString>;
+  method: alepha1672.TOptional<alepha1672.TString>;
+  path: alepha1672.TOptional<alepha1672.TString>;
+}>;
+type Permission = Static<typeof permissionSchema>;
+//#endregion
+//#region ../alepha/src/security/schemas/roleSchema.d.ts
+declare const roleSchema: alepha1672.TObject<{
+  name: alepha1672.TString;
+  description: alepha1672.TOptional<alepha1672.TString>;
+  default: alepha1672.TOptional<alepha1672.TBoolean>;
+  permissions: alepha1672.TArray<alepha1672.TObject<{
+    name: alepha1672.TString;
+    ownership: alepha1672.TOptional<alepha1672.TBoolean>;
+    exclude: alepha1672.TOptional<alepha1672.TArray<alepha1672.TString>>;
+  }>>;
+}>;
+type Role = Static<typeof roleSchema>;
+//#endregion
+//#region ../alepha/src/security/providers/JwtProvider.d.ts
+/**
+ * Provides utilities for working with JSON Web Tokens (JWT).
+ */
+declare class JwtProvider {
+  protected readonly log: Logger;
+  protected readonly keystore: KeyLoaderHolder[];
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly encoder: TextEncoder;
   /**
-   * Handler function for this route.
+   * Adds a key loader to the embedded keystore.
+   *
+   * @param name
+   * @param secretKeyOrJwks
    */
-  handler: ServerHandler<TConfig>;
+  setKeyLoader(name: string, secretKeyOrJwks: string | JSONWebKeySet): void;
   /**
-   * HTTP method for this route.
+   * Retrieves the payload from a JSON Web Token (JWT).
+   *
+   * @param token - The JWT to extract the payload from.
+   *
+   * @return A Promise that resolves with the payload object from the token.
    */
-  method?: RouteMethod;
+  parse(token: string, keyName?: string, options?: JWTVerifyOptions): Promise<JwtParseResult>;
   /**
-   * Request/response schema for this route.
-   *
-   * Request schema contains:
-   * - body, for POST/PUT/PATCH requests
-   * - params, for URL parameters (e.g. /user/:id)
-   * - query, for URL query parameters (e.g. /user?id=123)
-   * - headers, for HTTP headers
+   * Creates a JWT token with the provided payload and secret key.
    *
-   * Response schema contains:
-   * - response
+   * @param payload - The payload to be encoded in the token.
+   * 	It should include the `realm_access` property which contains an array of roles.
+   * @param keyName - The name of the key to use when signing the token.
    *
-   * Response schema is used to validate and serialize the response sent by the handler.
+   * @returns The signed JWT token.
    */
-  schema?: TConfig;
+  create(payload: ExtendedJWTPayload, keyName?: string, signOptions?: JwtSignOptions): Promise<string>;
   /**
-   * @see ServerLoggerProvider
+   * Determines if the provided key is a secret key.
+   *
+   * @param key
+   * @protected
    */
-  silent?: boolean;
-}
-type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TResponseBody ? Static<TConfig["response"]> : ResponseBodyType;
-type ResponseKind = "json" | "text" | "void" | "file" | "any";
-type ResponseBodyType = string | Buffer | StreamLike | undefined | null | void;
-type ServerHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
-interface ServerResponse$1 {
-  body: string | Buffer | ArrayBuffer | Readable | ReadableStream;
-  headers: Record<string, string>;
-  status: number;
-}
-type ServerRouteRequestHandler = (request: ServerRequestData) => Promise<ServerResponse$1>;
-interface ServerRouteMatcher extends Route {
-  handler: ServerRouteRequestHandler;
+  protected isSecretKey(key: string): boolean;
 }
-interface ServerRequestData {
-  method: RouteMethod;
-  url: URL;
-  headers: Record<string, string>;
-  query: Record<string, string>;
-  params: Record<string, string>;
-  raw: ServerRawRequest;
+type KeyLoader = (protectedHeader?: JWSHeaderParameters, token?: FlattenedJWSInput) => Promise<CryptoKey | KeyObject>;
+interface KeyLoaderHolder {
+  name: string;
+  keyLoader: KeyLoader;
+  secretKey?: string;
 }
-interface ServerRawRequest {
-  node?: NodeRequestEvent;
-  web?: WebRequestEvent;
+interface JwtSignOptions {
+  header?: Partial<JWTHeaderParameters>;
 }
-interface NodeRequestEvent {
-  req: IncomingMessage;
-  res: ServerResponse;
+interface ExtendedJWTPayload extends JWTPayload {
+  sid?: string;
+  name?: string;
+  roles?: string[];
+  email?: string;
+  organizations?: string[];
+  realm_access?: {
+    roles: string[];
+  };
 }
-interface WebRequestEvent {
-  req: Request;
-  res?: Response;
+interface JwtParseResult {
+  keyName: string;
+  result: JWTVerifyResult<ExtendedJWTPayload>;
 }
 //#endregion
-//#region ../alepha/src/server/services/ServerRequestParser.d.ts
-declare class ServerRequestParser {
-  protected readonly alepha: Alepha;
-  protected readonly userAgentParser: UserAgentParser;
-  createServerRequest(rawRequest: ServerRequestData): ServerRequest;
-  getRequestId(request: ServerRequestData): string | undefined;
-  getRequestUserAgent(request: ServerRequestData): UserAgentInfo;
-  getRequestIp(request: ServerRequestData): string | undefined;
+//#region ../alepha/src/security/providers/SecurityProvider.d.ts
+declare const envSchema$6: alepha1672.TObject<{
+  APP_SECRET: alepha1672.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$6>> {}
 }
-//#endregion
-//#region ../alepha/src/server/providers/ServerTimingProvider.d.ts
-type TimingMap = Record<string, [number, number]>;
-declare class ServerTimingProvider {
+declare class SecurityProvider {
+  protected readonly UNKNOWN_USER_NAME = "Anonymous User";
+  protected readonly PERMISSION_REGEXP: RegExp;
+  protected readonly PERMISSION_REGEXP_WILDCARD: RegExp;
   protected readonly log: Logger;
-  protected readonly alepha: Alepha;
-  options: {
-    prefix: string;
-    disabled: boolean;
+  protected readonly jwt: JwtProvider;
+  protected readonly env: {
+    APP_SECRET: string;
   };
-  readonly onRequest: alepha1223.HookDescriptor<"server:onRequest">;
-  readonly onResponse: alepha1223.HookDescriptor<"server:onResponse">;
-  protected get handlerName(): string;
-  beginTiming(name: string): void;
-  endTiming(name: string): void;
-  protected setDuration(name: string, timing: TimingMap): void;
-}
-//#endregion
-//#region ../alepha/src/server/providers/ServerRouterProvider.d.ts
-/**
- * Main router for all routes on the server side.
- *
- * - $route => generic route
- * - $action => action route (for API calls)
- * - $page => React route (for SSR)
- */
-declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
-  protected readonly log: Logger;
-  protected readonly alepha: Alepha;
-  protected readonly routes: ServerRoute[];
-  protected readonly serverTimingProvider: ServerTimingProvider;
-  protected readonly serverRequestParser: ServerRequestParser;
-  /**
-   * Get all registered routes, optionally filtered by a pattern.
-   *
-   * Pattern accept simple wildcard '*' at the end.
-   * Example: '/api/*' will match all routes starting with '/api/' but '/api/' will match only that exact route.
-   */
-  getRoutes(pattern?: string): ServerRoute[];
-  createRoute<TConfig extends RequestConfigSchema = RequestConfigSchema>(route: ServerRoute<TConfig>): void;
-  protected getContextId(headers: Record<string, string>): string;
-  protected processRequest(request: ServerRequest, route: ServerRoute, responseKind: ResponseKind): Promise<{
-    status: number;
-    headers: Record<string, string> & {
-      "set-cookie"?: string[];
-    };
-    body: any;
-  }>;
-  protected runRouteHandler(route: ServerRoute, request: ServerRequest, responseKind: ResponseKind): Promise<void>;
-  serializeResponse(route: ServerRoute, reply: ServerReply, responseKind: ResponseKind): void;
-  protected getResponseType(schema?: RequestConfigSchema): ResponseKind;
-  protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
-  validateRequest(route: {
-    schema?: RequestConfigSchema;
-  }, request: ServerRequestConfig): void;
-}
-//#endregion
-//#region ../alepha/src/server/providers/ServerProvider.d.ts
-/**
- * Base server provider to handle incoming requests and route them.
- *
- * This is the default implementation for serverless environments.
- *
- * ServerProvider supports both Node.js HTTP requests and Web (Fetch API) requests.
- */
-declare class ServerProvider {
-  protected readonly log: Logger;
   protected readonly alepha: Alepha;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly router: ServerRouterProvider;
-  protected readonly internalServerErrorMessage = "Internal Server Error";
-  get hostname(): string;
+  get secretKey(): string;
   /**
-   * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
+   * The permissions configured for the security provider.
    */
-  protected readonly onNodeRequest: alepha1223.HookDescriptor<"node:request">;
+  protected readonly permissions: Permission[];
   /**
-   * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
+   * The realms configured for the security provider.
    */
-  protected readonly onWebRequest: alepha1223.HookDescriptor<"web:request">;
+  protected readonly realms: Realm[];
+  protected start: alepha1672.HookPrimitive<"start">;
   /**
-   * Handle Node.js HTTP request event.
+   * Adds a role to one or more realms.
    *
-   * Technically, we just convert Node.js request to Web Standard Request.
-   */
-  handleNodeRequest(nodeRequestEvent: NodeRequestEvent): Promise<void>;
-  /**
-   * Handle Web (Fetch API) request event.
+   * @param role
+   * @param realms
    */
-  handleWebRequest(ev: WebRequestEvent): Promise<void>;
+  createRole(role: Role, ...realms: string[]): Role;
   /**
-   * Helper for Vite development mode to let Vite handle (or not) 404.
+   * Adds a permission to the security provider.
+   *
+   * @param raw - The permission to add.
    */
-  protected isViteNotFound(url?: string, route?: Route, params?: Record<string, string>): boolean;
-}
-//#endregion
-//#region ../alepha/src/cache/providers/CacheProvider.d.ts
-/**
- * Cache provider interface.
- *
- * All methods are asynchronous and return promises.
- * Values are stored as Uint8Array.
- */
-declare abstract class CacheProvider {
+  createPermission(raw: Permission | string): Permission;
+  createRealm(realm: Realm): void;
   /**
-   * Get the value of a key.
+   * Updates the roles for a realm then synchronizes the user account provider if available.
    *
-   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
-   * @param key The key of the value to get.
+   * Only available when the app is started.
    *
-   * @return The value of the key, or undefined if the key does not exist.
+   * @param realm - The realm to update the roles for.
+   * @param roles - The roles to update.
    */
-  abstract get(name: string, key: string): Promise<Uint8Array | undefined>;
+  updateRealm(realm: string, roles: Role[]): Promise<void>;
   /**
-   * Set the string value of a key.
+   * Creates a user account from the provided payload.
    *
-   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
-   * @param key The key of the value to set.
-   * @param value The value to set.
-   * @param ttl The time-to-live of the key, in milliseconds.
+   * @param payload - The payload to create the user account from.
+   * @param [realmName] - The realm containing the roles. Default is all.
    *
-   * @return The value of the key.
+   * @returns The user info created from the payload.
    */
-  abstract set(name: string, key: string, value: Uint8Array, ttl?: number): Promise<Uint8Array>;
+  createUserFromPayload(payload: JWTPayload, realmName?: string): UserAccount;
   /**
-   * Remove the specified keys.
+   * Checks if the user has the specified permission.
    *
-   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
-   * @param keys The keys to delete.
+   * Bonus: we check also if the user has "ownership" flag.
+   *
+   * @param permissionLike - The permission to check for.
+   * @param roleEntries - The roles to check for the permission.
    */
-  abstract del(name: string, ...keys: string[]): Promise<void>;
-  abstract has(name: string, key: string): Promise<boolean>;
-  abstract keys(name: string, filter?: string): Promise<string[]>;
+  checkPermission(permissionLike: string | Permission, ...roleEntries: string[]): SecurityCheckResult;
   /**
-   * Remove all keys from all cache names.
+   * Creates a user account from the provided payload.
    */
-  abstract clear(): Promise<void>;
-}
-//#endregion
-//#region ../alepha/src/cache/descriptors/$cache.d.ts
-interface CacheDescriptorOptions<TReturn = any, TParameter extends any[] = any[]> {
+  createUserFromToken(headerOrToken?: string, options?: {
+    permission?: Permission | string;
+    realm?: string;
+    verify?: JWTVerifyOptions;
+  }): Promise<UserAccountToken>;
   /**
-   * The cache name. This is useful for invalidating multiple caches at once.
-   *
-   * Store key as `cache:$name:$key`.
+   * Checks if a user has a specific role.
    *
-   * @default Name of the key of the class.
+   * @param roleName - The role to check for.
+   * @param permission - The permission to check for.
+   * @returns True if the user has the role, false otherwise.
    */
-  name?: string;
+  can(roleName: string, permission: string | Permission): boolean;
   /**
-   * Function which returns cached data.
+   * Checks if a user has ownership of a specific permission.
    */
-  handler?: (...args: TParameter) => TReturn;
+  ownership(roleName: string, permission: string | Permission): string | boolean | undefined;
   /**
-   * The key generator for the cache.
-   * If not provided, the arguments will be json.stringify().
+   * Converts a permission object to a string.
+   *
+   * @param permission
    */
-  key?: (...args: TParameter) => string;
+  permissionToString(permission: Permission | string): string;
+  getRealms(): Realm[];
   /**
-   * The store provider for the cache.
-   * If not provided, the default store provider will be used.
+   * Retrieves the user account from the provided user ID.
+   *
+   * @param realm
    */
-  provider?: InstantiableClass<CacheProvider> | "memory";
+  getRoles(realm?: string): Role[];
   /**
-   * The time-to-live for the cache in seconds.
-   * Set 0 to skip expiration.
+   * Returns all permissions.
    *
-   * @default 300 (5 minutes).
+   * @param user - Filter permissions by user.
+   *
+   * @return An array containing all permissions.
    */
-  ttl?: DurationLike;
+  getPermissions(user?: {
+    roles?: Array<Role | string>;
+    realm?: string;
+  }): Permission[];
   /**
-   * If the cache is disabled.
+   * Retrieves the user ID from the provided payload object.
+   *
+   * @param payload - The payload object from which to extract the user ID.
+   * @return The user ID as a string.
    */
-  disabled?: boolean;
-}
-declare class CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> extends Descriptor<CacheDescriptorOptions<TReturn, TParameter>> {
-  protected readonly env: {
-    CACHE_ENABLED: boolean;
-    CACHE_DEFAULT_TTL: number;
-  };
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly provider: CacheProvider;
-  protected encoder: TextEncoder;
-  protected decoder: TextDecoder;
-  protected codes: {
-    BINARY: number;
-    JSON: number;
-    STRING: number;
-  };
-  get container(): string;
-  run(...args: TParameter): Promise<TReturn>;
-  key(...args: TParameter): string;
-  invalidate(...keys: string[]): Promise<void>;
-  set(key: string, value: TReturn, ttl?: DurationLike): Promise<void>;
-  get(key: string): Promise<TReturn | undefined>;
-  protected serialize<TReturn>(value: TReturn): Uint8Array;
-  protected deserialize<TReturn>(uint8Array: Uint8Array): Promise<TReturn>;
-  protected $provider(): CacheProvider;
-}
-interface CacheDescriptorFn<TReturn = any, TParameter extends any[] = any[]> extends CacheDescriptor<TReturn, TParameter> {
+  getIdFromPayload(payload: Record<string, any>): string;
+  getSessionIdFromPayload(payload: Record<string, any>): string | undefined;
   /**
-   * Run the cache descriptor with the provided arguments.
+   * Retrieves the roles from the provided payload object.
+   * @param payload - The payload object from which to extract the roles.
+   * @return An array of role strings.
    */
-  (...args: TParameter): Promise<TReturn>;
-}
-//#endregion
-//#region ../alepha/src/server/services/HttpClient.d.ts
-declare class HttpClient {
-  protected readonly log: Logger;
-  protected readonly alepha: Alepha;
-  readonly cache: CacheDescriptorFn<HttpClientCache, any[]>;
-  protected readonly pendingRequests: HttpClientPendingRequests;
-  fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
-  fetch<T$1 extends TSchema>(url: string, request?: RequestInitWithOptions<T$1>): Promise<FetchResponse<Static<T$1>>>;
-  protected url(host: string, action: HttpAction, args: ServerRequestConfigEntry): string;
-  protected body(init: RequestInit, headers: Record<string, string>, action: HttpAction, args?: ServerRequestConfigEntry): Promise<void>;
-  protected responseData(response: Response, options: FetchOptions): Promise<any>;
-  protected isMaybeFile(response: Response): boolean;
-  protected createFileLike(response: Response, defaultFileName?: string): FileLike;
-  pathVariables(url: string, action: {
-    schema?: {
-      params?: TObject;
-    };
-  }, args?: ServerRequestConfigEntry): string;
-  queryParams(url: string, action: {
-    schema?: {
-      query?: TObject;
-    };
-  }, args?: ServerRequestConfigEntry): string;
-}
-interface FetchOptions<T$1 extends TSchema = TSchema> {
+  getRolesFromPayload(payload: Record<string, any>): string[];
+  getPictureFromPayload(payload: Record<string, any>): string | undefined;
+  getUsernameFromPayload(payload: Record<string, any>): string | undefined;
+  getEmailFromPayload(payload: Record<string, any>): string | undefined;
   /**
-   * Key to identify the request in the pending requests.
+   * Returns the name from the given payload.
+   *
+   * @param payload - The payload object.
+   * @returns The name extracted from the payload, or an empty string if the payload is falsy or no name is found.
    */
-  key?: string;
+  getNameFromPayload(payload: Record<string, any>): string;
+  getOrganizationsFromPayload(payload: Record<string, any>): string[] | undefined;
+}
+/**
+ * A realm definition.
+ */
+interface Realm {
+  name: string;
+  roles: Role[];
   /**
-   * The schema to validate the response against.
+   * The secret key for the realm.
+   *
+   * Can be also a JWKS URL.
    */
-  schema?: {
-    response?: T$1;
-  };
+  secret?: string | JSONWebKeySet | (() => string);
   /**
-   * Built-in cache options.
+   * Create the user account info based on the raw JWT payload.
+   * By default, SecurityProvider has his own implementation, but this method allow to override it.
    */
-  localCache?: boolean | number | DurationLike;
-}
-type RequestInitWithOptions<T$1 extends TSchema = TSchema> = RequestInit & FetchOptions<T$1>;
-interface FetchResponse<T$1 = any> {
-  data: T$1;
-  status: number;
-  statusText: string;
-  headers: Headers;
-  raw?: Response;
-}
-type HttpClientPendingRequests = Record<string, Promise<any> | undefined>;
-interface HttpClientCache {
-  data: any;
-  etag?: string;
-}
-interface FetchActionArgs {
-  action: HttpAction;
-  host?: string;
-  config?: ServerRequestConfigEntry;
-  options?: ClientRequestOptions;
+  profile?: (raw: Record<string, any>) => UserAccount;
 }
-interface HttpAction {
-  method?: string;
-  prefix?: string;
-  path: string;
-  requestBodyType?: string;
-  schema?: {
-    params?: TObject;
-    query?: TObject;
-    body?: TRequestBody;
-    response?: TResponseBody;
-  };
+interface SecurityCheckResult {
+  isAuthorized: boolean;
+  ownership: string | boolean | undefined;
 }
 //#endregion
-//#region ../alepha/src/server/descriptors/$action.d.ts
-interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
+//#region ../alepha/src/security/primitives/$realm.d.ts
+type RealmPrimitiveOptions = {
   /**
-   * Name of the action.
-   *
-   * - It will be used to generate the route path if `path` is not provided.
-   * - It will be used to generate the permission name if `security` is enabled.
+   * Define the realm name.
+   * If not provided, it will use the property key.
    */
   name?: string;
   /**
-   * Group actions together.
-   *
-   * - If not provided, the service name containing the route will be used.
-   * - It will be used as Tag for documentation purposes.
-   * - It will be used for permission name generation if `security` is enabled.
-   *
-   * @example
-   * ```ts
-   * // group = "MyController"
-   * class MyController {
-   * 	hello = $action({ handler: () => "Hello World" });
-   * }
-   *
-   * // group = "users"
-   * class MyOtherController {
-   *   group = "users";
-   *   a1 = $action({ handler: () => "Action 1", group: this.group });
-   *   a2 = $action({ handler: () => "Action 2", group: this.group });
-   * }
-   * ```
-   */
-  group?: string;
-  /**
-   * Pathname of the route. If not provided, property key is used.
+   * Short description about the realm.
    */
-  path?: string;
+  description?: string;
   /**
-   * The route method.
-   *
-   * - If not provided, it will be set to "GET" by default.
-   * - If not provider and a body is provided, it will be set to "POST".
-   *
-   * Wildcard methods are not supported for now. (e.g. "ALL", "ANY", etc.)
+   * All roles available in the realm. Role is a string (role name) or a Role object (embedded role).
    */
-  method?: RouteMethod;
+  roles?: Array<string | Role>;
   /**
-   * The config schema of the route.
-   * - body: The request body schema.
-   * - params: Path variables schema.
-   * - query: The request query-params schema.
-   * - response: The response schema.
+   * Realm settings.
    */
-  schema?: TConfig;
+  settings?: RealmSettings;
   /**
-   * A short description of the action. Used for documentation purposes.
+   * Parse the JWT payload to create a user account info.
    */
-  description?: string;
+  profile?: (jwtPayload: Record<string, any>) => UserAccount;
+} & (RealmInternal | RealmExternal);
+interface RealmSettings {
+  accessToken?: {
+    /**
+     * Lifetime of the access token.
+     * @default 15 minutes
+     */
+    expiration?: DurationLike;
+  };
+  refreshToken?: {
+    /**
+     * Lifetime of the refresh token.
+     * @default 30 days
+     */
+    expiration?: DurationLike;
+  };
+  onCreateSession?: (user: UserAccount, config: {
+    expiresIn: number;
+  }) => Promise<{
+    refreshToken: string;
+    sessionId?: string;
+  }>;
+  onRefreshSession?: (refreshToken: string) => Promise<{
+    user: UserAccount;
+    expiresIn: number;
+    sessionId?: string;
+  }>;
+  onDeleteSession?: (refreshToken: string) => Promise<void>;
+}
+type RealmInternal = {
   /**
-   * Disable the route. Useful with env variables do disable one specific route.
-   * Route won't be available in the API but can still be called locally!
+   * Internal secret to sign JWT tokens and verify them.
    */
-  disabled?: boolean;
+  secret: string;
+};
+interface RealmExternal {
   /**
-   * Main route handler. This is where the route logic is implemented.
+   * URL to the JWKS (JSON Web Key Set) to verify JWT tokens from external providers.
    */
-  handler: ServerActionHandler<TConfig>;
+  jwks: (() => string) | JSONWebKeySet;
 }
-declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig>> {
+declare class RealmPrimitive extends Primitive<RealmPrimitiveOptions> {
+  protected readonly securityProvider: SecurityProvider;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly jwt: JwtProvider;
   protected readonly log: Logger;
-  protected readonly env: {
-    SERVER_API_PREFIX: string;
-  };
-  protected readonly httpClient: HttpClient;
-  protected readonly serverProvider: ServerProvider;
-  protected readonly serverRouterProvider: ServerRouterProvider;
-  protected onInit(): void;
-  get prefix(): string;
-  get route(): ServerRoute;
-  /**
-   * Returns the name of the action.
-   */
   get name(): string;
+  get accessTokenExpiration(): Duration;
+  get refreshTokenExpiration(): Duration;
+  protected onInit(): void;
   /**
-   * Returns the group of the action. (e.g. "orders", "admin", etc.)
-   */
-  get group(): string;
-  /**
-   * Returns the HTTP method of the action.
-   */
-  get method(): RouteMethod;
-  /**
-   * Returns the path of the action.
-   *
-   * Path is prefixed by `/api` by default.
+   * Get all roles in the realm.
    */
-  get path(): string;
-  get schema(): TConfig | undefined;
-  getBodyContentType(): string | undefined;
+  getRoles(): Role[];
   /**
-   * Call the action handler directly.
-   * There is no HTTP layer involved.
+   * Set all roles in the realm.
    */
-  run(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
+  setRoles(roles: Role[]): Promise<void>;
   /**
-   * Works like `run`, but always fetches (http request) the route.
+   * Get a role by name, throws an error if not found.
    */
-  fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
-}
-interface ActionDescriptorFn<TConfig extends RequestConfigSchema> extends ActionDescriptor<TConfig> {
-  (config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
-}
-type ClientRequestEntry<TConfig extends RequestConfigSchema, T$1 = ClientRequestEntryContainer<TConfig>> = { [K in keyof T$1 as T$1[K] extends undefined ? never : K]: T$1[K] };
-type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
-  body: TConfig["body"] extends TObject ? Static<TConfig["body"]> : undefined;
-  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : undefined;
-  headers?: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : undefined;
-  query?: TConfig["query"] extends TObject ? Partial<Static<TConfig["query"]>> : undefined;
-};
-interface ClientRequestOptions extends FetchOptions {
+  getRoleByName(name: string): Role;
+  parseToken(token: string): Promise<JWTPayload>;
   /**
-   * Standard request fetch options.
+   * Create a token for the subject.
    */
-  request?: RequestInit;
-}
-type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : any;
-/**
- * Specific handler for server actions.
- */
-type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerActionRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
-/**
- * Server Action Request Interface
- *
- * Can be extended with module augmentation to add custom properties (like `user` in Server Security).
- *
- * This is NOT Server Request, but a specific type for actions.
- */
-interface ServerActionRequest<TConfig extends RequestConfigSchema> extends ServerRequest<TConfig> {}
-//#endregion
-//#region ../alepha/src/server/schemas/errorSchema.d.ts
-declare const errorSchema: alepha1223.TObject<{
-  error: alepha1223.TString;
-  status: alepha1223.TInteger;
-  message: alepha1223.TString;
-  details: alepha1223.TOptional<alepha1223.TString>;
-  requestId: alepha1223.TOptional<alepha1223.TString>;
-  cause: alepha1223.TOptional<alepha1223.TObject<{
-    name: alepha1223.TString;
-    message: alepha1223.TString;
-  }>>;
-}>;
-type ErrorSchema = Static<typeof errorSchema>;
-//#endregion
-//#region ../alepha/src/server/errors/HttpError.d.ts
-declare class HttpError extends AlephaError {
-  name: string;
-  static is: (error: unknown, status?: number) => error is HttpErrorLike;
-  static toJSON(error: HttpError): ErrorSchema;
-  readonly error: string;
-  readonly status: number;
-  readonly requestId?: string;
-  readonly details?: string;
-  readonly reason?: {
-    name: string;
-    message: string;
-  };
-  constructor(options: Partial<ErrorSchema>, cause?: unknown);
-}
-interface HttpErrorLike extends Error {
-  status: number;
-}
-//#endregion
-//#region ../alepha/src/server/descriptors/$route.d.ts
-interface RouteDescriptorOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {}
-declare class RouteDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<RouteDescriptorOptions<TConfig>> {
-  protected readonly serverRouterProvider: ServerRouterProvider;
-  protected onInit(): void;
-}
-//#endregion
-//#region ../alepha/src/server/providers/BunHttpServerProvider.d.ts
-declare const envSchema$7: alepha1223.TObject<{
-  SERVER_PORT: alepha1223.TInteger;
-  SERVER_HOST: alepha1223.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$7>> {}
+  createToken(user: UserAccount, refreshToken?: {
+    sid?: string;
+    refresh_token?: string;
+    refresh_token_expires_in?: number;
+  }): Promise<AccessTokenResponse>;
+  refreshToken(refreshToken: string, accessToken?: string): Promise<{
+    tokens: AccessTokenResponse;
+    user: UserAccount;
+  }>;
 }
-//#endregion
-//#region ../alepha/src/server/providers/NodeHttpServerProvider.d.ts
-declare const envSchema$6: alepha1223.TObject<{
-  SERVER_PORT: alepha1223.TInteger;
-  SERVER_HOST: alepha1223.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$6>> {}
+interface AccessTokenResponse {
+  access_token: string;
+  token_type: string;
+  expires_in?: number;
+  issued_at: number;
+  refresh_token?: string;
+  refresh_token_expires_in?: number;
+  scope?: string;
 }
 //#endregion
-//#region ../alepha/src/server/index.d.ts
-declare module "alepha" {
-  interface State {
-    "alepha.node.server"?: Server;
-  }
-  interface Hooks {
-    "action:onRequest": {
-      action: ActionDescriptor<RequestConfigSchema>;
-      request: ServerRequest;
-      options: ClientRequestOptions;
-    };
-    "action:onResponse": {
-      action: ActionDescriptor<RequestConfigSchema>;
-      request: ServerRequest;
-      options: ClientRequestOptions;
-      response: any;
-    };
-    "server:onRequest": {
-      route: ServerRoute;
-      request: ServerRequest;
-    };
-    "server:onError": {
-      route: ServerRoute;
-      request: ServerRequest;
-      error: Error;
-    };
-    "server:onSend": {
-      route: ServerRoute;
-      request: ServerRequest;
-    };
-    "server:onResponse": {
-      route: ServerRoute;
-      request: ServerRequest;
-      response: ServerResponse$1;
-    };
-    "client:onRequest": {
-      route: HttpAction;
-      config: ServerRequestConfigEntry;
-      options: ClientRequestOptions;
-      headers: Record<string, string>;
-      request: RequestInit;
-    };
-    "client:beforeFetch": {
-      url: string;
-      options: FetchOptions;
-      request: RequestInit;
-    };
-    "client:onError": {
-      route?: HttpAction;
-      error: HttpError;
-    };
-    "node:request": NodeRequestEvent;
-    "web:request": WebRequestEvent;
-  }
+//#region ../alepha/src/security/primitives/$serviceAccount.d.ts
+interface ServiceAccountPrimitive {
+  token: () => Promise<string>;
 }
 //#endregion
 //#region ../alepha/src/security/providers/CryptoProvider.d.ts
@@ -1397,7 +1393,7 @@ declare module "alepha" {
 /**
  * Provides comprehensive authentication and authorization capabilities with JWT tokens, role-based access control, and user management.
  *
- * The security module enables building secure applications using descriptors like `$realm`, `$role`, and `$permission`
+ * The security module enables building secure applications using primitives like `$realm`, `$role`, and `$permission`
  * on class properties. It offers JWT-based authentication, fine-grained permissions, service accounts, and seamless
  * integration with various authentication providers and user management systems.
  *
@@ -1472,23 +1468,23 @@ declare module "alepha/server" {
  */
 //#endregion
 //#region ../alepha/src/server-links/schemas/apiLinksResponseSchema.d.ts
-declare const apiLinkSchema: alepha1223.TObject<{
-  name: alepha1223.TString;
-  group: alepha1223.TOptional<alepha1223.TString>;
-  path: alepha1223.TString;
-  method: alepha1223.TOptional<alepha1223.TString>;
-  requestBodyType: alepha1223.TOptional<alepha1223.TString>;
-  service: alepha1223.TOptional<alepha1223.TString>;
+declare const apiLinkSchema: alepha1672.TObject<{
+  name: alepha1672.TString;
+  group: alepha1672.TOptional<alepha1672.TString>;
+  path: alepha1672.TString;
+  method: alepha1672.TOptional<alepha1672.TString>;
+  requestBodyType: alepha1672.TOptional<alepha1672.TString>;
+  service: alepha1672.TOptional<alepha1672.TString>;
 }>;
-declare const apiLinksResponseSchema: alepha1223.TObject<{
-  prefix: alepha1223.TOptional<alepha1223.TString>;
-  links: alepha1223.TArray<alepha1223.TObject<{
-    name: alepha1223.TString;
-    group: alepha1223.TOptional<alepha1223.TString>;
-    path: alepha1223.TString;
-    method: alepha1223.TOptional<alepha1223.TString>;
-    requestBodyType: alepha1223.TOptional<alepha1223.TString>;
-    service: alepha1223.TOptional<alepha1223.TString>;
+declare const apiLinksResponseSchema: alepha1672.TObject<{
+  prefix: alepha1672.TOptional<alepha1672.TString>;
+  links: alepha1672.TArray<alepha1672.TObject<{
+    name: alepha1672.TString;
+    group: alepha1672.TOptional<alepha1672.TString>;
+    path: alepha1672.TString;
+    method: alepha1672.TOptional<alepha1672.TString>;
+    requestBodyType: alepha1672.TOptional<alepha1672.TString>;
+    service: alepha1672.TOptional<alepha1672.TString>;
   }>>;
 }>;
 type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
@@ -1555,14 +1551,14 @@ interface ClientScope {
   service?: string;
   hostname?: string;
 }
-type HttpVirtualClient<T$1> = { [K in keyof T$1 as T$1[K] extends ActionDescriptor<RequestConfigSchema> ? K : never]: T$1[K] extends ActionDescriptor<infer Schema> ? VirtualAction<Schema> : never };
-interface VirtualAction<T$1 extends RequestConfigSchema> extends Pick<ActionDescriptor<T$1>, "name" | "run" | "fetch"> {
+type HttpVirtualClient<T$1> = { [K in keyof T$1 as T$1[K] extends ActionPrimitive<RequestConfigSchema> ? K : never]: T$1[K] extends ActionPrimitive<infer Schema> ? VirtualAction<Schema> : never };
+interface VirtualAction<T$1 extends RequestConfigSchema> extends Pick<ActionPrimitive<T$1>, "name" | "run" | "fetch"> {
   (config?: ClientRequestEntry<T$1>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<T$1>>;
   can: () => boolean;
 }
 //#endregion
-//#region ../alepha/src/server-proxy/descriptors/$proxy.d.ts
-type ProxyDescriptorOptions = {
+//#region ../alepha/src/server-proxy/primitives/$proxy.d.ts
+type ProxyPrimitiveOptions = {
   /**
    * Path pattern to match for proxying requests.
    *
@@ -1684,14 +1680,14 @@ declare class ServerProxyProvider {
   protected readonly log: Logger;
   protected readonly routerProvider: ServerRouterProvider;
   protected readonly alepha: Alepha;
-  protected readonly configure: alepha1223.HookDescriptor<"configure">;
-  createProxy(options: ProxyDescriptorOptions): void;
-  createProxyHandler(target: string, options: Omit<ProxyDescriptorOptions, "path">): ServerHandler;
+  protected readonly configure: alepha1672.HookPrimitive<"configure">;
+  createProxy(options: ProxyPrimitiveOptions): void;
+  createProxyHandler(target: string, options: Omit<ProxyPrimitiveOptions, "path">): ServerHandler;
   private getRawRequestBody;
 }
 //#endregion
-//#region ../alepha/src/server-links/descriptors/$remote.d.ts
-interface RemoteDescriptorOptions {
+//#region ../alepha/src/server-links/primitives/$remote.d.ts
+interface RemotePrimitiveOptions {
   /**
    * The URL of the remote service.
    * You can use a function to generate the URL dynamically.
@@ -1723,7 +1719,7 @@ interface RemoteDescriptorOptions {
    * If true, all methods of the remote service will be exposed as actions in this context.
    * > Note: Proxy will never use the service account, it just... proxies the request.
    */
-  proxy?: boolean | Partial<ProxyDescriptorOptions & {
+  proxy?: boolean | Partial<ProxyPrimitiveOptions & {
     /**
      * If true, the remote service won't be available internally, only through the proxy.
      */
@@ -1733,9 +1729,9 @@ interface RemoteDescriptorOptions {
    * For communication between the server and the remote service with a security layer.
    * This will be used for internal communication and will not be exposed to the client.
    */
-  serviceAccount?: ServiceAccountDescriptor;
+  serviceAccount?: ServiceAccountPrimitive;
 }
-declare class RemoteDescriptor extends Descriptor<RemoteDescriptorOptions> {
+declare class RemotePrimitive extends Primitive<RemotePrimitiveOptions> {
   get name(): string;
 }
 //#endregion
@@ -1826,8 +1822,8 @@ declare class RetryProvider {
   protected calculateBackoff(attempt: number, options?: number | RetryBackoffOptions): number;
 }
 //#endregion
-//#region ../alepha/src/retry/descriptors/$retry.d.ts
-interface RetryDescriptorOptions<T$1 extends (...args: any[]) => any> {
+//#region ../alepha/src/retry/primitives/$retry.d.ts
+interface RetryPrimitiveOptions<T$1 extends (...args: any[]) => any> {
   /**
    * The function to retry.
    */
@@ -1867,18 +1863,18 @@ interface RetryDescriptorOptions<T$1 extends (...args: any[]) => any> {
    */
   signal?: AbortSignal;
 }
-declare class RetryDescriptor<T$1 extends (...args: any[]) => any> extends Descriptor<RetryDescriptorOptions<T$1>> {
+declare class RetryPrimitive<T$1 extends (...args: any[]) => any> extends Primitive<RetryPrimitiveOptions<T$1>> {
   protected readonly retryProvider: RetryProvider;
-  protected appAbortController: AbortController;
-  constructor(args: DescriptorArgs<RetryDescriptorOptions<T$1>>);
+  protected appAbortController?: AbortController;
+  constructor(args: PrimitiveArgs<RetryPrimitiveOptions<T$1>>);
   run(...args: Parameters<T$1>): Promise<ReturnType<T$1>>;
 }
-interface RetryDescriptorFn<T$1 extends (...args: any[]) => any> extends RetryDescriptor<T$1> {
+interface RetryPrimitiveFn<T$1 extends (...args: any[]) => any> extends RetryPrimitive<T$1> {
   (...args: Parameters<T$1>): Promise<ReturnType<T$1>>;
 }
 //#endregion
-//#region ../alepha/src/server-links/providers/RemoteDescriptorProvider.d.ts
-declare class RemoteDescriptorProvider {
+//#region ../alepha/src/server-links/providers/RemotePrimitiveProvider.d.ts
+declare class RemotePrimitiveProvider {
   protected readonly env: {
     SERVER_API_PREFIX: string;
   };
@@ -1888,10 +1884,10 @@ declare class RemoteDescriptorProvider {
   protected readonly remotes: Array<ServerRemote>;
   protected readonly log: Logger;
   getRemotes(): ServerRemote[];
-  readonly configure: alepha1223.HookDescriptor<"configure">;
-  readonly start: alepha1223.HookDescriptor<"start">;
-  registerRemote(value: RemoteDescriptor): Promise<void>;
-  protected readonly fetchLinks: RetryDescriptorFn<(opts: FetchLinksOptions) => Promise<ApiLinksResponse>>;
+  readonly configure: alepha1672.HookPrimitive<"configure">;
+  readonly start: alepha1672.HookPrimitive<"start">;
+  registerRemote(value: RemotePrimitive): Promise<void>;
+  protected readonly fetchLinks: RetryPrimitiveFn<(opts: FetchLinksOptions) => Promise<ApiLinksResponse>>;
 }
 interface FetchLinksOptions {
   /**
@@ -1940,7 +1936,7 @@ interface ServerRemote {
   /**
    * Force a default access token provider when not provided.
    */
-  serviceAccount?: ServiceAccountDescriptor;
+  serviceAccount?: ServiceAccountPrimitive;
   /**
    * Prefix for the remote service links.
    */
@@ -1954,25 +1950,25 @@ declare class ServerLinksProvider {
   };
   protected readonly alepha: Alepha;
   protected readonly linkProvider: LinkProvider;
-  protected readonly remoteProvider: RemoteDescriptorProvider;
+  protected readonly remoteProvider: RemotePrimitiveProvider;
   protected readonly serverTimingProvider: ServerTimingProvider;
   get prefix(): string;
-  readonly onRoute: alepha1223.HookDescriptor<"configure">;
+  readonly onRoute: alepha1672.HookPrimitive<"configure">;
   /**
    * First API - Get all API links for the user.
    *
    * This is based on the user's permissions.
    */
-  readonly links: RouteDescriptor<{
-    response: alepha1223.TObject<{
-      prefix: alepha1223.TOptional<alepha1223.TString>;
-      links: alepha1223.TArray<alepha1223.TObject<{
-        name: alepha1223.TString;
-        group: alepha1223.TOptional<alepha1223.TString>;
-        path: alepha1223.TString;
-        method: alepha1223.TOptional<alepha1223.TString>;
-        requestBodyType: alepha1223.TOptional<alepha1223.TString>;
-        service: alepha1223.TOptional<alepha1223.TString>;
+  readonly links: RoutePrimitive<{
+    response: alepha1672.TObject<{
+      prefix: alepha1672.TOptional<alepha1672.TString>;
+      links: alepha1672.TArray<alepha1672.TObject<{
+        name: alepha1672.TString;
+        group: alepha1672.TOptional<alepha1672.TString>;
+        path: alepha1672.TString;
+        method: alepha1672.TOptional<alepha1672.TString>;
+        requestBodyType: alepha1672.TOptional<alepha1672.TString>;
+        service: alepha1672.TOptional<alepha1672.TString>;
       }>>;
     }>;
   }>;
@@ -1982,11 +1978,11 @@ declare class ServerLinksProvider {
    * Note: Body/Response schema are not included in `links` API because it's TOO BIG.
    * I mean for 150+ links, you got 50ms of serialization time.
    */
-  readonly schema: RouteDescriptor<{
-    params: alepha1223.TObject<{
-      name: alepha1223.TString;
+  readonly schema: RoutePrimitive<{
+    params: alepha1672.TObject<{
+      name: alepha1672.TString;
     }>;
-    response: alepha1223.TRecord<string, alepha1223.TAny>;
+    response: alepha1672.TRecord<string, alepha1672.TAny>;
   }>;
   getSchemaByName(name: string, options?: GetApiLinksOptions): Promise<RequestConfigSchema>;
   /**
@@ -2015,7 +2011,7 @@ declare module "alepha" {
 /**
  * Provides server-side link management and remote capabilities for client-server interactions.
  *
- * The server-links module enables declarative link definitions using `$remote` and `$client` descriptors,
+ * The server-links module enables declarative link definitions using `$remote` and `$client` primitives,
  * facilitating seamless API endpoint management and client-server communication. It integrates with server
  * security features to ensure safe and controlled access to resources.
  *
@@ -2036,7 +2032,7 @@ declare module "alepha/server" {
      */
     cache?: ServerRouteCache;
   }
-  interface ActionDescriptor<TConfig extends RequestConfigSchema> {
+  interface ActionPrimitive<TConfig extends RequestConfigSchema> {
     invalidate: () => Promise<void>;
   }
 }
@@ -2055,11 +2051,11 @@ boolean
   /**
    * If true, enables storing cached responses. (in-memory, Redis, @see alepha/cache for other providers)
    * If a DurationLike is provided, it will be used as the TTL for the cache.
-   * If CacheDescriptorOptions is provided, it will be used to configure the cache storage.
+   * If CachePrimitiveOptions is provided, it will be used to configure the cache storage.
    *
    * @default false
    */
-  store?: true | DurationLike | CacheDescriptorOptions;
+  store?: true | DurationLike | CachePrimitiveOptions;
   /**
    * If true, enables ETag support for the cached responses.
    */
@@ -2139,13 +2135,13 @@ declare class Redirection extends Error {
 }
 //#endregion
 //#region ../react/src/core/providers/ReactPageProvider.d.ts
-declare const envSchema$5: alepha1223.TObject<{
-  REACT_STRICT_MODE: alepha1223.TBoolean;
+declare const envSchema$5: alepha1672.TObject<{
+  REACT_STRICT_MODE: alepha1672.TBoolean;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$5>> {}
 }
-interface PageRouteEntry extends Omit<PageDescriptorOptions, "children" | "parent"> {
+interface PageRouteEntry extends Omit<PagePrimitiveOptions, "children" | "parent"> {
   children?: PageRouteEntry[];
 }
 interface PageRoute extends PageRouteEntry {
@@ -2197,25 +2193,22 @@ interface ReactRouterState {
    */
   meta: Record<string, any>;
 }
-interface TransitionOptions {
-  previous?: PreviousLayerData[];
-}
 //#endregion
 //#region ../react/src/core/services/ReactPageService.d.ts
 declare class ReactPageService {
-  fetch(pathname: string, options?: PageDescriptorRenderOptions): Promise<{
+  fetch(pathname: string, options?: PagePrimitiveRenderOptions): Promise<{
     html: string;
     response: Response;
   }>;
-  render(name: string, options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
+  render(name: string, options?: PagePrimitiveRenderOptions): Promise<PagePrimitiveRenderResult>;
 }
 //#endregion
-//#region ../react/src/core/descriptors/$page.d.ts
-interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
+//#region ../react/src/core/primitives/$page.d.ts
+interface PagePrimitiveOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
   /**
    * Identifier name for the page. Must be unique.
    *
-   * @default Descriptor key
+   * @default Primitive key
    */
   name?: string;
   /**
@@ -2267,11 +2260,11 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
    * Attach child pages to create nested routes.
    * This will make the page a parent route.
    */
-  children?: Array<PageDescriptor> | (() => Array<PageDescriptor>);
+  children?: Array<PagePrimitive> | (() => Array<PagePrimitive>);
   /**
    * Define a parent page for nested routing.
    */
-  parent?: PageDescriptor<PageConfigSchema, TPropsParent, any>;
+  parent?: PagePrimitive<PageConfigSchema, TPropsParent, any>;
   can?: () => boolean;
   /**
    * Catch any error from the `resolve` function or during `rendering`.
@@ -2381,7 +2374,7 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
   animation?: PageAnimation;
 }
 type ErrorHandler = (error: Error, state: ReactRouterState) => ReactNode | Redirection | undefined;
-declare class PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Descriptor<PageDescriptorOptions<TConfig, TProps, TPropsParent>> {
+declare class PagePrimitive<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Primitive<PagePrimitiveOptions<TConfig, TProps, TPropsParent>> {
   protected readonly reactPageService: ReactPageService;
   protected onInit(): void;
   get name(): string;
@@ -2391,8 +2384,8 @@ declare class PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema
    * This will render the page (HTML layout included or not) and return the HTML + context.
    * Only valid for server-side rendering, it will throw an error if called on the client-side.
    */
-  render(options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
-  fetch(options?: PageDescriptorRenderOptions): Promise<{
+  render(options?: PagePrimitiveRenderOptions): Promise<PagePrimitiveRenderResult>;
+  fetch(options?: PagePrimitiveRenderOptions): Promise<{
     html: string;
     response: Response;
   }>;
@@ -2405,7 +2398,7 @@ interface PageConfigSchema {
 }
 type TPropsDefault = any;
 type TPropsParentDefault = {};
-interface PageDescriptorRenderOptions {
+interface PagePrimitiveRenderOptions {
   params?: Record<string, string>;
   query?: Record<string, string>;
   /**
@@ -2417,7 +2410,7 @@ interface PageDescriptorRenderOptions {
   html?: boolean;
   hydration?: boolean;
 }
-interface PageDescriptorRenderResult {
+interface PagePrimitiveRenderResult {
   html: string;
   state: ReactRouterState;
   redirect?: string;
@@ -2440,8 +2433,8 @@ type CssAnimation = {
 };
 //#endregion
 //#region ../react/src/core/providers/ReactBrowserProvider.d.ts
-declare const envSchema$4: alepha1223.TObject<{
-  REACT_ROOT_ID: alepha1223.TString;
+declare const envSchema$4: alepha1672.TObject<{
+  REACT_ROOT_ID: alepha1672.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$4>> {}
@@ -2449,8 +2442,8 @@ declare module "alepha" {
 /**
  * React browser renderer configuration atom
  */
-declare const reactBrowserOptions: alepha1223.Atom<alepha1223.TObject<{
-  scrollRestoration: alepha1223.TUnsafe<"top" | "manual">;
+declare const reactBrowserOptions: alepha1672.Atom<alepha1672.TObject<{
+  scrollRestoration: alepha1672.TUnsafe<"top" | "manual">;
 }>, "alepha.react.browser.options">;
 type ReactBrowserRendererOptions = Static<typeof reactBrowserOptions.schema>;
 declare module "alepha" {
@@ -2458,64 +2451,12 @@ declare module "alepha" {
     [reactBrowserOptions.key]: ReactBrowserRendererOptions;
   }
 }
-interface RouterGoOptions {
-  replace?: boolean;
-  match?: TransitionOptions;
-  params?: Record<string, string>;
-  query?: Record<string, string>;
-  meta?: Record<string, any>;
-  /**
-   * Recreate the whole page, ignoring the current state.
-   */
-  force?: boolean;
-}
 type ReactHydrationState = {
   layers?: Array<PreviousLayerData>;
 } & {
   [key: string]: any;
 };
 //#endregion
-//#region ../react/src/core/hooks/useAction.d.ts
-interface UseActionReturn<Args extends any[], Result> {
-  /**
-   * Execute the action with the provided arguments.
-   *
-   * @example
-   * ```tsx
-   * const action = useAction({ handler: async (data) => { ... } }, []);
-   * action.run(data);
-   * ```
-   */
-  run: (...args: Args) => Promise<Result | undefined>;
-  /**
-   * Loading state - true when action is executing.
-   */
-  loading: boolean;
-  /**
-   * Error state - contains error if action failed, undefined otherwise.
-   */
-  error?: Error;
-  /**
-   * Cancel any pending debounced action or abort the current in-flight request.
-   *
-   * @example
-   * ```tsx
-   * const action = useAction({ ... }, []);
-   *
-   * <button onClick={action.cancel} disabled={!action.loading}>
-   *   Cancel
-   * </button>
-   * ```
-   */
-  cancel: () => void;
-}
-//#endregion
-//#region ../react/src/core/hooks/useActive.d.ts
-interface UseActiveOptions {
-  href: string;
-  startWith?: boolean;
-}
-//#endregion
 //#region ../alepha/src/file/providers/FileSystemProvider.d.ts
 /**
  * Options for creating a file from a URL
@@ -2913,10 +2854,10 @@ declare class FileDetector {
 }
 //#endregion
 //#region ../react/src/core/providers/ReactServerProvider.d.ts
-declare const envSchema$3: alepha1223.TObject<{
-  REACT_SSR_ENABLED: alepha1223.TOptional<alepha1223.TBoolean>;
-  REACT_ROOT_ID: alepha1223.TString;
-  REACT_SERVER_TEMPLATE: alepha1223.TOptional<alepha1223.TString>;
+declare const envSchema$3: alepha1672.TObject<{
+  REACT_SSR_ENABLED: alepha1672.TOptional<alepha1672.TBoolean>;
+  REACT_ROOT_ID: alepha1672.TString;
+  REACT_SERVER_TEMPLATE: alepha1672.TOptional<alepha1672.TString>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$3>> {}
@@ -2927,11 +2868,11 @@ declare module "alepha" {
 /**
  * React server provider configuration atom
  */
-declare const reactServerOptions: alepha1223.Atom<alepha1223.TObject<{
-  publicDir: alepha1223.TString;
-  staticServer: alepha1223.TObject<{
-    disabled: alepha1223.TBoolean;
-    path: alepha1223.TString;
+declare const reactServerOptions: alepha1672.Atom<alepha1672.TObject<{
+  publicDir: alepha1672.TString;
+  staticServer: alepha1672.TObject<{
+    disabled: alepha1672.TBoolean;
+    path: alepha1672.TString;
   }>;
 }>, "alepha.react.server.options">;
 type ReactServerProviderOptions = Static<typeof reactServerOptions.schema>;
@@ -3036,7 +2977,7 @@ declare module "alepha" {
 /**
  * Provides full-stack React development with declarative routing, server-side rendering, and client-side hydration.
  *
- * The React module enables building modern React applications using the `$page` descriptor on class properties.
+ * The React module enables building modern React applications using the `$page` primitive on class properties.
  * It delivers seamless server-side rendering, automatic code splitting, and client-side navigation with full
  * type safety and schema validation for route parameters and data.
  *
@@ -3045,25 +2986,25 @@ declare module "alepha" {
  */
 //#endregion
 //#region ../alepha/src/api-users/atoms/realmAuthSettingsAtom.d.ts
-declare const realmAuthSettingsAtom: alepha1223.Atom<alepha1223.TObject<{
-  registrationAllowed: alepha1223.TBoolean;
-  emailEnabled: alepha1223.TBoolean;
-  emailRequired: alepha1223.TBoolean;
-  usernameEnabled: alepha1223.TBoolean;
-  usernameRequired: alepha1223.TBoolean;
-  phoneEnabled: alepha1223.TBoolean;
-  phoneRequired: alepha1223.TBoolean;
-  verifyEmailRequired: alepha1223.TBoolean;
-  verifyPhoneRequired: alepha1223.TBoolean;
-  firstNameLastNameEnabled: alepha1223.TBoolean;
-  firstNameLastNameRequired: alepha1223.TBoolean;
-  resetPasswordAllowed: alepha1223.TBoolean;
-  passwordPolicy: alepha1223.TObject<{
-    minLength: alepha1223.TInteger;
-    requireUppercase: alepha1223.TBoolean;
-    requireLowercase: alepha1223.TBoolean;
-    requireNumbers: alepha1223.TBoolean;
-    requireSpecialCharacters: alepha1223.TBoolean;
+declare const realmAuthSettingsAtom: alepha1672.Atom<alepha1672.TObject<{
+  registrationAllowed: alepha1672.TBoolean;
+  emailEnabled: alepha1672.TBoolean;
+  emailRequired: alepha1672.TBoolean;
+  usernameEnabled: alepha1672.TBoolean;
+  usernameRequired: alepha1672.TBoolean;
+  phoneEnabled: alepha1672.TBoolean;
+  phoneRequired: alepha1672.TBoolean;
+  verifyEmailRequired: alepha1672.TBoolean;
+  verifyPhoneRequired: alepha1672.TBoolean;
+  firstNameLastNameEnabled: alepha1672.TBoolean;
+  firstNameLastNameRequired: alepha1672.TBoolean;
+  resetPasswordAllowed: alepha1672.TBoolean;
+  passwordPolicy: alepha1672.TObject<{
+    minLength: alepha1672.TInteger;
+    requireUppercase: alepha1672.TBoolean;
+    requireLowercase: alepha1672.TBoolean;
+    requireNumbers: alepha1672.TBoolean;
+    requireSpecialCharacters: alepha1672.TBoolean;
   }>;
 }>, "alepha.api.users.realmAuthSettings">;
 type RealmAuthSettings = Static<typeof realmAuthSettingsAtom.schema>;
@@ -3095,8 +3036,8 @@ type TObjectInsert<T$1 extends TObject> = TObject<{ [K in keyof T$1["properties"
  */
 type TObjectUpdate<T$1 extends TObject> = TObject<{ [K in keyof T$1["properties"]]: T$1["properties"][K] extends TOptional<infer U> ? TOptional<TUnion<[U, TNull]>> : T$1["properties"][K] }>;
 //#endregion
-//#region ../alepha/src/orm/descriptors/$entity.d.ts
-interface EntityDescriptorOptions<T$1 extends TObject, Keys = keyof Static<T$1>> {
+//#region ../alepha/src/orm/primitives/$entity.d.ts
+interface EntityPrimitiveOptions<T$1 extends TObject, Keys = keyof Static<T$1>> {
   /**
    * The database table name that will be created for this entity.
    * If not provided, name will be inferred from the $repository variable name.
@@ -3208,9 +3149,9 @@ interface EntityDescriptorOptions<T$1 extends TObject, Keys = keyof Static<T$1>>
    */
   config?: (self: BuildExtraConfigColumns<string, FromSchema<T$1>, "pg">) => PgTableExtraConfigValue[];
 }
-declare class EntityDescriptor<T$1 extends TObject = TObject> {
-  readonly options: EntityDescriptorOptions<T$1>;
-  constructor(options: EntityDescriptorOptions<T$1>);
+declare class EntityPrimitive<T$1 extends TObject = TObject> {
+  readonly options: EntityPrimitiveOptions<T$1>;
+  constructor(options: EntityPrimitiveOptions<T$1>);
   alias(alias: string): this;
   get cols(): EntityColumns<T$1>;
   get name(): string;
@@ -3230,7 +3171,7 @@ type SchemaToTableConfig<T$1 extends TObject> = {
 };
 type EntityColumn<T$1 extends TObject> = {
   name: string;
-  entity: EntityDescriptor<T$1>;
+  entity: EntityPrimitive<T$1>;
 };
 type EntityColumns<T$1 extends TObject> = { [key in keyof T$1["properties"]]: EntityColumn<T$1> };
 //#endregion
@@ -3276,7 +3217,7 @@ interface PgEnumOptions {
 interface PgRefOptions {
   ref: () => {
     name: string;
-    entity: EntityDescriptor;
+    entity: EntityPrimitive;
   };
   actions?: {
     onUpdate?: UpdateDeleteAction;
@@ -3290,19 +3231,6 @@ declare class DbError extends AlephaError {
   constructor(message: string, cause?: unknown);
 }
 //#endregion
-//#region ../alepha/src/orm/helpers/pgAttr.d.ts
-/**
- * Type representation.
- */
-type PgAttr<T$1 extends TSchema, TAttr extends PgSymbolKeys> = T$1 & { [K in TAttr]: PgSymbols[K] };
-interface PgAttrField {
-  key: string;
-  type: TSchema;
-  data: any;
-  nested?: any[];
-  one?: boolean;
-}
-//#endregion
 //#region ../alepha/src/orm/interfaces/FilterOperators.d.ts
 interface FilterOperators<TValue> {
   /**
@@ -3719,6 +3647,55 @@ interface FilterOperators<TValue> {
   arrayOverlaps?: TValue;
 }
 //#endregion
+//#region ../alepha/src/orm/interfaces/PgQuery.d.ts
+/**
+ * Order direction for sorting
+ */
+type OrderDirection = "asc" | "desc";
+/**
+ * Single order by clause with column and direction
+ */
+interface OrderByClause<T$1> {
+  column: keyof T$1;
+  direction?: OrderDirection;
+}
+/**
+ * Order by parameter - supports 3 modes:
+ * 1. String: orderBy: "name" (defaults to ASC)
+ * 2. Single object: orderBy: { column: "name", direction: "desc" }
+ * 3. Array: orderBy: [{ column: "name", direction: "asc" }, { column: "age", direction: "desc" }]
+ */
+type OrderBy<T$1> = keyof T$1 | OrderByClause<T$1> | Array<OrderByClause<T$1>>;
+/**
+ * Generic query interface for PostgreSQL entities
+ */
+interface PgQuery<T$1 extends TObject = TObject> {
+  distinct?: (keyof Static<T$1>)[];
+  columns?: (keyof Static<T$1>)[];
+  where?: PgQueryWhereOrSQL<T$1>;
+  limit?: number;
+  offset?: number;
+  orderBy?: OrderBy<Static<T$1>>;
+  groupBy?: (keyof Static<T$1>)[];
+}
+type PgStatic<T$1 extends TObject, Relations extends PgRelationMap<T$1>> = Static<T$1> & { [K in keyof Relations]: Static<Relations[K]["join"]["schema"]> & (Relations[K]["with"] extends PgRelationMap<TObject> ? PgStatic<Relations[K]["join"]["schema"], Relations[K]["with"]> : {}) };
+interface PgQueryRelations<T$1 extends TObject = TObject, Relations extends PgRelationMap<T$1> | undefined = undefined> extends PgQuery<T$1> {
+  with?: Relations;
+  where?: PgQueryWhereOrSQL<T$1, Relations>;
+}
+type PgRelationMap<Base extends TObject> = Record<string, PgRelation<Base>>;
+type PgRelation<Base extends TObject> = {
+  type?: "left" | "inner" | "right";
+  join: {
+    schema: TObject;
+    name: string;
+  };
+  on: SQLWrapper | [keyof Static<Base>, {
+    name: string;
+  }];
+  with?: PgRelationMap<TObject>;
+};
+//#endregion
 //#region ../alepha/src/orm/interfaces/PgQueryWhere.d.ts
 type PgQueryWhere<T$1 extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = (PgQueryWhereOperators<T$1> & PgQueryWhereConditions<T$1>) | (PgQueryWhereRelations<Relations> & PgQueryWhereOperators<T$1> & PgQueryWhereConditions<T$1, Relations>);
 type PgQueryWhereOrSQL<T$1 extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = SQLWrapper | PgQueryWhere<T$1, Relations>;
@@ -3798,64 +3775,28 @@ type PgQueryWhereRelations<Relations extends PgRelationMap<TObject> | undefined
  */
 type NestedJsonbQuery<T$1> = T$1 extends object ? T$1 extends Array<infer U> ? U extends object ? { [K in keyof U]?: FilterOperators<U[K]> | U[K] } : FilterOperators<U> | U : { [K in keyof T$1]?: FilterOperators<T$1[K]> | T$1[K] | (T$1[K] extends object ? NestedJsonbQuery<T$1[K]> : never) } : FilterOperators<T$1> | T$1;
 //#endregion
-//#region ../alepha/src/orm/interfaces/PgQuery.d.ts
-/**
- * Order direction for sorting
- */
-type OrderDirection = "asc" | "desc";
-/**
- * Single order by clause with column and direction
- */
-interface OrderByClause<T$1> {
-  column: keyof T$1;
-  direction?: OrderDirection;
-}
-/**
- * Order by parameter - supports 3 modes:
- * 1. String: orderBy: "name" (defaults to ASC)
- * 2. Single object: orderBy: { column: "name", direction: "desc" }
- * 3. Array: orderBy: [{ column: "name", direction: "asc" }, { column: "age", direction: "desc" }]
- */
-type OrderBy<T$1> = keyof T$1 | OrderByClause<T$1> | Array<OrderByClause<T$1>>;
+//#region ../alepha/src/orm/helpers/pgAttr.d.ts
 /**
- * Generic query interface for PostgreSQL entities
+ * Type representation.
  */
-interface PgQuery<T$1 extends TObject = TObject> {
-  distinct?: (keyof Static<T$1>)[];
-  columns?: (keyof Static<T$1>)[];
-  where?: PgQueryWhereOrSQL<T$1>;
-  limit?: number;
-  offset?: number;
-  orderBy?: OrderBy<Static<T$1>>;
-  groupBy?: (keyof Static<T$1>)[];
-}
-type PgStatic<T$1 extends TObject, Relations extends PgRelationMap<T$1>> = Static<T$1> & { [K in keyof Relations]: Static<Relations[K]["join"]["schema"]> & (Relations[K]["with"] extends PgRelationMap<TObject> ? PgStatic<Relations[K]["join"]["schema"], Relations[K]["with"]> : {}) };
-interface PgQueryRelations<T$1 extends TObject = TObject, Relations extends PgRelationMap<T$1> | undefined = undefined> extends PgQuery<T$1> {
-  with?: Relations;
-  where?: PgQueryWhereOrSQL<T$1, Relations>;
+type PgAttr<T$1 extends TSchema, TAttr extends PgSymbolKeys> = T$1 & { [K in TAttr]: PgSymbols[K] };
+interface PgAttrField {
+  key: string;
+  type: TSchema;
+  data: any;
+  nested?: any[];
+  one?: boolean;
 }
-type PgRelationMap<Base extends TObject> = Record<string, PgRelation<Base>>;
-type PgRelation<Base extends TObject> = {
-  type?: "left" | "inner" | "right";
-  join: {
-    schema: TObject;
-    name: string;
-  };
-  on: SQLWrapper | [keyof Static<Base>, {
-    name: string;
-  }];
-  with?: PgRelationMap<TObject>;
-};
 //#endregion
-//#region ../alepha/src/orm/descriptors/$sequence.d.ts
-interface SequenceDescriptorOptions extends PgSequenceOptions {
+//#region ../alepha/src/orm/primitives/$sequence.d.ts
+interface SequencePrimitiveOptions extends PgSequenceOptions {
   /**
    * The name of the sequence. If not provided, the property key will be used.
    */
   name?: string;
   provider?: DatabaseProvider;
 }
-declare class SequenceDescriptor extends Descriptor<SequenceDescriptorOptions> {
+declare class SequencePrimitive extends Primitive<SequencePrimitiveOptions> {
   readonly provider: DatabaseProvider;
   onInit(): void;
   get name(): string;
@@ -3886,22 +3827,22 @@ interface TableConfigBuilders<TConfig> {
   }) => TConfig;
 }
 /**
- * Abstract base class for transforming Alepha Descriptors (Entity, Sequence, etc...)
+ * Abstract base class for transforming Alepha Primitives (Entity, Sequence, etc...)
  * into drizzle models (tables, enums, sequences, etc...).
  */
 declare abstract class ModelBuilder {
   /**
-   * Build a table from an entity descriptor.
+   * Build a table from an entity primitive.
    */
-  abstract buildTable(entity: EntityDescriptor, options: {
+  abstract buildTable(entity: EntityPrimitive, options: {
     tables: Map<string, unknown>;
     enums: Map<string, unknown>;
     schema: string;
   }): void;
   /**
-   * Build a sequence from a sequence descriptor.
+   * Build a sequence from a sequence primitive.
    */
-  abstract buildSequence(sequence: SequenceDescriptor, options: {
+  abstract buildSequence(sequence: SequencePrimitive, options: {
     sequences: Map<string, unknown>;
     schema: string;
   }): void;
@@ -3913,12 +3854,12 @@ declare abstract class ModelBuilder {
    * Build the table configuration function for any database.
    * This includes indexes, foreign keys, constraints, and custom config.
    *
-   * @param entity - The entity descriptor
+   * @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: EntityDescriptor, builders: TableConfigBuilders<TConfig>, tableResolver?: (entityName: string) => any, customConfigHandler?: (config: any, self: TSelf) => TConfig[]): ((self: TSelf) => TConfig[]) | undefined;
+  protected buildTableConfig<TConfig, TSelf>(entity: EntityPrimitive, builders: TableConfigBuilders<TConfig>, tableResolver?: (entityName: string) => any, customConfigHandler?: (config: any, self: TSelf) => TConfig[]): ((self: TSelf) => TConfig[]) | undefined;
 }
 //#endregion
 //#region ../alepha/src/orm/providers/DrizzleKitProvider.d.ts
@@ -3957,13 +3898,13 @@ declare class DrizzleKitProvider {
    * Try to load the official Drizzle Kit API.
    * If not available, fallback to the local kit import.
    */
-  protected importDrizzleKit(): typeof DrizzleKit;
+  importDrizzleKit(): typeof DrizzleKit;
 }
-declare const devMigrationsSchema: alepha1223.TObject<{
-  id: alepha1223.TNumber;
-  name: alepha1223.TString;
-  snapshot: alepha1223.TString;
-  created_at: alepha1223.TString;
+declare const devMigrationsSchema: alepha1672.TObject<{
+  id: alepha1672.TNumber;
+  name: alepha1672.TString;
+  snapshot: alepha1672.TString;
+  created_at: alepha1672.TString;
 }>;
 type DevMigrations = Static<typeof devMigrationsSchema>;
 //#endregion
@@ -3982,9 +3923,9 @@ declare abstract class DatabaseProvider {
   readonly sequences: Map<string, unknown>;
   get name(): string;
   get schema(): string;
-  table<T$1 extends TObject>(entity: EntityDescriptor<T$1>): PgTableWithColumns<SchemaToTableConfig<T$1>>;
-  registerEntity(entity: EntityDescriptor): void;
-  registerSequence(sequence: SequenceDescriptor): void;
+  table<T$1 extends TObject>(entity: EntityPrimitive<T$1>): PgTableWithColumns<SchemaToTableConfig<T$1>>;
+  registerEntity(entity: EntityPrimitive): void;
+  registerSequence(sequence: SequencePrimitive): void;
   abstract execute(statement: SQLLike): Promise<Record<string, unknown>[]>;
   run<T$1 extends TObject>(statement: SQLLike, schema: T$1): Promise<Array<Static<T$1>>>;
   /**
@@ -4160,7 +4101,7 @@ declare class QueryManager {
   createPagination<T$1>(entities: T$1[], limit?: number, offset?: number, sort?: Array<{
     column: string;
     direction: "asc" | "desc";
-  }>): alepha1223.Page<T$1>;
+  }>): alepha1672.Page<T$1>;
 }
 interface PgJoin {
   table: string;
@@ -4192,13 +4133,13 @@ declare class PgRelationManager {
 //#endregion
 //#region ../alepha/src/orm/services/Repository.d.ts
 declare abstract class Repository<T$1 extends TObject> {
-  readonly entity: EntityDescriptor<T$1>;
+  readonly entity: EntityPrimitive<T$1>;
   readonly provider: DatabaseProvider;
   protected readonly relationManager: PgRelationManager;
   protected readonly queryManager: QueryManager;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly alepha: Alepha;
-  constructor(entity: EntityDescriptor<T$1>, provider?: typeof DatabaseProvider);
+  constructor(entity: EntityPrimitive<T$1>, provider?: typeof DatabaseProvider);
   /**
    * Represents the primary key of the table.
    * - Key is the name of the primary key column.
@@ -4464,9 +4405,9 @@ interface StatementOptions {
   now?: DateTime | string;
 }
 //#endregion
-//#region ../alepha/src/lock/descriptors/$lock.d.ts
-declare const envSchema$2: alepha1223.TObject<{
-  LOCK_PREFIX_KEY: alepha1223.TString;
+//#region ../alepha/src/lock/primitives/$lock.d.ts
+declare const envSchema$2: alepha1672.TObject<{
+  LOCK_PREFIX_KEY: alepha1672.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$2>> {}
@@ -4476,7 +4417,7 @@ declare module "alepha" {
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
 }
-declare const envSchema$1: alepha1223.TObject<{
+declare const envSchema$1: alepha1672.TObject<{
   /**
    * Main configuration for database connection.
    * Accept a string in the format of a Postgres connection URL.
@@ -4484,21 +4425,21 @@ declare const envSchema$1: alepha1223.TObject<{
    * or
    * Example: postgres://user:password@localhost:5432/database?sslmode=require
    */
-  DATABASE_URL: alepha1223.TOptional<alepha1223.TString>;
+  DATABASE_URL: alepha1672.TOptional<alepha1672.TString>;
   /**
    * In addition to the DATABASE_URL, you can specify the postgres schema name.
    *
    * It will monkey patch drizzle tables.
    */
-  POSTGRES_SCHEMA: alepha1223.TOptional<alepha1223.TString>;
+  POSTGRES_SCHEMA: alepha1672.TOptional<alepha1672.TString>;
 }>;
 //#endregion
 //#region ../alepha/src/orm/providers/drivers/NodeSqliteProvider.d.ts
 /**
  * Configuration options for the Node.js SQLite database provider.
  */
-declare const nodeSqliteOptions: alepha1223.Atom<alepha1223.TObject<{
-  path: alepha1223.TOptional<alepha1223.TString>;
+declare const nodeSqliteOptions: alepha1672.Atom<alepha1672.TObject<{
+  path: alepha1672.TOptional<alepha1672.TString>;
 }>, "alepha.postgres.node-sqlite.options">;
 type NodeSqliteProviderOptions = Static<typeof nodeSqliteOptions.schema>;
 declare module "alepha" {
@@ -4582,16 +4523,16 @@ declare module "alepha" {
 }
 //#endregion
 //#region ../alepha/src/api-users/entities/identities.d.ts
-declare const identities: EntityDescriptor<alepha1223.TObject<{
-  id: PgAttr<PgAttr<alepha1223.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-  version: PgAttr<PgAttr<alepha1223.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-  createdAt: PgAttr<PgAttr<alepha1223.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-  updatedAt: PgAttr<PgAttr<alepha1223.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-  userId: PgAttr<alepha1223.TString, typeof PG_REF>;
-  password: alepha1223.TOptional<alepha1223.TString>;
-  provider: alepha1223.TString;
-  providerUserId: alepha1223.TOptional<alepha1223.TString>;
-  providerData: alepha1223.TOptional<alepha1223.TRecord<string, alepha1223.TAny>>;
+declare const identities: EntityPrimitive<alepha1672.TObject<{
+  id: PgAttr<PgAttr<alepha1672.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+  version: PgAttr<PgAttr<alepha1672.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+  createdAt: PgAttr<PgAttr<alepha1672.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+  updatedAt: PgAttr<PgAttr<alepha1672.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+  userId: PgAttr<alepha1672.TString, typeof PG_REF>;
+  password: alepha1672.TOptional<alepha1672.TString>;
+  provider: alepha1672.TString;
+  providerUserId: alepha1672.TOptional<alepha1672.TString>;
+  providerData: alepha1672.TOptional<alepha1672.TRecord<string, alepha1672.TAny>>;
 }>>;
 //#endregion
 //#region ../alepha/src/bucket/providers/FileStorageProvider.d.ts
@@ -4642,8 +4583,8 @@ declare class MemoryFileStorageProvider implements FileStorageProvider {
   protected createId(): string;
 }
 //#endregion
-//#region ../alepha/src/bucket/descriptors/$bucket.d.ts
-interface BucketDescriptorOptions extends BucketFileOptions {
+//#region ../alepha/src/bucket/primitives/$bucket.d.ts
+interface BucketPrimitiveOptions extends BucketFileOptions {
   /**
    * File storage provider configuration for the bucket.
    *
@@ -4775,7 +4716,7 @@ interface BucketFileOptions {
    */
   maxSize?: number;
 }
-declare class BucketDescriptor extends Descriptor<BucketDescriptorOptions> {
+declare class BucketPrimitive extends Primitive<BucketPrimitiveOptions> {
   readonly provider: FileStorageProvider | MemoryFileStorageProvider;
   private readonly fileSystem;
   get name(): string;
@@ -4818,8 +4759,8 @@ interface BucketFileOptions {
 /**
  * Local file storage configuration atom
  */
-declare const localFileStorageOptions: alepha1223.Atom<alepha1223.TObject<{
-  storagePath: alepha1223.TString;
+declare const localFileStorageOptions: alepha1672.Atom<alepha1672.TObject<{
+  storagePath: alepha1672.TString;
 }>, "alepha.bucket.local.options">;
 type LocalFileStorageProviderOptions = Static<typeof localFileStorageOptions.schema>;
 declare module "alepha" {
@@ -4838,7 +4779,7 @@ declare module "alepha" {
     "bucket:file:uploaded": {
       id: string;
       file: FileLike;
-      bucket: BucketDescriptor;
+      bucket: BucketPrimitive;
       options: BucketFileOptions;
     };
     /**
@@ -4846,14 +4787,14 @@ declare module "alepha" {
      */
     "bucket:file:deleted": {
       id: string;
-      bucket: BucketDescriptor;
+      bucket: BucketPrimitive;
     };
   }
 }
 /**
- * Provides file storage capabilities through declarative bucket descriptors with support for multiple storage backends.
+ * Provides file storage capabilities through declarative bucket primitives with support for multiple storage backends.
  *
- * The bucket module enables unified file operations across different storage systems using the `$bucket` descriptor
+ * The bucket module enables unified file operations across different storage systems using the `$bucket` primitive
  * on class properties. It abstracts storage provider differences, offering consistent APIs for local filesystem,
  * cloud storage, or in-memory storage for testing environments.
  *
@@ -4863,38 +4804,38 @@ declare module "alepha" {
  */
 //#endregion
 //#region ../alepha/src/api-users/entities/sessions.d.ts
-declare const sessions: EntityDescriptor<alepha1223.TObject<{
-  id: PgAttr<PgAttr<alepha1223.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-  version: PgAttr<PgAttr<alepha1223.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-  createdAt: PgAttr<PgAttr<alepha1223.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-  updatedAt: PgAttr<PgAttr<alepha1223.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-  refreshToken: alepha1223.TString;
-  userId: PgAttr<alepha1223.TString, typeof PG_REF>;
-  expiresAt: alepha1223.TString;
-  ip: alepha1223.TOptional<alepha1223.TString>;
-  userAgent: alepha1223.TOptional<alepha1223.TObject<{
-    os: alepha1223.TString;
-    browser: alepha1223.TString;
-    device: alepha1223.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
+declare const sessions: EntityPrimitive<alepha1672.TObject<{
+  id: PgAttr<PgAttr<alepha1672.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+  version: PgAttr<PgAttr<alepha1672.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+  createdAt: PgAttr<PgAttr<alepha1672.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+  updatedAt: PgAttr<PgAttr<alepha1672.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+  refreshToken: alepha1672.TString;
+  userId: PgAttr<alepha1672.TString, typeof PG_REF>;
+  expiresAt: alepha1672.TString;
+  ip: alepha1672.TOptional<alepha1672.TString>;
+  userAgent: alepha1672.TOptional<alepha1672.TObject<{
+    os: alepha1672.TString;
+    browser: alepha1672.TString;
+    device: alepha1672.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
   }>>;
 }>>;
 //#endregion
 //#region ../alepha/src/api-users/entities/users.d.ts
-declare const users: EntityDescriptor<alepha1223.TObject<{
-  id: PgAttr<PgAttr<alepha1223.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-  version: PgAttr<PgAttr<alepha1223.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-  createdAt: PgAttr<PgAttr<alepha1223.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-  updatedAt: PgAttr<PgAttr<alepha1223.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-  realm: PgAttr<alepha1223.TString, typeof PG_DEFAULT>;
-  username: alepha1223.TOptional<alepha1223.TString>;
-  email: alepha1223.TOptional<alepha1223.TString>;
-  phoneNumber: alepha1223.TOptional<alepha1223.TString>;
-  roles: PgAttr<alepha1223.TArray<alepha1223.TString>, typeof PG_DEFAULT>;
-  firstName: alepha1223.TOptional<alepha1223.TString>;
-  lastName: alepha1223.TOptional<alepha1223.TString>;
-  picture: alepha1223.TOptional<alepha1223.TString>;
-  enabled: PgAttr<alepha1223.TBoolean, typeof PG_DEFAULT>;
-  emailVerified: PgAttr<alepha1223.TBoolean, typeof PG_DEFAULT>;
+declare const users: EntityPrimitive<alepha1672.TObject<{
+  id: PgAttr<PgAttr<alepha1672.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+  version: PgAttr<PgAttr<alepha1672.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+  createdAt: PgAttr<PgAttr<alepha1672.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+  updatedAt: PgAttr<PgAttr<alepha1672.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+  realm: PgAttr<alepha1672.TString, typeof PG_DEFAULT>;
+  username: alepha1672.TOptional<alepha1672.TString>;
+  email: alepha1672.TOptional<alepha1672.TString>;
+  phoneNumber: alepha1672.TOptional<alepha1672.TString>;
+  roles: PgAttr<alepha1672.TArray<alepha1672.TString>, typeof PG_DEFAULT>;
+  firstName: alepha1672.TOptional<alepha1672.TString>;
+  lastName: alepha1672.TOptional<alepha1672.TString>;
+  picture: alepha1672.TOptional<alepha1672.TString>;
+  enabled: PgAttr<alepha1672.TBoolean, typeof PG_DEFAULT>;
+  emailVerified: PgAttr<alepha1672.TBoolean, typeof PG_DEFAULT>;
 }>>;
 //#endregion
 //#region ../alepha/src/api-users/providers/UserRealmProvider.d.ts
@@ -4910,51 +4851,51 @@ interface UserRealm {
 }
 declare class UserRealmProvider {
   protected readonly alepha: Alepha;
-  protected readonly defaultIdentities: Repository<alepha1223.TObject<{
-    id: PgAttr<PgAttr<alepha1223.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-    version: PgAttr<PgAttr<alepha1223.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-    createdAt: PgAttr<PgAttr<alepha1223.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-    updatedAt: PgAttr<PgAttr<alepha1223.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-    userId: PgAttr<alepha1223.TString, typeof PG_REF>;
-    password: alepha1223.TOptional<alepha1223.TString>;
-    provider: alepha1223.TString;
-    providerUserId: alepha1223.TOptional<alepha1223.TString>;
-    providerData: alepha1223.TOptional<alepha1223.TRecord<string, alepha1223.TAny>>;
+  protected readonly defaultIdentities: Repository<alepha1672.TObject<{
+    id: PgAttr<PgAttr<alepha1672.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+    version: PgAttr<PgAttr<alepha1672.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+    createdAt: PgAttr<PgAttr<alepha1672.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+    updatedAt: PgAttr<PgAttr<alepha1672.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+    userId: PgAttr<alepha1672.TString, typeof PG_REF>;
+    password: alepha1672.TOptional<alepha1672.TString>;
+    provider: alepha1672.TString;
+    providerUserId: alepha1672.TOptional<alepha1672.TString>;
+    providerData: alepha1672.TOptional<alepha1672.TRecord<string, alepha1672.TAny>>;
   }>>;
-  protected readonly defaultSessions: Repository<alepha1223.TObject<{
-    id: PgAttr<PgAttr<alepha1223.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-    version: PgAttr<PgAttr<alepha1223.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-    createdAt: PgAttr<PgAttr<alepha1223.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-    updatedAt: PgAttr<PgAttr<alepha1223.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-    refreshToken: alepha1223.TString;
-    userId: PgAttr<alepha1223.TString, typeof PG_REF>;
-    expiresAt: alepha1223.TString;
-    ip: alepha1223.TOptional<alepha1223.TString>;
-    userAgent: alepha1223.TOptional<alepha1223.TObject<{
-      os: alepha1223.TString;
-      browser: alepha1223.TString;
-      device: alepha1223.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
+  protected readonly defaultSessions: Repository<alepha1672.TObject<{
+    id: PgAttr<PgAttr<alepha1672.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+    version: PgAttr<PgAttr<alepha1672.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+    createdAt: PgAttr<PgAttr<alepha1672.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+    updatedAt: PgAttr<PgAttr<alepha1672.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+    refreshToken: alepha1672.TString;
+    userId: PgAttr<alepha1672.TString, typeof PG_REF>;
+    expiresAt: alepha1672.TString;
+    ip: alepha1672.TOptional<alepha1672.TString>;
+    userAgent: alepha1672.TOptional<alepha1672.TObject<{
+      os: alepha1672.TString;
+      browser: alepha1672.TString;
+      device: alepha1672.TUnsafe<"MOBILE" | "DESKTOP" | "TABLET">;
     }>>;
   }>>;
-  protected readonly defaultUsers: Repository<alepha1223.TObject<{
-    id: PgAttr<PgAttr<alepha1223.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-    version: PgAttr<PgAttr<alepha1223.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-    createdAt: PgAttr<PgAttr<alepha1223.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-    updatedAt: PgAttr<PgAttr<alepha1223.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-    realm: PgAttr<alepha1223.TString, typeof PG_DEFAULT>;
-    username: alepha1223.TOptional<alepha1223.TString>;
-    email: alepha1223.TOptional<alepha1223.TString>;
-    phoneNumber: alepha1223.TOptional<alepha1223.TString>;
-    roles: PgAttr<alepha1223.TArray<alepha1223.TString>, typeof PG_DEFAULT>;
-    firstName: alepha1223.TOptional<alepha1223.TString>;
-    lastName: alepha1223.TOptional<alepha1223.TString>;
-    picture: alepha1223.TOptional<alepha1223.TString>;
-    enabled: PgAttr<alepha1223.TBoolean, typeof PG_DEFAULT>;
-    emailVerified: PgAttr<alepha1223.TBoolean, typeof PG_DEFAULT>;
+  protected readonly defaultUsers: Repository<alepha1672.TObject<{
+    id: PgAttr<PgAttr<alepha1672.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+    version: PgAttr<PgAttr<alepha1672.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+    createdAt: PgAttr<PgAttr<alepha1672.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+    updatedAt: PgAttr<PgAttr<alepha1672.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+    realm: PgAttr<alepha1672.TString, typeof PG_DEFAULT>;
+    username: alepha1672.TOptional<alepha1672.TString>;
+    email: alepha1672.TOptional<alepha1672.TString>;
+    phoneNumber: alepha1672.TOptional<alepha1672.TString>;
+    roles: PgAttr<alepha1672.TArray<alepha1672.TString>, typeof PG_DEFAULT>;
+    firstName: alepha1672.TOptional<alepha1672.TString>;
+    lastName: alepha1672.TOptional<alepha1672.TString>;
+    picture: alepha1672.TOptional<alepha1672.TString>;
+    enabled: PgAttr<alepha1672.TBoolean, typeof PG_DEFAULT>;
+    emailVerified: PgAttr<alepha1672.TBoolean, typeof PG_DEFAULT>;
   }>>;
   protected realms: Map<string, UserRealm>;
-  avatars: BucketDescriptor;
-  protected readonly onConfigure: alepha1223.HookDescriptor<"configure">;
+  avatars: BucketPrimitive;
+  protected readonly onConfigure: alepha1672.HookPrimitive<"configure">;
   register(userRealmName: string, userRealmOptions?: UserRealmOptions): void;
   /**
    * Gets a registered realm by name, auto-creating default if needed.
@@ -4969,21 +4910,21 @@ declare class UserRealmProvider {
 /**
  * Verification settings configuration atom
  */
-declare const verificationOptions: alepha1223.Atom<alepha1223.TObject<{
-  code: alepha1223.TObject<{
-    maxAttempts: alepha1223.TInteger;
-    codeLength: alepha1223.TInteger;
-    codeExpiration: alepha1223.TInteger;
-    verificationCooldown: alepha1223.TInteger;
-    limitPerDay: alepha1223.TInteger;
+declare const verificationOptions: alepha1672.Atom<alepha1672.TObject<{
+  code: alepha1672.TObject<{
+    maxAttempts: alepha1672.TInteger;
+    codeLength: alepha1672.TInteger;
+    codeExpiration: alepha1672.TInteger;
+    verificationCooldown: alepha1672.TInteger;
+    limitPerDay: alepha1672.TInteger;
   }>;
-  link: alepha1223.TObject<{
-    maxAttempts: alepha1223.TInteger;
-    codeExpiration: alepha1223.TInteger;
-    verificationCooldown: alepha1223.TInteger;
-    limitPerDay: alepha1223.TInteger;
+  link: alepha1672.TObject<{
+    maxAttempts: alepha1672.TInteger;
+    codeExpiration: alepha1672.TInteger;
+    verificationCooldown: alepha1672.TInteger;
+    limitPerDay: alepha1672.TInteger;
   }>;
-  purgeDays: alepha1223.TInteger;
+  purgeDays: alepha1672.TInteger;
 }>, "alepha.api.verifications.options">;
 type VerificationOptions = Static<typeof verificationOptions.schema>;
 declare module "alepha" {
@@ -5032,7 +4973,7 @@ declare module "alepha" {
 /**
  * Provides email sending capabilities for Alepha applications with multiple provider backends.
  *
- * The email module enables declarative email sending through the `$email` descriptor, allowing you to send
+ * The email module enables declarative email sending through the `$email` primitive, allowing you to send
  * emails through different providers: memory (for testing), local file system, or SMTP via Nodemailer.
  * It supports HTML email content and automatic provider selection based on environment configuration.
  *
@@ -5040,44 +4981,112 @@ declare module "alepha" {
  * @module alepha.email
  */
 //#endregion
+//#region ../alepha/src/sms/providers/SmsProvider.d.ts
+/**
+ * SMS provider interface.
+ *
+ * All methods are asynchronous and return promises.
+ */
+declare abstract class SmsProvider {
+  /**
+   * Send an SMS.
+   *
+   * @return Promise that resolves when the SMS is sent.
+   */
+  abstract send(options: SmsSendOptions): Promise<void>;
+}
+type SmsSendOptions = {
+  to: string | string[];
+  message: string;
+};
+//#endregion
+//#region ../alepha/src/sms/index.d.ts
+declare module "alepha" {
+  interface Hooks {
+    "sms:sending": {
+      to: string | string[];
+      template: string;
+      variables: Record<string, unknown>;
+      provider: SmsProvider;
+      abort(): void;
+    };
+    "sms:sent": {
+      to: string | string[];
+      template: string;
+      provider: SmsProvider;
+    };
+  }
+}
+/**
+ * Provides SMS sending capabilities for Alepha applications with multiple provider backends.
+ *
+ * The SMS module enables declarative SMS sending through the `$sms` primitive, allowing you to send
+ * text messages through different providers: memory (for testing) or local file system.
+ * It supports automatic provider selection based on environment configuration.
+ *
+ * @see {@link SmsProvider}
+ * @module alepha.sms
+ */
+//#endregion
 //#region ../alepha/src/api-notifications/services/NotificationService.d.ts
-declare const notificationServiceEnvSchema: alepha1223.TObject<{
-  NOTIFICATION_QUEUE: alepha1223.TOptional<alepha1223.TBoolean>;
+declare const notificationServiceEnvSchema: alepha1672.TObject<{
+  NOTIFICATION_QUEUE: alepha1672.TOptional<alepha1672.TBoolean>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof notificationServiceEnvSchema>> {}
 }
 //#endregion
 //#region ../alepha/src/queue/providers/WorkerProvider.d.ts
-declare const envSchema: alepha1223.TObject<{
+declare const envSchema: alepha1672.TObject<{
   /**
    * The timeout in seconds for blocking job acquisition.
    * Workers will check for shutdown after each timeout period.
    */
-  QUEUE_WORKER_BLOCKING_TIMEOUT: alepha1223.TInteger;
+  QUEUE_WORKER_BLOCKING_TIMEOUT: alepha1672.TInteger;
   /**
    * The number of workers to run concurrently. Defaults to 1.
    * Useful only if you are doing a lot of I/O.
    */
-  QUEUE_WORKER_CONCURRENCY: alepha1223.TInteger;
+  QUEUE_WORKER_CONCURRENCY: alepha1672.TInteger;
   /**
    * Interval in milliseconds for renewing job locks during processing.
    * Should be less than the job's lock duration.
    */
-  QUEUE_WORKER_LOCK_RENEWAL_INTERVAL: alepha1223.TInteger;
+  QUEUE_WORKER_LOCK_RENEWAL_INTERVAL: alepha1672.TInteger;
   /**
    * Interval in milliseconds for the scheduler to check delayed jobs and stalled jobs.
    */
-  QUEUE_SCHEDULER_INTERVAL: alepha1223.TInteger;
+  QUEUE_SCHEDULER_INTERVAL: alepha1672.TInteger;
   /**
    * Threshold in milliseconds after lock expiration to consider a job stalled.
    */
-  QUEUE_STALLED_THRESHOLD: alepha1223.TInteger;
+  QUEUE_STALLED_THRESHOLD: alepha1672.TInteger;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
 //#endregion
+//#region ../alepha/src/server-auth/schemas/authenticationProviderSchema.d.ts
+declare const authenticationProviderSchema: alepha1672.TObject<{
+  name: alepha1672.TString;
+  type: alepha1672.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
+}>;
+type AuthenticationProvider = Static<typeof authenticationProviderSchema>;
+//#endregion
+//#region ../alepha/src/server-auth/schemas/tokensSchema.d.ts
+declare const tokensSchema: alepha1672.TObject<{
+  provider: alepha1672.TString;
+  access_token: alepha1672.TString;
+  issued_at: alepha1672.TNumber;
+  expires_in: alepha1672.TOptional<alepha1672.TNumber>;
+  refresh_token: alepha1672.TOptional<alepha1672.TString>;
+  refresh_token_expires_in: alepha1672.TOptional<alepha1672.TNumber>;
+  refresh_expires_in: alepha1672.TOptional<alepha1672.TNumber>;
+  id_token: alepha1672.TOptional<alepha1672.TString>;
+  scope: alepha1672.TOptional<alepha1672.TString>;
+}>;
+type Tokens = Static<typeof tokensSchema>;
+//#endregion
 //#region ../alepha/src/server-cookies/services/CookieParser.d.ts
 declare class CookieParser {
   parseRequestCookies(header: string): Record<string, string>;
@@ -5098,12 +5107,12 @@ declare class ServerCookiesProvider {
   protected readonly IV_LENGTH = 16;
   protected readonly AUTH_TAG_LENGTH = 16;
   protected readonly SIGNATURE_LENGTH = 32;
-  readonly onRequest: alepha1223.HookDescriptor<"server:onRequest">;
-  readonly onAction: alepha1223.HookDescriptor<"action:onRequest">;
-  readonly onSend: alepha1223.HookDescriptor<"server:onSend">;
+  readonly onRequest: alepha1672.HookPrimitive<"server:onRequest">;
+  readonly onAction: alepha1672.HookPrimitive<"action:onRequest">;
+  readonly onSend: alepha1672.HookPrimitive<"server:onSend">;
   protected getCookiesFromContext(cookies?: Cookies): Cookies;
-  getCookie<T$1 extends TSchema>(name: string, options: CookieDescriptorOptions<T$1>, contextCookies?: Cookies): Static<T$1> | undefined;
-  setCookie<T$1 extends TSchema>(name: string, options: CookieDescriptorOptions<T$1>, data: Static<T$1>, contextCookies?: Cookies): void;
+  getCookie<T$1 extends TSchema>(name: string, options: CookiePrimitiveOptions<T$1>, contextCookies?: Cookies): Static<T$1> | undefined;
+  setCookie<T$1 extends TSchema>(name: string, options: CookiePrimitiveOptions<T$1>, data: Static<T$1>, contextCookies?: Cookies): void;
   deleteCookie<T$1 extends TSchema>(name: string, contextCookies?: Cookies): void;
   protected encrypt(text: string): string;
   protected decrypt(encryptedText: string): string;
@@ -5111,8 +5120,8 @@ declare class ServerCookiesProvider {
   protected sign(data: string): string;
 }
 //#endregion
-//#region ../alepha/src/server-cookies/descriptors/$cookie.d.ts
-interface CookieDescriptorOptions<T$1 extends TSchema> {
+//#region ../alepha/src/server-cookies/primitives/$cookie.d.ts
+interface CookiePrimitiveOptions<T$1 extends TSchema> {
   /** The schema for the cookie's value, used for validation and type safety. */
   schema: T$1;
   /** The name of the cookie. */
@@ -5136,9 +5145,9 @@ interface CookieDescriptorOptions<T$1 extends TSchema> {
   /** If true, the cookie will be signed to prevent tampering. Requires `COOKIE_SECRET` env var. */
   sign?: boolean;
 }
-interface AbstractCookieDescriptor<T$1 extends TSchema> {
+interface AbstractCookiePrimitive<T$1 extends TSchema> {
   readonly name: string;
-  readonly options: CookieDescriptorOptions<T$1>;
+  readonly options: CookiePrimitiveOptions<T$1>;
   set(value: Static<T$1>, options?: {
     cookies?: Cookies;
     ttl?: DurationLike;
@@ -5171,9 +5180,9 @@ declare module "alepha/server" {
   }
 }
 /**
- * Provides HTTP cookie management capabilities for server requests and responses with type-safe cookie descriptors.
+ * Provides HTTP cookie management capabilities for server requests and responses with type-safe cookie primitives.
  *
- * The server-cookies module enables declarative cookie handling using the `$cookie` descriptor on class properties.
+ * The server-cookies module enables declarative cookie handling using the `$cookie` primitive on class properties.
  * It offers automatic cookie parsing, secure cookie configuration, and seamless integration with server routes
  * for managing user sessions, preferences, and authentication tokens.
  *
@@ -5181,27 +5190,6 @@ declare module "alepha/server" {
  * @module alepha.server.cookies
  */
 //#endregion
-//#region ../alepha/src/server-auth/schemas/authenticationProviderSchema.d.ts
-declare const authenticationProviderSchema: alepha1223.TObject<{
-  name: alepha1223.TString;
-  type: alepha1223.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
-}>;
-type AuthenticationProvider = Static<typeof authenticationProviderSchema>;
-//#endregion
-//#region ../alepha/src/server-auth/schemas/tokensSchema.d.ts
-declare const tokensSchema: alepha1223.TObject<{
-  provider: alepha1223.TString;
-  access_token: alepha1223.TString;
-  issued_at: alepha1223.TNumber;
-  expires_in: alepha1223.TOptional<alepha1223.TNumber>;
-  refresh_token: alepha1223.TOptional<alepha1223.TString>;
-  refresh_token_expires_in: alepha1223.TOptional<alepha1223.TNumber>;
-  refresh_expires_in: alepha1223.TOptional<alepha1223.TNumber>;
-  id_token: alepha1223.TOptional<alepha1223.TString>;
-  scope: alepha1223.TOptional<alepha1223.TString>;
-}>;
-type Tokens = Static<typeof tokensSchema>;
-//#endregion
 //#region ../alepha/src/server-auth/providers/ServerAuthProvider.d.ts
 declare class ServerAuthProvider {
   protected readonly log: Logger;
@@ -5209,34 +5197,34 @@ declare class ServerAuthProvider {
   protected readonly serverCookiesProvider: ServerCookiesProvider;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly serverLinksProvider: ServerLinksProvider;
-  protected readonly authorizationCode: AbstractCookieDescriptor<alepha1223.TObject<{
-    provider: alepha1223.TString;
-    codeVerifier: alepha1223.TOptional<alepha1223.TString>;
-    redirectUri: alepha1223.TOptional<alepha1223.TString>;
-    state: alepha1223.TOptional<alepha1223.TString>;
-    nonce: alepha1223.TOptional<alepha1223.TString>;
+  protected readonly authorizationCode: AbstractCookiePrimitive<alepha1672.TObject<{
+    provider: alepha1672.TString;
+    codeVerifier: alepha1672.TOptional<alepha1672.TString>;
+    redirectUri: alepha1672.TOptional<alepha1672.TString>;
+    state: alepha1672.TOptional<alepha1672.TString>;
+    nonce: alepha1672.TOptional<alepha1672.TString>;
   }>>;
-  readonly tokens: AbstractCookieDescriptor<alepha1223.TObject<{
-    provider: alepha1223.TString;
-    access_token: alepha1223.TString;
-    issued_at: alepha1223.TNumber;
-    expires_in: alepha1223.TOptional<alepha1223.TNumber>;
-    refresh_token: alepha1223.TOptional<alepha1223.TString>;
-    refresh_token_expires_in: alepha1223.TOptional<alepha1223.TNumber>;
-    refresh_expires_in: alepha1223.TOptional<alepha1223.TNumber>;
-    id_token: alepha1223.TOptional<alepha1223.TString>;
-    scope: alepha1223.TOptional<alepha1223.TString>;
+  readonly tokens: AbstractCookiePrimitive<alepha1672.TObject<{
+    provider: alepha1672.TString;
+    access_token: alepha1672.TString;
+    issued_at: alepha1672.TNumber;
+    expires_in: alepha1672.TOptional<alepha1672.TNumber>;
+    refresh_token: alepha1672.TOptional<alepha1672.TString>;
+    refresh_token_expires_in: alepha1672.TOptional<alepha1672.TNumber>;
+    refresh_expires_in: alepha1672.TOptional<alepha1672.TNumber>;
+    id_token: alepha1672.TOptional<alepha1672.TString>;
+    scope: alepha1672.TOptional<alepha1672.TString>;
   }>>;
-  get identities(): Array<AuthDescriptor>;
+  get identities(): Array<AuthPrimitive>;
   getAuthenticationProviders(filters?: {
     realmName?: string;
   }): AuthenticationProvider[];
-  protected readonly configure: alepha1223.HookDescriptor<"configure">;
+  protected readonly configure: alepha1672.HookPrimitive<"configure">;
   protected getAccessTokens(tokens: Tokens): string | undefined;
   /**
    * Fill request headers with access token from cookies or fallback to provider's fallback function.
    */
-  protected readonly onRequest: alepha1223.HookDescriptor<"server:onRequest">;
+  protected readonly onRequest: alepha1672.HookPrimitive<"server:onRequest">;
   /**
    * Convert cookies to tokens.
    * If the tokens are expired, try to refresh them using the refresh token.
@@ -5246,27 +5234,27 @@ declare class ServerAuthProvider {
   /**
    * Get user information.
    */
-  readonly userinfo: RouteDescriptor<{
-    response: alepha1223.TObject<{
-      user: alepha1223.TOptional<alepha1223.TObject<{
-        id: alepha1223.TString;
-        name: alepha1223.TOptional<alepha1223.TString>;
-        email: alepha1223.TOptional<alepha1223.TString>;
-        username: alepha1223.TOptional<alepha1223.TString>;
-        picture: alepha1223.TOptional<alepha1223.TString>;
-        sessionId: alepha1223.TOptional<alepha1223.TString>;
-        organizations: alepha1223.TOptional<alepha1223.TArray<alepha1223.TString>>;
-        roles: alepha1223.TOptional<alepha1223.TArray<alepha1223.TString>>;
+  readonly userinfo: RoutePrimitive<{
+    response: alepha1672.TObject<{
+      user: alepha1672.TOptional<alepha1672.TObject<{
+        id: alepha1672.TString;
+        name: alepha1672.TOptional<alepha1672.TString>;
+        email: alepha1672.TOptional<alepha1672.TString>;
+        username: alepha1672.TOptional<alepha1672.TString>;
+        picture: alepha1672.TOptional<alepha1672.TString>;
+        sessionId: alepha1672.TOptional<alepha1672.TString>;
+        organizations: alepha1672.TOptional<alepha1672.TArray<alepha1672.TString>>;
+        roles: alepha1672.TOptional<alepha1672.TArray<alepha1672.TString>>;
       }>>;
-      api: alepha1223.TObject<{
-        prefix: alepha1223.TOptional<alepha1223.TString>;
-        links: alepha1223.TArray<alepha1223.TObject<{
-          name: alepha1223.TString;
-          group: alepha1223.TOptional<alepha1223.TString>;
-          path: alepha1223.TString;
-          method: alepha1223.TOptional<alepha1223.TString>;
-          requestBodyType: alepha1223.TOptional<alepha1223.TString>;
-          service: alepha1223.TOptional<alepha1223.TString>;
+      api: alepha1672.TObject<{
+        prefix: alepha1672.TOptional<alepha1672.TString>;
+        links: alepha1672.TArray<alepha1672.TObject<{
+          name: alepha1672.TString;
+          group: alepha1672.TOptional<alepha1672.TString>;
+          path: alepha1672.TString;
+          method: alepha1672.TOptional<alepha1672.TString>;
+          requestBodyType: alepha1672.TOptional<alepha1672.TString>;
+          service: alepha1672.TOptional<alepha1672.TString>;
         }>>;
       }>;
     }>;
@@ -5274,66 +5262,66 @@ declare class ServerAuthProvider {
   /**
    * Refresh a token for internal providers.
    */
-  readonly refresh: RouteDescriptor<{
-    query: alepha1223.TObject<{
-      provider: alepha1223.TString;
+  readonly refresh: RoutePrimitive<{
+    query: alepha1672.TObject<{
+      provider: alepha1672.TString;
     }>;
-    body: alepha1223.TObject<{
-      refresh_token: alepha1223.TString;
-      access_token: alepha1223.TOptional<alepha1223.TString>;
+    body: alepha1672.TObject<{
+      refresh_token: alepha1672.TString;
+      access_token: alepha1672.TOptional<alepha1672.TString>;
     }>;
-    response: alepha1223.TObject<{
-      provider: alepha1223.TString;
-      access_token: alepha1223.TString;
-      issued_at: alepha1223.TNumber;
-      expires_in: alepha1223.TOptional<alepha1223.TNumber>;
-      refresh_token: alepha1223.TOptional<alepha1223.TString>;
-      refresh_token_expires_in: alepha1223.TOptional<alepha1223.TNumber>;
-      refresh_expires_in: alepha1223.TOptional<alepha1223.TNumber>;
-      id_token: alepha1223.TOptional<alepha1223.TString>;
-      scope: alepha1223.TOptional<alepha1223.TString>;
+    response: alepha1672.TObject<{
+      provider: alepha1672.TString;
+      access_token: alepha1672.TString;
+      issued_at: alepha1672.TNumber;
+      expires_in: alepha1672.TOptional<alepha1672.TNumber>;
+      refresh_token: alepha1672.TOptional<alepha1672.TString>;
+      refresh_token_expires_in: alepha1672.TOptional<alepha1672.TNumber>;
+      refresh_expires_in: alepha1672.TOptional<alepha1672.TNumber>;
+      id_token: alepha1672.TOptional<alepha1672.TString>;
+      scope: alepha1672.TOptional<alepha1672.TString>;
     }>;
   }>;
   /**
    * Login for local password-based authentication.
    */
-  readonly token: RouteDescriptor<{
-    query: alepha1223.TObject<{
-      provider: alepha1223.TString;
+  readonly token: RoutePrimitive<{
+    query: alepha1672.TObject<{
+      provider: alepha1672.TString;
     }>;
-    body: alepha1223.TObject<{
-      username: alepha1223.TString;
-      password: alepha1223.TString;
+    body: alepha1672.TObject<{
+      username: alepha1672.TString;
+      password: alepha1672.TString;
     }>;
-    response: alepha1223.TObject<{
-      provider: alepha1223.TString;
-      access_token: alepha1223.TString;
-      issued_at: alepha1223.TNumber;
-      expires_in: alepha1223.TOptional<alepha1223.TNumber>;
-      refresh_token: alepha1223.TOptional<alepha1223.TString>;
-      refresh_token_expires_in: alepha1223.TOptional<alepha1223.TNumber>;
-      refresh_expires_in: alepha1223.TOptional<alepha1223.TNumber>;
-      id_token: alepha1223.TOptional<alepha1223.TString>;
-      scope: alepha1223.TOptional<alepha1223.TString>;
-      user: alepha1223.TObject<{
-        id: alepha1223.TString;
-        name: alepha1223.TOptional<alepha1223.TString>;
-        email: alepha1223.TOptional<alepha1223.TString>;
-        username: alepha1223.TOptional<alepha1223.TString>;
-        picture: alepha1223.TOptional<alepha1223.TString>;
-        sessionId: alepha1223.TOptional<alepha1223.TString>;
-        organizations: alepha1223.TOptional<alepha1223.TArray<alepha1223.TString>>;
-        roles: alepha1223.TOptional<alepha1223.TArray<alepha1223.TString>>;
+    response: alepha1672.TObject<{
+      provider: alepha1672.TString;
+      access_token: alepha1672.TString;
+      issued_at: alepha1672.TNumber;
+      expires_in: alepha1672.TOptional<alepha1672.TNumber>;
+      refresh_token: alepha1672.TOptional<alepha1672.TString>;
+      refresh_token_expires_in: alepha1672.TOptional<alepha1672.TNumber>;
+      refresh_expires_in: alepha1672.TOptional<alepha1672.TNumber>;
+      id_token: alepha1672.TOptional<alepha1672.TString>;
+      scope: alepha1672.TOptional<alepha1672.TString>;
+      user: alepha1672.TObject<{
+        id: alepha1672.TString;
+        name: alepha1672.TOptional<alepha1672.TString>;
+        email: alepha1672.TOptional<alepha1672.TString>;
+        username: alepha1672.TOptional<alepha1672.TString>;
+        picture: alepha1672.TOptional<alepha1672.TString>;
+        sessionId: alepha1672.TOptional<alepha1672.TString>;
+        organizations: alepha1672.TOptional<alepha1672.TArray<alepha1672.TString>>;
+        roles: alepha1672.TOptional<alepha1672.TArray<alepha1672.TString>>;
       }>;
-      api: alepha1223.TObject<{
-        prefix: alepha1223.TOptional<alepha1223.TString>;
-        links: alepha1223.TArray<alepha1223.TObject<{
-          name: alepha1223.TString;
-          group: alepha1223.TOptional<alepha1223.TString>;
-          path: alepha1223.TString;
-          method: alepha1223.TOptional<alepha1223.TString>;
-          requestBodyType: alepha1223.TOptional<alepha1223.TString>;
-          service: alepha1223.TOptional<alepha1223.TString>;
+      api: alepha1672.TObject<{
+        prefix: alepha1672.TOptional<alepha1672.TString>;
+        links: alepha1672.TArray<alepha1672.TObject<{
+          name: alepha1672.TString;
+          group: alepha1672.TOptional<alepha1672.TString>;
+          path: alepha1672.TString;
+          method: alepha1672.TOptional<alepha1672.TString>;
+          requestBodyType: alepha1672.TOptional<alepha1672.TString>;
+          service: alepha1672.TOptional<alepha1672.TString>;
         }>>;
       }>;
     }>;
@@ -5341,28 +5329,28 @@ declare class ServerAuthProvider {
   /**
    * Oauth2/OIDC login route.
    */
-  readonly login: RouteDescriptor<{
-    query: alepha1223.TObject<{
-      provider: alepha1223.TString;
-      redirect_uri: alepha1223.TOptional<alepha1223.TString>;
+  readonly login: RoutePrimitive<{
+    query: alepha1672.TObject<{
+      provider: alepha1672.TString;
+      redirect_uri: alepha1672.TOptional<alepha1672.TString>;
     }>;
   }>;
   /**
    * Callback for OAuth2/OIDC providers.
    * It handles the authorization code flow and retrieves the access token.
    */
-  readonly callback: RouteDescriptor<RequestConfigSchema>;
+  readonly callback: RoutePrimitive<RequestConfigSchema>;
   /**
    * Logout route for OAuth2/OIDC providers.
    */
-  readonly logout: RouteDescriptor<{
-    query: alepha1223.TObject<{
-      post_logout_redirect_uri: alepha1223.TOptional<alepha1223.TString>;
+  readonly logout: RoutePrimitive<{
+    query: alepha1672.TObject<{
+      post_logout_redirect_uri: alepha1672.TOptional<alepha1672.TString>;
     }>;
   }>;
   protected provider(opts: string | {
     provider: string;
-  }): AuthDescriptor;
+  }): AuthPrimitive;
   protected setTokens(tokens: Tokens, cookies?: Cookies): void;
 }
 interface OAuth2Profile {
@@ -5396,8 +5384,8 @@ interface OAuth2Profile {
   [key: string]: unknown;
 }
 //#endregion
-//#region ../alepha/src/server-auth/descriptors/$auth.d.ts
-type AuthDescriptorOptions = {
+//#region ../alepha/src/server-auth/primitives/$auth.d.ts
+type AuthPrimitiveOptions = {
   /**
    * Name of the identity provider.
    * If not provided, it will be derived from the property key.
@@ -5438,7 +5426,7 @@ type AuthExternal = {
  * This relies on the `realm`, which is used to create/verify the access token.
  */
 type AuthInternal = {
-  realm: RealmDescriptor;
+  realm: RealmPrimitive;
 } & ({
   /**
    * The common username/password authentication.
@@ -5551,7 +5539,7 @@ interface OAuth2Options {
    */
   scope?: string;
 }
-declare class AuthDescriptor extends Descriptor<AuthDescriptorOptions> {
+declare class AuthPrimitive extends Primitive<AuthPrimitiveOptions> {
   protected readonly securityProvider: SecurityProvider;
   protected readonly dateTimeProvider: DateTimeProvider;
   oauth?: Configuration;
@@ -5615,53 +5603,53 @@ declare class UserRealmController {
    * Get realm configuration settings.
    * This endpoint is not exposed in the API documentation.
    */
-  readonly getRealmConfig: ActionDescriptorFn<{
-    query: alepha1223.TObject<{
-      userRealmName: alepha1223.TOptional<alepha1223.TString>;
+  readonly getRealmConfig: ActionPrimitiveFn<{
+    query: alepha1672.TObject<{
+      userRealmName: alepha1672.TOptional<alepha1672.TString>;
     }>;
-    response: alepha1223.TObject<{
-      settings: alepha1223.TObject<{
-        registrationAllowed: alepha1223.TBoolean;
-        emailEnabled: alepha1223.TBoolean;
-        emailRequired: alepha1223.TBoolean;
-        usernameEnabled: alepha1223.TBoolean;
-        usernameRequired: alepha1223.TBoolean;
-        phoneEnabled: alepha1223.TBoolean;
-        phoneRequired: alepha1223.TBoolean;
-        verifyEmailRequired: alepha1223.TBoolean;
-        verifyPhoneRequired: alepha1223.TBoolean;
-        firstNameLastNameEnabled: alepha1223.TBoolean;
-        firstNameLastNameRequired: alepha1223.TBoolean;
-        resetPasswordAllowed: alepha1223.TBoolean;
-        passwordPolicy: alepha1223.TObject<{
-          minLength: alepha1223.TInteger;
-          requireUppercase: alepha1223.TBoolean;
-          requireLowercase: alepha1223.TBoolean;
-          requireNumbers: alepha1223.TBoolean;
-          requireSpecialCharacters: alepha1223.TBoolean;
+    response: alepha1672.TObject<{
+      settings: alepha1672.TObject<{
+        registrationAllowed: alepha1672.TBoolean;
+        emailEnabled: alepha1672.TBoolean;
+        emailRequired: alepha1672.TBoolean;
+        usernameEnabled: alepha1672.TBoolean;
+        usernameRequired: alepha1672.TBoolean;
+        phoneEnabled: alepha1672.TBoolean;
+        phoneRequired: alepha1672.TBoolean;
+        verifyEmailRequired: alepha1672.TBoolean;
+        verifyPhoneRequired: alepha1672.TBoolean;
+        firstNameLastNameEnabled: alepha1672.TBoolean;
+        firstNameLastNameRequired: alepha1672.TBoolean;
+        resetPasswordAllowed: alepha1672.TBoolean;
+        passwordPolicy: alepha1672.TObject<{
+          minLength: alepha1672.TInteger;
+          requireUppercase: alepha1672.TBoolean;
+          requireLowercase: alepha1672.TBoolean;
+          requireNumbers: alepha1672.TBoolean;
+          requireSpecialCharacters: alepha1672.TBoolean;
         }>;
       }>;
-      realmName: alepha1223.TString;
-      authenticationMethods: alepha1223.TArray<alepha1223.TObject<{
-        name: alepha1223.TString;
-        type: alepha1223.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
+      realmName: alepha1672.TString;
+      authenticationMethods: alepha1672.TArray<alepha1672.TObject<{
+        name: alepha1672.TString;
+        type: alepha1672.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
       }>>;
     }>;
   }>;
-  readonly checkUsernameAvailability: ActionDescriptorFn<{
-    query: alepha1223.TObject<{
-      userRealmName: alepha1223.TOptional<alepha1223.TString>;
+  readonly checkUsernameAvailability: ActionPrimitiveFn<{
+    query: alepha1672.TObject<{
+      userRealmName: alepha1672.TOptional<alepha1672.TString>;
     }>;
-    body: alepha1223.TObject<{
-      username: alepha1223.TString;
+    body: alepha1672.TObject<{
+      username: alepha1672.TString;
     }>;
-    response: alepha1223.TObject<{
-      available: alepha1223.TBoolean;
+    response: alepha1672.TObject<{
+      available: alepha1672.TBoolean;
     }>;
   }>;
 }
 //#endregion
-//#region ../alepha/src/api-users/descriptors/$userRealm.d.ts
+//#region ../alepha/src/api-users/primitives/$userRealm.d.ts
 interface UserRealmOptions {
   /**
    * Secret key for signing tokens.
@@ -5674,7 +5662,7 @@ interface UserRealmOptions {
    *
    * It's already pre-configured for user management with admin and user roles.
    */
-  realm?: Partial<RealmDescriptorOptions>;
+  realm?: Partial<RealmPrimitiveOptions>;
   /**
    * Override entities.
    */
@@ -5692,32 +5680,32 @@ interface UserRealmOptions {
 }
 //#endregion
 //#region ../alepha/src/api-users/schemas/userRealmConfigSchema.d.ts
-declare const userRealmConfigSchema: alepha1223.TObject<{
-  settings: alepha1223.TObject<{
-    registrationAllowed: alepha1223.TBoolean;
-    emailEnabled: alepha1223.TBoolean;
-    emailRequired: alepha1223.TBoolean;
-    usernameEnabled: alepha1223.TBoolean;
-    usernameRequired: alepha1223.TBoolean;
-    phoneEnabled: alepha1223.TBoolean;
-    phoneRequired: alepha1223.TBoolean;
-    verifyEmailRequired: alepha1223.TBoolean;
-    verifyPhoneRequired: alepha1223.TBoolean;
-    firstNameLastNameEnabled: alepha1223.TBoolean;
-    firstNameLastNameRequired: alepha1223.TBoolean;
-    resetPasswordAllowed: alepha1223.TBoolean;
-    passwordPolicy: alepha1223.TObject<{
-      minLength: alepha1223.TInteger;
-      requireUppercase: alepha1223.TBoolean;
-      requireLowercase: alepha1223.TBoolean;
-      requireNumbers: alepha1223.TBoolean;
-      requireSpecialCharacters: alepha1223.TBoolean;
+declare const userRealmConfigSchema: alepha1672.TObject<{
+  settings: alepha1672.TObject<{
+    registrationAllowed: alepha1672.TBoolean;
+    emailEnabled: alepha1672.TBoolean;
+    emailRequired: alepha1672.TBoolean;
+    usernameEnabled: alepha1672.TBoolean;
+    usernameRequired: alepha1672.TBoolean;
+    phoneEnabled: alepha1672.TBoolean;
+    phoneRequired: alepha1672.TBoolean;
+    verifyEmailRequired: alepha1672.TBoolean;
+    verifyPhoneRequired: alepha1672.TBoolean;
+    firstNameLastNameEnabled: alepha1672.TBoolean;
+    firstNameLastNameRequired: alepha1672.TBoolean;
+    resetPasswordAllowed: alepha1672.TBoolean;
+    passwordPolicy: alepha1672.TObject<{
+      minLength: alepha1672.TInteger;
+      requireUppercase: alepha1672.TBoolean;
+      requireLowercase: alepha1672.TBoolean;
+      requireNumbers: alepha1672.TBoolean;
+      requireSpecialCharacters: alepha1672.TBoolean;
     }>;
   }>;
-  realmName: alepha1223.TString;
-  authenticationMethods: alepha1223.TArray<alepha1223.TObject<{
-    name: alepha1223.TString;
-    type: alepha1223.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
+  realmName: alepha1672.TString;
+  authenticationMethods: alepha1672.TArray<alepha1672.TObject<{
+    name: alepha1672.TString;
+    type: alepha1672.TUnsafe<"OAUTH2" | "OIDC" | "CREDENTIALS">;
   }>>;
 }>;
 type UserRealmConfig = Static<typeof userRealmConfigSchema>;
@@ -5757,9 +5745,9 @@ declare module "alepha/bucket" {
 //#region src/auth/AuthRouter.d.ts
 declare class AuthRouter {
   userRealmClient: HttpVirtualClient<UserRealmController>;
-  login: PageDescriptor<{
-    query: alepha1223.TObject<{
-      redirect: alepha1223.TOptional<alepha1223.TString>;
+  login: PagePrimitive<{
+    query: alepha1672.TObject<{
+      redirect: alepha1672.TOptional<alepha1672.TString>;
     }>;
   }, {
     realmConfig: {
@@ -5791,9 +5779,9 @@ declare class AuthRouter {
       }[];
     };
   }, TPropsParentDefault>;
-  register: PageDescriptor<{
-    query: alepha1223.TObject<{
-      redirect: alepha1223.TOptional<alepha1223.TString>;
+  register: PagePrimitive<{
+    query: alepha1672.TObject<{
+      redirect: alepha1672.TOptional<alepha1672.TString>;
     }>;
   }, {
     realmConfig: {
@@ -5825,9 +5813,9 @@ declare class AuthRouter {
       }[];
     };
   }, TPropsParentDefault>;
-  resetPassword: PageDescriptor<{
-    query: alepha1223.TObject<{
-      redirect: alepha1223.TOptional<alepha1223.TString>;
+  resetPassword: PagePrimitive<{
+    query: alepha1672.TObject<{
+      redirect: alepha1672.TOptional<alepha1672.TString>;
     }>;
   }, {
     realmConfig: {
@@ -5861,364 +5849,6 @@ declare class AuthRouter {
   }, TPropsParentDefault>;
 }
 //#endregion
-//#region ../react/src/form/services/FormModel.d.ts
-/**
- * FormModel is a dynamic form handler that generates form inputs based on a provided TypeBox schema.
- * It manages form state, handles input changes, and processes form submissions with validation.
- *
- * It means to be injected and used within React components to provide a structured way to create and manage forms.
- *
- * @see {@link useForm}
- */
-declare class FormModel<T$1 extends TObject> {
-  readonly id: string;
-  readonly options: FormCtrlOptions<T$1>;
-  protected readonly log: Logger;
-  protected readonly alepha: Alepha;
-  protected readonly values: Record<string, any>;
-  protected submitInProgress: boolean;
-  input: SchemaToInput<T$1>;
-  get submitting(): boolean;
-  constructor(id: string, options: FormCtrlOptions<T$1>);
-  get element(): HTMLFormElement;
-  get currentValues(): Record<string, any>;
-  get props(): {
-    id: string;
-    noValidate: boolean;
-    onSubmit: (ev?: FormEventLike) => void;
-    onReset: (event: FormEventLike) => Promise<void>;
-  };
-  readonly reset: (event: FormEventLike) => Promise<void>;
-  readonly submit: () => Promise<void>;
-  /**
-   * Restructures flat keys like "address.city" into nested objects like { address: { city: ... } }
-   * Values are already typed from onChange, so no conversion is needed.
-   */
-  protected restructureValues(store: Record<string, any>): Record<string, any>;
-  /**
-   * Helper to restructure a flat key like "address.city" into nested object structure.
-   * The value is already typed, so we just assign it to the nested path.
-   */
-  protected restructureNestedValue(values: Record<string, any>, key: string, value: any): void;
-  protected createProxyFromSchema<T$1 extends TObject>(options: FormCtrlOptions<T$1>, schema: TSchema, context: {
-    parent: string;
-    store: Record<string, any>;
-  }): SchemaToInput<T$1>;
-  protected createInputFromSchema<T$1 extends TObject>(name: keyof Static<T$1> & string, options: FormCtrlOptions<T$1>, schema: TObject, required: boolean, context: {
-    parent: string;
-    store: Record<string, any>;
-  }): InputField;
-  /**
-   * Convert an input value to the correct type based on the schema.
-   * Handles raw DOM values (strings, booleans from checkboxes, Files, etc.)
-   */
-  protected getValueFromInput(input: any, schema: TSchema): any;
-  protected valueToInputEntry(value: any): string | number | boolean;
-}
-type SchemaToInput<T$1 extends TObject> = { [K in keyof T$1["properties"]]: T$1["properties"][K] extends TObject ? SchemaToInput<T$1["properties"][K]> : InputField };
-interface FormEventLike {
-  preventDefault?: () => void;
-  stopPropagation?: () => void;
-}
-interface InputField {
-  path: string;
-  required: boolean;
-  props: InputHTMLAttributesLike;
-  schema: TSchema;
-  set: (value: any) => void;
-  form: FormModel<any>;
-}
-type InputHTMLAttributesLike = Pick<InputHTMLAttributes<unknown>, "id" | "name" | "type" | "value" | "defaultValue" | "required" | "maxLength" | "minLength" | "aria-label" | "autoComplete"> & {
-  value?: any;
-  defaultValue?: any;
-  onChange?: (event: any) => void;
-};
-type FormCtrlOptions<T$1 extends TObject> = {
-  /**
-   * The schema defining the structure and validation rules for the form.
-   * This should be a TypeBox schema object.
-   */
-  schema: T$1;
-  /**
-   * Callback function to handle form submission.
-   * This function will receive the parsed and validated form values.
-   */
-  handler: (values: Static<T$1>, args: {
-    form: HTMLFormElement;
-  }) => unknown;
-  /**
-   * Optional initial values for the form fields.
-   * This can be used to pre-populate the form with existing data.
-   */
-  initialValues?: Partial<Static<T$1>>;
-  /**
-   * Optional function to create custom field attributes.
-   * This can be used to add custom validation, styles, or other attributes.
-   */
-  onCreateField?: (name: keyof Static<T$1> & string, schema: TSchema) => InputHTMLAttributes<unknown>;
-  /**
-   * If defined, this will generate a unique ID for each field, prefixed with this string.
-   *
-   * > "username" with id="form-123" will become "form-123-username".
-   *
-   * If omitted, IDs will not be generated.
-   */
-  id?: string;
-  onError?: (error: Error, args: {
-    form: HTMLFormElement;
-  }) => void;
-  onChange?: (key: string, value: any, store: Record<string, any>) => void;
-  onReset?: () => void;
-};
-//#endregion
-//#region ../react/src/form/index.d.ts
-declare module "alepha" {
-  interface Hooks {
-    "form:change": {
-      id: string;
-      path: string;
-      value: any;
-    };
-    "form:reset": {
-      id: string;
-      values: Record<string, any>;
-    };
-    "form:submit:begin": {
-      id: string;
-    };
-    "form:submit:success": {
-      id: string;
-      values: Record<string, any>;
-    };
-    "form:submit:error": {
-      id: string;
-      error: Error;
-    };
-    "form:submit:end": {
-      id: string;
-    };
-  }
-}
-/**
- * React hooks for managing forms in Alepha applications.
- *
- * This module provides a set of hooks to simplify form handling, validation, and submission in React applications built with Alepha.
- *
- * It includes:
- * - `useForm`: A hook for managing form state, validation, and submission.
- *
- * @see {@link useForm}
- * @module alepha.react.form
- */
-//#endregion
-//#region src/core/utils/parseInput.d.ts
-interface GenericControlProps {
-  input: InputField;
-  title?: string;
-  description?: string;
-  icon?: ReactElement | ((props: {
-    size: number;
-  }) => ReactNode);
-}
-//#endregion
-//#region src/core/components/form/ControlNumber.d.ts
-interface ControlNumberProps extends GenericControlProps {
-  numberInputProps?: Partial<NumberInputProps>;
-  sliderProps?: Partial<SliderProps>;
-}
-//#endregion
-//#region src/core/components/form/ControlSelect.d.ts
-type SelectValueLabel = string | {
-  value: string;
-  label: string;
-  icon?: string;
-};
-interface ControlSelectProps extends GenericControlProps {
-  select?: boolean | SelectProps;
-  multi?: boolean | MultiSelectProps;
-  tags?: boolean | TagsInputProps;
-  autocomplete?: boolean | AutocompleteProps;
-  segmented?: boolean | Partial<SegmentedControlProps>;
-  loader?: () => Promise<SelectValueLabel[]>;
-}
-//#endregion
-//#region src/core/components/form/Control.d.ts
-interface ControlProps extends GenericControlProps {
-  text?: TextInputProps;
-  area?: boolean | TextareaProps;
-  select?: boolean | Partial<ControlSelectProps>;
-  password?: boolean | PasswordInputProps;
-  switch?: boolean | SwitchProps;
-  number?: boolean | Partial<ControlNumberProps>;
-  file?: boolean | FileInputProps;
-  color?: boolean | ColorInputProps;
-  date?: boolean | DateInputProps;
-  datetime?: boolean | DateTimePickerProps;
-  time?: boolean | TimeInputProps;
-  query?: any;
-  custom?: ComponentType<CustomControlProps>;
-}
-type CustomControlProps = {
-  defaultValue: any;
-  onChange: (value: any) => void;
-};
-//#endregion
-//#region src/core/components/buttons/ActionButton.d.ts
-interface ActionMenuItem {
-  /**
-   * Menu item type
-   */
-  type?: "item" | "divider" | "label";
-  /**
-   * Label text for the menu item
-   */
-  label?: string | ReactNode;
-  /**
-   * Icon element to display before the label
-   */
-  icon?: ReactNode;
-  /**
-   * Click handler for menu items
-   */
-  onClick?: () => void;
-  /**
-   * Href for navigation menu items
-   */
-  href?: string;
-  /**
-   * Color for the menu item (e.g., "red" for danger actions)
-   */
-  color?: string;
-  /**
-   * Nested submenu items
-   */
-  children?: ActionMenuItem[];
-  /**
-   * Whether the menu item is active
-   */
-  active?: boolean;
-}
-interface ActionMenuConfig {
-  /**
-   * Array of menu items to display
-   */
-  items: ActionMenuItem[];
-  /**
-   * Menu position relative to the button
-   */
-  position?: "bottom" | "bottom-start" | "bottom-end" | "top" | "top-start" | "top-end" | "left" | "right";
-  /**
-   * Menu width
-   */
-  width?: number | string;
-  /**
-   * Menu shadow
-   */
-  shadow?: "xs" | "sm" | "md" | "lg" | "xl";
-  on?: "hover" | "click";
-  targetProps?: MenuTargetProps;
-  menuProps?: MenuProps;
-}
-interface ActionCommonProps extends ButtonProps {
-  children?: ReactNode;
-  textVisibleFrom?: "xs" | "sm" | "md" | "lg" | "xl";
-  /**
-   * Tooltip to display on hover. Can be a string for simple tooltips
-   * or a TooltipProps object for advanced configuration.
-   */
-  tooltip?: string | TooltipProps;
-  /**
-   * Menu configuration. When provided, the action will display a dropdown menu.
-   */
-  menu?: ActionMenuConfig;
-  /**
-   * If set, a confirmation dialog will be shown before performing the action.
-   * If `true`, a default title and message will be used.
-   * If a string, it will be used as the message with a default title.
-   * If an object, it can contain `title` and `message` properties to customize the dialog.
-   */
-  confirm?: boolean | string | {
-    title?: string;
-    message: string;
-  };
-  /**
-   * Icon to display on the left side of the button.
-   * If no children are provided, the button will be styled as an icon-only button.
-   */
-  icon?: ReactNode | ComponentType;
-  /**
-   * Additional props to pass to the ThemeIcon wrapping the icon.
-   */
-  themeIconProps?: ThemeIconProps;
-}
-type ActionProps = ActionCommonProps & (ActionNavigationButtonProps | ActionClickButtonProps | ActionSubmitButtonProps | ActionHookButtonProps | {});
-interface ActionSubmitButtonProps extends ButtonProps {
-  form: FormModel<any>;
-  type?: "submit" | "reset";
-}
-interface ActionHookButtonProps extends ButtonProps {
-  action: UseActionReturn<any[], any>;
-}
-interface ActionClickButtonProps extends ButtonProps {
-  onClick: (e: any) => any;
-}
-interface ActionNavigationButtonProps extends ButtonProps {
-  href: string;
-  active?: Partial<UseActiveOptions> | false;
-  routerGoOptions?: RouterGoOptions;
-  classNameActive?: string;
-  variantActive?: ButtonProps["variant"];
-  target?: string;
-  anchorProps?: AnchorProps;
-}
-//#endregion
-//#region src/core/components/layout/AdminShell.d.ts
-declare module "alepha" {
-  interface State {
-    /**
-     * Whether the sidebar is opened or closed.
-     */
-    "alepha.ui.sidebar.opened"?: boolean;
-    /**
-     * Whether the sidebar is collapsed (narrow) or expanded (wide).
-     */
-    "alepha.ui.sidebar.collapsed"?: boolean;
-  }
-}
-//#endregion
-//#region src/core/index.d.ts
-declare module "typebox" {
-  interface TSchemaOptions {
-    $control?: Omit<ControlProps, "input">;
-  }
-}
-declare module "@alepha/react" {
-  interface PageDescriptorOptions {
-    /**
-     * Human-readable title for the page.
-     * - for Sidebar navigation
-     * - for Omnibar navigation
-     * (soon)
-     * - for Breadcrumbs
-     * - for document title (with AlephaReactHead)
-     */
-    label?: string;
-    /**
-     * Optional description of the page.
-     */
-    description?: string;
-    /**
-     * Optional icon for the page.
-     */
-    icon?: ReactNode;
-  }
-}
-/**
- * Mantine
- *
- * @module alepha.ui
- */
-//#endregion
 //#region src/auth/components/buttons/UserButton.d.ts
 interface UserButtonProps extends Omit<ActionProps, "menu" | "icon" | "onClick"> {
   /**
@@ -6268,7 +5898,7 @@ declare const ResetPassword: (props: ResetPasswordProps) => react_jsx_runtime0.J
  *
  * @module alepha.ui.auth
  */
-declare const AlephaUIAuth: alepha1223.Service<alepha1223.Module>;
+declare const AlephaUIAuth: alepha1672.Service<alepha1672.Module>;
 //#endregion
 export { AlephaUIAuth, AuthRouter, Login, Register, ResetPassword, UserButton, type UserButtonProps };
 //# sourceMappingURL=index.d.ts.map