@alepha/react 0.13.7 → 0.14.0

package/dist/auth/index.d.ts

@@ -1,1195 +1,11 @@
-import * as alepha20 from "alepha";
-import { Alepha, AlephaError, Async, FileLike, InstantiableClass, LogLevel, LoggerInterface, Primitive, Static, StreamLike, TArray, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
-import { IncomingMessage, Server, ServerResponse } from "node:http";
-import { Readable } from "node:stream";
-import { ReadableStream } from "node:stream/web";
-import dayjsDuration from "dayjs/plugin/duration.js";
-import DayjsApi, { Dayjs, ManipulateType, PluginFunc } from "dayjs";
+import * as alepha2 from "alepha";
+import { Alepha } from "alepha";
+import * as alepha_logger0 from "alepha/logger";
+import { HttpClient } from "alepha/server";
+import { Tokens } from "alepha/server/auth";
+import { HttpVirtualClient, LinkProvider } from "alepha/server/links";
+import { UserAccount, UserAccountToken } from "alepha/security";
 
-//#region ../../../alepha/src/security/schemas/userAccountInfoSchema.d.ts
-declare const userAccountInfoSchema: alepha20.TObject<{
-  id: alepha20.TString;
-  name: alepha20.TOptional<alepha20.TString>;
-  email: alepha20.TOptional<alepha20.TString>;
-  username: alepha20.TOptional<alepha20.TString>;
-  picture: alepha20.TOptional<alepha20.TString>;
-  sessionId: alepha20.TOptional<alepha20.TString>;
-  organizations: alepha20.TOptional<alepha20.TArray<alepha20.TString>>;
-  roles: alepha20.TOptional<alepha20.TArray<alepha20.TString>>;
-}>;
-type UserAccount = Static<typeof userAccountInfoSchema>;
-//#endregion
-//#region ../../../alepha/src/server/schemas/errorSchema.d.ts
-declare const errorSchema: alepha20.TObject<{
-  error: alepha20.TString;
-  status: alepha20.TInteger;
-  message: alepha20.TString;
-  details: alepha20.TOptional<alepha20.TString>;
-  requestId: alepha20.TOptional<alepha20.TString>;
-  cause: alepha20.TOptional<alepha20.TObject<{
-    name: alepha20.TString;
-    message: alepha20.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 extends Route = Route> {
-  protected routePathRegex: RegExp;
-  protected tree: Tree<T>;
-  protected cache: Map<string, RouteMatch<T>>;
-  match(path: string): RouteMatch<T>;
-  protected test(path: string): void;
-  protected push(route: T): void;
-  protected createRouteMatch(path: string): RouteMatch<T>;
-  protected mapParams(match: RouteMatch<T>): RouteMatch<T>;
-  protected createParts(path: string): string[];
-}
-interface RouteMatch<T extends Route> {
-  route?: T;
-  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 extends Route> {
-  route?: T;
-  children: {
-    [key: string]: Tree<T>;
-  };
-  param?: {
-    route?: T;
-    name: string;
-    children: {
-      [key: string]: Tree<T>;
-    };
-  };
-  wildcard?: {
-    route: T;
-  };
-}
-//#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: alepha20.TObject<{
-  level: alepha20.TUnsafe<"SILENT" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
-  message: alepha20.TString;
-  service: alepha20.TString;
-  module: alepha20.TString;
-  context: alepha20.TOptional<alepha20.TString>;
-  app: alepha20.TOptional<alepha20.TString>;
-  data: alepha20.TOptional<alepha20.TAny>;
-  timestamp: alepha20.TNumber;
-}>;
-type LogEntry = Static<typeof logEntrySchema>;
-//#endregion
-//#region ../../../alepha/src/datetime/providers/DateTimeProvider.d.ts
-type DateTime = DayjsApi.Dayjs;
-type Duration = dayjsDuration.Duration;
-type DurationLike = number | dayjsDuration.Duration | [number, ManipulateType];
-declare class DateTimeProvider {
-  static PLUGINS: Array<PluginFunc<any>>;
-  protected alepha: Alepha;
-  protected ref: DateTime | null;
-  protected readonly timeouts: Timeout[];
-  protected readonly intervals: Interval[];
-  constructor();
-  protected readonly onStart: alepha20.HookPrimitive<"start">;
-  protected readonly onStop: alepha20.HookPrimitive<"stop">;
-  setLocale(locale: string): void;
-  isDateTime(value: unknown): value is DateTime;
-  /**
-   * Create a new UTC DateTime instance.
-   */
-  utc(date: string | number | Date | Dayjs | null | undefined): DateTime;
-  /**
-   * Create a new DateTime instance.
-   */
-  of(date: string | number | Date | Dayjs | null | undefined): DateTime;
-  /**
-   * Get the current date as a string.
-   */
-  toISOString(date?: Date | string | DateTime): string;
-  /**
-   * Get the current date.
-   */
-  now(): DateTime;
-  /**
-   * Get the current date as a string.
-   *
-   * This is much faster than `DateTimeProvider.now().toISOString()` as it avoids creating a DateTime instance.
-   */
-  nowISOString(): string;
-  /**
-   * Get the current date as milliseconds since epoch.
-   *
-   * This is much faster than `DateTimeProvider.now().valueOf()` as it avoids creating a DateTime instance.
-   */
-  nowMillis(): number;
-  /**
-   * Get the current date as a string.
-   *
-   * @protected
-   */
-  protected getCurrentDate(): DateTime;
-  /**
-   * Create a new Duration instance.
-   */
-  duration: (duration: DurationLike, unit?: ManipulateType) => Duration;
-  isDurationLike(value: unknown): value is DurationLike;
-  /**
-   * Return a promise that resolves after the next tick.
-   * It uses `setTimeout` with 0 ms delay.
-   */
-  tick(): Promise<void>;
-  /**
-   * Wait for a certain duration.
-   *
-   * You can clear the timeout by using the `AbortSignal` API.
-   * Aborted signal will resolve the promise immediately, it does not reject it.
-   */
-  wait(duration: DurationLike, options?: {
-    signal?: AbortSignal;
-    now?: number;
-  }): Promise<void>;
-  createInterval(run: () => unknown, duration: DurationLike, start?: boolean): Interval;
-  /**
-   * Run a callback after a certain duration.
-   */
-  createTimeout(callback: () => void, duration: DurationLike, now?: number): Timeout;
-  clearTimeout(timeout: Timeout): void;
-  clearInterval(interval: Interval): void;
-  /**
-   * Run a function with a deadline.
-   */
-  deadline<T>(fn: (signal: AbortSignal) => Promise<T>, duration: DurationLike): Promise<T>;
-  /**
-   * Add time to the current date.
-   */
-  travel(duration: DurationLike, unit?: ManipulateType): Promise<void>;
-  /**
-   * Stop the time.
-   */
-  pause(): DateTime;
-  /**
-   * Reset the reference date.
-   */
-  reset(): void;
-}
-interface Interval {
-  timer?: any;
-  duration: number;
-  run: () => unknown;
-}
-interface Timeout {
-  now: number;
-  timer?: any;
-  duration: number;
-  callback: () => void;
-  clear: () => void;
-}
-//#endregion
-//#region ../../../alepha/src/logger/providers/LogDestinationProvider.d.ts
-declare abstract class LogDestinationProvider {
-  abstract write(message: string, entry: LogEntry): void;
-}
-//#endregion
-//#region ../../../alepha/src/logger/providers/LogFormatterProvider.d.ts
-declare abstract class LogFormatterProvider {
-  abstract format(entry: LogEntry): string;
-}
-//#endregion
-//#region ../../../alepha/src/logger/services/Logger.d.ts
-declare class Logger implements LoggerInterface {
-  protected readonly alepha: Alepha;
-  protected readonly formatter: LogFormatterProvider;
-  protected readonly destination: LogDestinationProvider;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly levels: Record<string, number>;
-  protected readonly service: string;
-  protected readonly module: string;
-  protected readonly app?: string;
-  protected appLogLevel: string;
-  protected logLevel: LogLevel;
-  constructor(service: string, module: string);
-  get context(): string | undefined;
-  get level(): string;
-  parseLevel(level: string, app: string): LogLevel;
-  private matchesPattern;
-  asLogLevel(something: string): LogLevel;
-  error(message: string, data?: unknown): void;
-  warn(message: string, data?: unknown): void;
-  info(message: string, data?: unknown): void;
-  debug(message: string, data?: unknown): void;
-  trace(message: string, data?: unknown): void;
-  protected log(level: LogLevel, message: string, data?: unknown): void;
-  protected emit(entry: LogEntry, message?: string): void;
-}
-//#endregion
-//#region ../../../alepha/src/logger/index.d.ts
-declare const envSchema$3: alepha20.TObject<{
-  /**
-   * Default log level for the application.
-   *
-   * Default by environment:
-   * - dev = info
-   * - prod = info
-   * - test = error
-   *
-   * Levels are: "trace" | "debug" | "info" | "warn" | "error" | "silent"
-   *
-   * Level can be set for a specific module:
-   *
-   * @example
-   * 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: alepha20.TOptional<alepha20.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 PrettyFormatterProvider}
-   * - "raw" - Raw format, no formatting, just the message.  {@link RawFormatterProvider}
-   */
-  LOG_FORMAT: alepha20.TOptional<alepha20.TUnsafe<"json" | "pretty" | "raw">>;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$3>> {}
-  interface State {
-    /**
-     * Current log level for the application or specific modules.
-     */
-    "alepha.logger.level"?: string;
-  }
-  interface Hooks {
-    log: {
-      message?: string;
-      entry: LogEntry;
-    };
-  }
-}
-//#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;
-}
-//#endregion
-//#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: alepha20.HookPrimitive<"server:onRequest">;
-  readonly onResponse: alepha20.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/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;
-  /**
-   * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
-   */
-  protected readonly onNodeRequest: alepha20.HookPrimitive<"node:request">;
-  /**
-   * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
-   */
-  protected readonly onWebRequest: alepha20.HookPrimitive<"web:request">;
-  /**
-   * Handle Node.js HTTP request event.
-   *
-   * Technically, we just convert Node.js request to Web Standard Request.
-   */
-  handleNodeRequest(nodeRequestEvent: NodeRequestEvent): Promise<void>;
-  /**
-   * Handle Web (Fetch API) request event.
-   */
-  handleWebRequest(ev: WebRequestEvent): Promise<void>;
-  /**
-   * Helper for Vite development mode to let Vite handle (or not) 404.
-   */
-  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 {
-  /**
-   * Get the value of a key.
-   *
-   * @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.
-   *
-   * @return The value of the key, or undefined if the key does not exist.
-   */
-  abstract get(name: string, key: string): Promise<Uint8Array | undefined>;
-  /**
-   * Set the string value of a key.
-   *
-   * @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.
-   *
-   * @return The value of the key.
-   */
-  abstract set(name: string, key: string, value: Uint8Array, ttl?: number): Promise<Uint8Array>;
-  /**
-   * Remove the specified keys.
-   *
-   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
-   * @param keys The keys to delete.
-   */
-  abstract del(name: string, ...keys: string[]): Promise<void>;
-  abstract has(name: string, key: string): Promise<boolean>;
-  abstract keys(name: string, filter?: string): Promise<string[]>;
-  /**
-   * Remove all keys from all cache names.
-   */
-  abstract clear(): Promise<void>;
-}
-//#endregion
-//#region ../../../alepha/src/cache/primitives/$cache.d.ts
-interface CachePrimitiveOptions<TReturn = any, TParameter extends any[] = any[]> {
-  /**
-   * The cache name. This is useful for invalidating multiple caches at once.
-   *
-   * Store key as `cache:$name:$key`.
-   *
-   * @default Name of the key of the class.
-   */
-  name?: string;
-  /**
-   * Function which returns cached data.
-   */
-  handler?: (...args: TParameter) => TReturn;
-  /**
-   * The key generator for the cache.
-   * If not provided, the arguments will be json.stringify().
-   */
-  key?: (...args: TParameter) => string;
-  /**
-   * 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.
-   *
-   * @default 300 (5 minutes).
-   */
-  ttl?: DurationLike;
-  /**
-   * If the cache is disabled.
-   */
-  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> {
-  /**
-   * Run the cache primitive with the provided arguments.
-   */
-  (...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: CachePrimitiveFn<HttpClientCache, any[]>;
-  protected readonly pendingRequests: HttpClientPendingRequests;
-  fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
-  fetch<T extends TSchema>(url: string, request?: RequestInitWithOptions<T>): Promise<FetchResponse<Static<T>>>;
-  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 extends TSchema = TSchema> {
-  /**
-   * Key to identify the request in the pending requests.
-   */
-  key?: string;
-  /**
-   * The schema to validate the response against.
-   */
-  schema?: {
-    response?: T;
-  };
-  /**
-   * Built-in cache options.
-   */
-  localCache?: boolean | number | DurationLike;
-}
-type RequestInitWithOptions<T extends TSchema = TSchema> = RequestInit & FetchOptions<T>;
-interface FetchResponse<T = any> {
-  data: T;
-  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/server/primitives/$action.d.ts
-interface ActionPrimitiveOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
-  /**
-   * 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;
-  /**
-   * 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.
-   */
-  path?: 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.)
-   */
-  method?: RouteMethod;
-  /**
-   * 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.
-   */
-  schema?: TConfig;
-  /**
-   * A short description of the action. Used for documentation purposes.
-   */
-  description?: string;
-  /**
-   * 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!
-   */
-  disabled?: boolean;
-  /**
-   * Main route handler. This is where the route logic is implemented.
-   */
-  handler: ServerActionHandler<TConfig>;
-}
-declare class ActionPrimitive<TConfig extends RequestConfigSchema> extends Primitive<ActionPrimitiveOptions<TConfig>> {
-  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;
-  /**
-   * 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 path(): string;
-  get schema(): TConfig | undefined;
-  getBodyContentType(): string | undefined;
-  /**
-   * Call the action handler directly.
-   * There is no HTTP layer involved.
-   */
-  run(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
-  /**
-   * Works like `run`, but always fetches (http request) the route.
-   */
-  fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
-}
-type ClientRequestEntry<TConfig extends RequestConfigSchema, T = ClientRequestEntryContainer<TConfig>> = { [K in keyof T as T[K] extends undefined ? never : K]: T[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 {
-  /**
-   * Standard request fetch options.
-   */
-  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/providers/BunHttpServerProvider.d.ts
-declare const envSchema$2: alepha20.TObject<{
-  SERVER_PORT: alepha20.TInteger;
-  SERVER_HOST: alepha20.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$2>> {}
-}
-//#endregion
-//#region ../../../alepha/src/server/providers/NodeHttpServerProvider.d.ts
-declare const envSchema$1: alepha20.TObject<{
-  SERVER_PORT: alepha20.TInteger;
-  SERVER_HOST: alepha20.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$1>> {}
-}
-//#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 {
-  /**
-   * 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;
-}
-//#endregion
-//#region ../../../alepha/src/security/providers/SecurityProvider.d.ts
-declare const envSchema: alepha20.TObject<{
-  APP_SECRET: alepha20.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-}
-//#endregion
-//#region ../../../alepha/src/security/index.d.ts
-declare module "alepha" {
-  interface Hooks {
-    "security:user:created": {
-      realm: string;
-      user: UserAccount;
-    };
-  }
-}
-/**
- * Provides comprehensive authentication and authorization capabilities with JWT tokens, role-based access control, and user management.
- *
- * 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.
- *
- * @see {@link $realm}
- * @see {@link $role}
- * @see {@link $permission}
- * @module alepha.security
- */
-//#endregion
-//#region ../../../alepha/src/server-security/providers/ServerBasicAuthProvider.d.ts
-interface BasicAuthOptions {
-  username: string;
-  password: string;
-}
-//#endregion
-//#region ../../../alepha/src/server-security/providers/ServerSecurityProvider.d.ts
-type ServerRouteSecure = {
-  realm?: string;
-  basic?: BasicAuthOptions;
-};
-//#endregion
-//#region ../../../alepha/src/server-security/index.d.ts
-declare module "alepha" {
-  interface State {
-    /**
-     * Real (or fake) user account, used for internal actions.
-     *
-     * If you define this, you assume that all actions are executed by this user by default.
-     * > To force a different user, you need to pass it explicitly in the options.
-     */
-    "alepha.server.security.system.user"?: UserAccountToken;
-    /**
-     * The authenticated user account attached to the server request state.
-     *
-     * @internal
-     */
-    "alepha.server.request.user"?: UserAccount;
-  }
-}
-declare module "alepha/server" {
-  interface ServerRequest<TConfig> {
-    user?: UserAccountToken;
-  }
-  interface ServerActionRequest<TConfig> {
-    user: UserAccountToken;
-  }
-  interface ServerRoute {
-    /**
-     * If true, the route will be protected by the security provider.
-     * All actions are secure by default, but you can disable it for specific actions.
-     */
-    secure?: boolean | ServerRouteSecure;
-  }
-  interface ClientRequestOptions extends FetchOptions {
-    /**
-     * Forward user from the previous request.
-     * If "system", use system user. @see {ServerSecurityProvider.localSystemUser}
-     * If "context", use the user from the current context (e.g. request).
-     *
-     * @default "system" if provided, else "context" if available.
-     */
-    user?: UserAccountToken | "system" | "context";
-  }
-}
-/**
- * Plugin for Alepha Server that provides security features. Based on the Alepha Security module.
- *
- * By default, all $action will be guarded by a permission check.
- *
- * @see {@link ServerSecurityProvider}
- * @module alepha.server.security
- */
-//#endregion
-//#region ../../../alepha/src/server-links/schemas/apiLinksResponseSchema.d.ts
-declare const apiLinkSchema: alepha20.TObject<{
-  name: alepha20.TString;
-  group: alepha20.TOptional<alepha20.TString>;
-  path: alepha20.TString;
-  method: alepha20.TOptional<alepha20.TString>;
-  requestBodyType: alepha20.TOptional<alepha20.TString>;
-  service: alepha20.TOptional<alepha20.TString>;
-}>;
-declare const apiLinksResponseSchema: alepha20.TObject<{
-  prefix: alepha20.TOptional<alepha20.TString>;
-  links: alepha20.TArray<alepha20.TObject<{
-    name: alepha20.TString;
-    group: alepha20.TOptional<alepha20.TString>;
-    path: alepha20.TString;
-    method: alepha20.TOptional<alepha20.TString>;
-    requestBodyType: alepha20.TOptional<alepha20.TString>;
-    service: alepha20.TOptional<alepha20.TString>;
-  }>>;
-}>;
-type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
-type ApiLink = Static<typeof apiLinkSchema>;
-//#endregion
-//#region ../../../alepha/src/server-links/providers/LinkProvider.d.ts
-/**
- * Browser, SSR friendly, service to handle links.
- */
-declare class LinkProvider {
-  static path: {
-    apiLinks: string;
-    apiSchema: string;
-  };
-  protected readonly log: Logger;
-  protected readonly alepha: Alepha;
-  protected readonly httpClient: HttpClient;
-  protected serverLinks: Array<HttpClientLink>;
-  /**
-   * Get applicative links registered on the server.
-   * This does not include lazy-loaded remote links.
-   */
-  getServerLinks(): HttpClientLink[];
-  /**
-   * Register a new link for the application.
-   */
-  registerLink(link: HttpClientLink): void;
-  get links(): HttpClientLink[];
-  /**
-   * Force browser to refresh links from the server.
-   */
-  fetchLinks(): Promise<HttpClientLink[]>;
-  /**
-   * Create a virtual client that can be used to call actions.
-   *
-   * Use js Proxy under the hood.
-   */
-  client<T extends object>(scope?: ClientScope): HttpVirtualClient<T>;
-  /**
-   * Check if a link with the given name exists.
-   * @param name
-   */
-  can(name: string): boolean;
-  /**
-   * Resolve a link by its name and call it.
-   * - If link is local, it will call the local handler.
-   * - If link is remote, it will make a fetch request to the remote server.
-   */
-  follow(name: string, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions & ClientScope): Promise<any>;
-  protected createVirtualAction<T extends RequestConfigSchema>(name: string, scope?: ClientScope): VirtualAction<T>;
-  protected followRemote(link: HttpClientLink, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions): Promise<FetchResponse>;
-  protected getLinkByName(name: string, options?: ClientScope): Promise<HttpClientLink>;
-}
-interface HttpClientLink extends ApiLink {
-  secured?: boolean | ServerRouteSecure;
-  prefix?: string;
-  host?: string;
-  service?: string;
-  schema?: RequestConfigSchema;
-  handler?: (request: ServerRequest, options: ClientRequestOptions) => Async<ServerResponseBody>;
-}
-interface ClientScope {
-  group?: string;
-  service?: string;
-  hostname?: string;
-}
-type HttpVirtualClient<T> = { [K in keyof T as T[K] extends ActionPrimitive<RequestConfigSchema> ? K : never]: T[K] extends ActionPrimitive<infer Schema> ? VirtualAction<Schema> : never };
-interface VirtualAction<T extends RequestConfigSchema> extends Pick<ActionPrimitive<T>, "name" | "run" | "fetch"> {
-  (config?: ClientRequestEntry<T>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<T>>;
-  can: () => boolean;
-}
-//#endregion
-//#region ../../../alepha/src/server-links/index.d.ts
-declare module "alepha" {
-  interface State {
-    /**
-     * API links attached to the server request state.
-     *
-     * @see {@link ApiLinksResponse}
-     * @internal
-     */
-    "alepha.server.request.apiLinks"?: ApiLinksResponse;
-  }
-}
-/**
- * Provides server-side link management and remote capabilities for client-server interactions.
- *
- * 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.
- *
- * @see {@link $remote}
- * @see {@link $client}
- * @module alepha.server.links
- */
-//#endregion
 //#region ../../src/auth/hooks/useAuth.d.ts
 declare const useAuth: <T extends object = any>() => {
   user: {
@@ -1213,88 +29,17 @@ declare const useAuth: <T extends object = any>() => {
   can: <Api extends object = any>(name: keyof HttpVirtualClient<Api>) => boolean;
 };
 //#endregion
-//#region ../../../alepha/src/server-auth/schemas/tokensSchema.d.ts
-declare const tokensSchema: alepha20.TObject<{
-  provider: alepha20.TString;
-  access_token: alepha20.TString;
-  issued_at: alepha20.TNumber;
-  expires_in: alepha20.TOptional<alepha20.TNumber>;
-  refresh_token: alepha20.TOptional<alepha20.TString>;
-  refresh_token_expires_in: alepha20.TOptional<alepha20.TNumber>;
-  refresh_expires_in: alepha20.TOptional<alepha20.TNumber>;
-  id_token: alepha20.TOptional<alepha20.TString>;
-  scope: alepha20.TOptional<alepha20.TString>;
-}>;
-type Tokens = Static<typeof tokensSchema>;
-//#endregion
-//#region ../../../alepha/src/server-cookies/primitives/$cookie.d.ts
-interface Cookies {
-  req: Record<string, string>;
-  res: Record<string, Cookie | null>;
-}
-interface Cookie {
-  value: string;
-  path?: string;
-  maxAge?: number;
-  secure?: boolean;
-  httpOnly?: boolean;
-  sameSite?: "strict" | "lax" | "none";
-  domain?: string;
-}
-//#endregion
-//#region ../../../alepha/src/server-cookies/index.d.ts
-declare module "alepha/server" {
-  interface ServerRequest {
-    cookies: Cookies;
-  }
-}
-/**
- * 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` 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.
- *
- * @see {@link $cookie}
- * @module alepha.server.cookies
- */
-//#endregion
-//#region ../../../alepha/src/server-auth/index.d.ts
-declare module "alepha" {
-  interface State {
-    /**
-     * The authenticated user account attached to the server request state.
-     *
-     * @internal
-     */
-    "alepha.server.request.user"?: UserAccount;
-  }
-}
-/**
- * Allow authentication services for server applications.
- * It provides login and logout functionalities.
- *
- * There are multiple authentication providers available (e.g., Google, GitHub).
- * You can also delegate authentication to your own OIDC/OAuth2, for example using Keycloak or Auth0.
- *
- * It's cookie-based and SSR friendly.
- *
- * @see {@link $auth}
- * @see {@link ServerAuthProvider}
- * @module alepha.server.auth
- */
-//#endregion
 //#region ../../src/auth/services/ReactAuth.d.ts
 /**
  * Browser, SSR friendly, service to handle authentication.
  */
 declare class ReactAuth {
-  protected readonly log: Logger;
+  protected readonly log: alepha_logger0.Logger;
   protected readonly alepha: Alepha;
   protected readonly httpClient: HttpClient;
   protected readonly linkProvider: LinkProvider;
-  protected readonly onBeginTransition: alepha20.HookPrimitive<"react:transition:begin">;
-  protected readonly onFetchRequest: alepha20.HookPrimitive<"client:onRequest">;
+  protected readonly onBeginTransition: alepha2.HookPrimitive<"react:transition:begin">;
+  protected readonly onFetchRequest: alepha2.HookPrimitive<"client:onRequest">;
   /**
    * Get the current authenticated user.
    *
@@ -1326,7 +71,7 @@ declare class ReactAuth {
 //#region ../../src/auth/providers/ReactAuthProvider.d.ts
 declare class ReactAuthProvider {
   protected readonly alepha: Alepha;
-  readonly onRender: alepha20.HookPrimitive<"react:server:render:begin">;
+  readonly onRender: alepha2.HookPrimitive<"react:server:render:begin">;
 }
 //#endregion
 //#region ../../src/auth/index.d.ts
@@ -1341,7 +86,7 @@ declare module "@alepha/react" {
  * @see {@link ReactAuthProvider}
  * @module alepha.react.auth
  */
-declare const AlephaReactAuth: alepha20.Service<alepha20.Module>;
+declare const AlephaReactAuth: alepha2.Service<alepha2.Module>;
 //#endregion
 export { AlephaReactAuth, ReactAuth, ReactAuthProvider, useAuth };
 //# sourceMappingURL=index.d.ts.map