@alepha/react 0.12.1 → 0.13.1

package/dist/core/index.d.cts

@@ -1,2763 +0,0 @@
-import * as alepha139 from "alepha";
-import { Alepha, AlephaError, Async, Atom, Descriptor, FileLike, Hook, Hooks, InstantiableClass, KIND, LogLevel, LoggerInterface, Service, State, Static, StreamLike, TArray, TAtomObject, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
-import { IncomingMessage, Server, ServerResponse } from "node:http";
-import dayjsDuration from "dayjs/plugin/duration.js";
-import DayjsApi, { Dayjs, ManipulateType, PluginFunc } from "dayjs";
-import { Readable } from "node:stream";
-import { ReadableStream } from "node:stream/web";
-import * as react1 from "react";
-import React, { AnchorHTMLAttributes, CSSProperties, DependencyList, ErrorInfo, FC, PropsWithChildren, ReactNode } from "react";
-import * as react_jsx_runtime0 from "react/jsx-runtime";
-
-//#region ../alepha/src/logger/schemas/logEntrySchema.d.ts
-declare const logEntrySchema: alepha139.TObject<{
-  level: alepha139.TUnsafe<"TRACE" | "SILENT" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
-  message: alepha139.TString;
-  service: alepha139.TString;
-  module: alepha139.TString;
-  context: alepha139.TOptional<alepha139.TString>;
-  app: alepha139.TOptional<alepha139.TString>;
-  data: alepha139.TOptional<alepha139.TAny>;
-  timestamp: alepha139.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: alepha139.HookDescriptor<"start">;
-  protected readonly onStop: alepha139.HookDescriptor<"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$1>(fn: (signal: AbortSignal) => Promise<T$1>, duration: DurationLike): Promise<T$1>;
-  /**
-   * 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$6: alepha139.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: alepha139.TOptional<alepha139.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: alepha139.TOptional<alepha139.TUnsafe<"json" | "pretty" | "raw">>;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$6>> {}
-  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/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;
-  /**
-   * 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/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/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: alepha139.HookDescriptor<"server:onRequest">;
-  readonly onResponse: alepha139.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;
-  /**
-   * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
-   */
-  protected readonly onNodeRequest: alepha139.HookDescriptor<"node:request">;
-  /**
-   * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
-   */
-  protected readonly onWebRequest: alepha139.HookDescriptor<"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/descriptors/$cache.d.ts
-interface CacheDescriptorOptions<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 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> {
-  /**
-   * Run the cache descriptor 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: 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> {
-  /**
-   * Key to identify the request in the pending requests.
-   */
-  key?: string;
-  /**
-   * The schema to validate the response against.
-   */
-  schema?: {
-    response?: T$1;
-  };
-  /**
-   * Built-in cache options.
-   */
-  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;
-}
-interface HttpAction {
-  method?: string;
-  prefix?: string;
-  path: string;
-  requestBodyType?: string;
-  schema?: {
-    params?: TObject;
-    query?: TObject;
-    body?: TRequestBody;
-    response?: TResponseBody;
-  };
-}
-//#endregion
-//#region ../alepha/src/server/descriptors/$action.d.ts
-interface ActionDescriptorOptions<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 ActionDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<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$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 {
-  /**
-   * 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/schemas/errorSchema.d.ts
-declare const errorSchema: alepha139.TObject<{
-  error: alepha139.TString;
-  status: alepha139.TInteger;
-  message: alepha139.TString;
-  details: alepha139.TOptional<alepha139.TString>;
-  requestId: alepha139.TOptional<alepha139.TString>;
-  cause: alepha139.TOptional<alepha139.TObject<{
-    name: alepha139.TString;
-    message: alepha139.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/providers/BunHttpServerProvider.d.ts
-declare const envSchema$5: alepha139.TObject<{
-  SERVER_PORT: alepha139.TInteger;
-  SERVER_HOST: alepha139.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$5>> {}
-}
-//#endregion
-//#region ../alepha/src/server/providers/NodeHttpServerProvider.d.ts
-declare const envSchema$4: alepha139.TObject<{
-  SERVER_PORT: alepha139.TInteger;
-  SERVER_HOST: alepha139.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$4>> {}
-}
-//#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;
-  }
-}
-//#endregion
-//#region ../alepha/src/server-cache/providers/ServerCacheProvider.d.ts
-declare module "alepha/server" {
-  interface ServerRoute {
-    /**
-     * Enable caching for this route.
-     * - If true: enables both store and etag
-     * - If object: fine-grained control over store, etag, and cache-control headers
-     *
-     * @default false
-     */
-    cache?: ServerRouteCache;
-  }
-  interface ActionDescriptor<TConfig extends RequestConfigSchema> {
-    invalidate: () => Promise<void>;
-  }
-}
-type ServerRouteCache =
-/**
- * If true, enables caching with:
- * - store: true
- * - etag: true
- */
-boolean
-/**
- * Object configuration for fine-grained cache control.
- *
- * If empty, no caching will be applied.
- */ | {
-  /**
-   * 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.
-   *
-   * @default false
-   */
-  store?: true | DurationLike | CacheDescriptorOptions;
-  /**
-   * If true, enables ETag support for the cached responses.
-   */
-  etag?: true;
-  /**
-   * - If true, sets Cache-Control to "public, max-age=300" (5 minutes).
-   * - If string, sets Cache-Control to the provided value directly.
-   * - If object, configures Cache-Control directives.
-   */
-  control?: true
-  /**
-   * If string, sets Cache-Control to the provided value directly.
-   */ | string
-  /**
-   * If object, configures Cache-Control directives.
-   */ | {
-    /**
-     * Indicates that the response may be cached by any cache.
-     */
-    public?: boolean;
-    /**
-     * Indicates that the response is intended for a single user and must not be stored by a shared cache.
-     */
-    private?: boolean;
-    /**
-     * Forces caches to submit the request to the origin server for validation before releasing a cached copy.
-     */
-    noCache?: boolean;
-    /**
-     * Instructs caches not to store the response.
-     */
-    noStore?: boolean;
-    /**
-     * Maximum amount of time a resource is considered fresh.
-     * Can be specified as a number (seconds) or as a DurationLike object.
-     *
-     * @example 300 // 5 minutes in seconds
-     * @example { minutes: 5 } // 5 minutes
-     * @example { hours: 1 } // 1 hour
-     */
-    maxAge?: number | DurationLike;
-    /**
-     * Overrides max-age for shared caches (e.g., CDNs).
-     * Can be specified as a number (seconds) or as a DurationLike object.
-     */
-    sMaxAge?: number | DurationLike;
-    /**
-     * Indicates that once a resource becomes stale, caches must not use it without successful validation.
-     */
-    mustRevalidate?: boolean;
-    /**
-     * Similar to must-revalidate, but only for shared caches.
-     */
-    proxyRevalidate?: boolean;
-    /**
-     * Indicates that the response can be stored but must be revalidated before each use.
-     */
-    immutable?: boolean;
-  };
-};
-//#endregion
-//#region src/core/components/ClientOnly.d.ts
-interface ClientOnlyProps {
-  fallback?: ReactNode;
-  disabled?: boolean;
-}
-/**
- * A small utility component that renders its children only on the client side.
- *
- * Optionally, you can provide a fallback React node that will be rendered.
- *
- * You should use this component when
- * - you have code that relies on browser-specific APIs
- * - you want to avoid server-side rendering for a specific part of your application
- * - you want to prevent pre-rendering of a component
- */
-declare const ClientOnly: (props: PropsWithChildren<ClientOnlyProps>) => ReactNode;
-//#endregion
-//#region src/core/errors/Redirection.d.ts
-/**
- * Used for Redirection during the page loading.
- *
- * Depends on the context, it can be thrown or just returned.
- */
-declare class Redirection extends Error {
-  readonly redirect: string;
-  constructor(redirect: string);
-}
-//#endregion
-//#region src/core/providers/ReactPageProvider.d.ts
-declare const envSchema$3: alepha139.TObject<{
-  REACT_STRICT_MODE: alepha139.TBoolean;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$3>> {}
-}
-declare class ReactPageProvider {
-  protected readonly log: Logger;
-  protected readonly env: {
-    REACT_STRICT_MODE: boolean;
-  };
-  protected readonly alepha: Alepha;
-  protected readonly pages: PageRoute[];
-  getPages(): PageRoute[];
-  getConcretePages(): PageRoute[];
-  page(name: string): PageRoute;
-  pathname(name: string, options?: {
-    params?: Record<string, string>;
-    query?: Record<string, string>;
-  }): string;
-  url(name: string, options?: {
-    params?: Record<string, string>;
-    host?: string;
-  }): URL;
-  root(state: ReactRouterState): ReactNode;
-  protected convertStringObjectToObject: (schema?: TSchema, value?: any) => any;
-  /**
-   * Create a new RouterState based on a given route and request.
-   * This method resolves the layers for the route, applying any query and params schemas defined in the route.
-   * It also handles errors and redirects.
-   */
-  createLayers(route: PageRoute, state: ReactRouterState, previous?: PreviousLayerData[]): Promise<CreateLayersResult>;
-  protected createRedirectionLayer(redirect: string): CreateLayersResult;
-  protected getErrorHandler(route: PageRoute): ErrorHandler | undefined;
-  protected createElement(page: PageRoute, props: Record<string, any>): Promise<ReactNode>;
-  renderError(error: Error): ReactNode;
-  renderEmptyView(): ReactNode;
-  href(page: {
-    options: {
-      name?: string;
-    };
-  }, params?: Record<string, any>): string;
-  compile(path: string, params?: Record<string, string>): string;
-  protected renderView(index: number, path: string, view: ReactNode | undefined, page: PageRoute): ReactNode;
-  protected readonly configure: alepha139.HookDescriptor<"configure">;
-  protected map(pages: Array<PageDescriptor>, target: PageDescriptor): PageRouteEntry;
-  add(entry: PageRouteEntry): void;
-  protected createMatch(page: PageRoute): string;
-  protected _next: number;
-  protected nextId(): string;
-}
-declare const isPageRoute: (it: any) => it is PageRoute;
-interface PageRouteEntry extends Omit<PageDescriptorOptions, "children" | "parent"> {
-  children?: PageRouteEntry[];
-}
-interface PageRoute extends PageRouteEntry {
-  type: "page";
-  name: string;
-  parent?: PageRoute;
-  match: string;
-}
-interface Layer {
-  config?: {
-    query?: Record<string, any>;
-    params?: Record<string, any>;
-    context?: Record<string, any>;
-  };
-  name: string;
-  props?: Record<string, any>;
-  error?: Error;
-  part?: string;
-  element: ReactNode;
-  index: number;
-  path: string;
-  route?: PageRoute;
-  cache?: boolean;
-}
-type PreviousLayerData = Omit<Layer, "element" | "index" | "path">;
-interface AnchorProps {
-  href: string;
-  onClick: (ev?: any) => any;
-}
-interface ReactRouterState {
-  /**
-   * Stack of layers for the current page.
-   */
-  layers: Array<Layer>;
-  /**
-   * URL of the current page.
-   */
-  url: URL;
-  /**
-   * Error handler for the current page.
-   */
-  onError: ErrorHandler;
-  /**
-   * Params extracted from the URL for the current page.
-   */
-  params: Record<string, any>;
-  /**
-   * Query parameters extracted from the URL for the current page.
-   */
-  query: Record<string, string>;
-  /**
-   * Optional meta information associated with the current page.
-   */
-  meta: Record<string, any>;
-}
-interface RouterStackItem {
-  route: PageRoute;
-  config?: Record<string, any>;
-  props?: Record<string, any>;
-  error?: Error;
-  cache?: boolean;
-}
-interface TransitionOptions {
-  previous?: PreviousLayerData[];
-}
-interface CreateLayersResult {
-  redirect?: string;
-  state?: ReactRouterState;
-}
-//#endregion
-//#region src/core/services/ReactPageService.d.ts
-declare class ReactPageService {
-  fetch(pathname: string, options?: PageDescriptorRenderOptions): Promise<{
-    html: string;
-    response: Response;
-  }>;
-  render(name: string, options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
-}
-//#endregion
-//#region src/core/descriptors/$page.d.ts
-/**
- * Main descriptor for defining a React route in the application.
- *
- * The $page descriptor is the core building block for creating type-safe, SSR-enabled React routes.
- * It provides a declarative way to define pages with powerful features:
- *
- * **Routing & Navigation**
- * - URL pattern matching with parameters (e.g., `/users/:id`)
- * - Nested routing with parent-child relationships
- * - Type-safe URL parameter and query string validation
- *
- * **Data Loading**
- * - Server-side data fetching with the `resolve` function
- * - Automatic serialization and hydration for SSR
- * - Access to request context, URL params, and parent data
- *
- * **Component Loading**
- * - Direct component rendering or lazy loading for code splitting
- * - Client-only rendering when browser APIs are needed
- * - Automatic fallback handling during hydration
- *
- * **Performance Optimization**
- * - Static generation for pre-rendered pages at build time
- * - Server-side caching with configurable TTL and providers
- * - Code splitting through lazy component loading
- *
- * **Error Handling**
- * - Custom error handlers with support for redirects
- * - Hierarchical error handling (child → parent)
- * - HTTP status code handling (404, 401, etc.)
- *
- * **Page Animations**
- * - CSS-based enter/exit animations
- * - Dynamic animations based on page state
- * - Custom timing and easing functions
- *
- * **Lifecycle Management**
- * - Server response hooks for headers and status codes
- * - Page leave handlers for cleanup (browser only)
- * - Permission-based access control
- *
- * @example Simple page with data fetching
- * ```typescript
- * const userProfile = $page({
- *   path: "/users/:id",
- *   schema: {
- *     params: t.object({ id: t.integer() }),
- *     query: t.object({ tab: t.optional(t.text()) })
- *   },
- *   resolve: async ({ params }) => {
- *     const user = await userApi.getUser(params.id);
- *     return { user };
- *   },
- *   lazy: () => import("./UserProfile.tsx")
- * });
- * ```
- *
- * @example Nested routing with error handling
- * ```typescript
- * const projectSection = $page({
- *   path: "/projects/:id",
- *   children: () => [projectBoard, projectSettings],
- *   resolve: async ({ params }) => {
- *     const project = await projectApi.get(params.id);
- *     return { project };
- *   },
- *   errorHandler: (error) => {
- *     if (HttpError.is(error, 404)) {
- *       return <ProjectNotFound />;
- *     }
- *   }
- * });
- * ```
- *
- * @example Static generation with caching
- * ```typescript
- * const blogPost = $page({
- *   path: "/blog/:slug",
- *   static: {
- *     entries: posts.map(p => ({ params: { slug: p.slug } }))
- *   },
- *   resolve: async ({ params }) => {
- *     const post = await loadPost(params.slug);
- *     return { post };
- *   }
- * });
- * ```
- */
-declare const $page: {
-  <TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = any, TPropsParent extends object = TPropsParentDefault>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
-  [KIND]: typeof PageDescriptor;
-};
-interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
-  /**
-   * Identifier name for the page. Must be unique.
-   *
-   * @default Descriptor key
-   */
-  name?: string;
-  /**
-   * Add a pathname to the page.
-   *
-   * Pathname can contain parameters, like `/post/:slug`.
-   *
-   * @default ""
-   */
-  path?: string;
-  /**
-   * Add an input schema to define:
-   * - `params`: parameters from the pathname.
-   * - `query`: query parameters from the URL.
-   */
-  schema?: TConfig;
-  /**
-   * Load data before rendering the page.
-   *
-   * This function receives
-   * - the request context and
-   * - the parent props (if page has a parent)
-   *
-   * In SSR, the returned data will be serialized and sent to the client, then reused during the client-side hydration.
-   *
-   * Resolve can be stopped by throwing an error, which will be handled by the `errorHandler` function.
-   * It's common to throw a `NotFoundError` to display a 404 page.
-   *
-   * RedirectError can be thrown to redirect the user to another page.
-   */
-  resolve?: (context: PageResolve<TConfig, TPropsParent>) => Async<TProps>;
-  /**
-   * The component to render when the page is loaded.
-   *
-   * If `lazy` is defined, this will be ignored.
-   * Prefer using `lazy` to improve the initial loading time.
-   */
-  component?: FC<TProps & TPropsParent>;
-  /**
-   * Lazy load the component when the page is loaded.
-   *
-   * It's recommended to use this for components to improve the initial loading time
-   * and enable code-splitting.
-   */
-  lazy?: () => Promise<{
-    default: FC<TProps & TPropsParent>;
-  }>;
-  /**
-   * Attach child pages to create nested routes.
-   * This will make the page a parent route.
-   */
-  children?: Array<PageDescriptor> | (() => Array<PageDescriptor>);
-  /**
-   * Define a parent page for nested routing.
-   */
-  parent?: PageDescriptor<PageConfigSchema, TPropsParent, any>;
-  can?: () => boolean;
-  /**
-   * Catch any error from the `resolve` function or during `rendering`.
-   *
-   * Expected to return one of the following:
-   * - a ReactNode to render an error page
-   * - a Redirection to redirect the user
-   * - undefined to let the error propagate
-   *
-   * If not defined, the error will be thrown and handled by the server or client error handler.
-   * If a leaf $page does not define an error handler, the error can be caught by parent pages.
-   *
-   * @example Catch a 404 from API and render a custom not found component:
-   * ```ts
-   * resolve: async ({ params, query }) => {
-   *    api.fetch("/api/resource", { params, query });
-   * },
-   * errorHandler: (error, context) => {
-   *   if (HttpError.is(error, 404)) {
-   *     return <ResourceNotFound />;
-   *   }
-   * }
-   * ```
-   *
-   * @example Catch an 401 error and redirect the user to the login page:
-   * ```ts
-   * resolve: async ({ params, query }) => {
-   *   // but the user is not authenticated
-   *   api.fetch("/api/resource", { params, query });
-   * },
-   * errorHandler: (error, context) => {
-   *   if (HttpError.is(error, 401)) {
-   *     // throwing a Redirection is also valid!
-   *     return new Redirection("/login");
-   *   }
-   * }
-   * ```
-   */
-  errorHandler?: ErrorHandler;
-  /**
-   * If true, the page will be considered as a static page, immutable and cacheable.
-   * Replace boolean by an object to define static entries. (e.g. list of params/query)
-   *
-   * Browser-side: it only works with `alepha/vite`, which can pre-render the page at build time.
-   *
-   * Server-side: It will act as timeless cached page. You can use `cache` to configure the cache behavior.
-   */
-  static?: boolean | {
-    entries?: Array<Partial<PageRequestConfig<TConfig>>>;
-  };
-  cache?: ServerRouteCache;
-  /**
-   * If true, force the page to be rendered only on the client-side (browser).
-   * It uses the `<ClientOnly/>` component to render the page.
-   */
-  client?: boolean | ClientOnlyProps;
-  /**
-   * Called before the server response is sent to the client. (server only)
-   */
-  onServerResponse?: (request: ServerRequest) => unknown;
-  /**
-   * Called when user leaves the page. (browser only)
-   */
-  onLeave?: () => void;
-  /**
-   * @experimental
-   *
-   * Add a css animation when the page is loaded or unloaded.
-   * It uses CSS animations, so you need to define the keyframes in your CSS.
-   *
-   * @example Simple animation name
-   * ```ts
-   * animation: "fadeIn"
-   * ```
-   *
-   * CSS example:
-   * ```css
-   * @keyframes fadeIn {
-   *  from { opacity: 0; }
-   *  to { opacity: 1; }
-   * }
-   * ```
-   *
-   * @example Detailed animation
-   * ```ts
-   * animation: {
-   *   enter: { name: "fadeIn", duration: 300 },
-   *   exit: { name: "fadeOut", duration: 200, timing: "ease-in-out" },
-   * }
-   * ```
-   *
-   * @example Only exit animation
-   * ```ts
-   * animation: {
-   *   exit: "fadeOut"
-   * }
-   * ```
-   *
-   * @example With custom timing function
-   * ```ts
-   * animation: {
-   *   enter: { name: "fadeIn", duration: 300, timing: "cubic-bezier(0.4, 0, 0.2, 1)" },
-   *   exit: { name: "fadeOut", duration: 200, timing: "ease-in-out" },
-   * }
-   * ```
-   */
-  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>> {
-  protected readonly reactPageService: ReactPageService;
-  protected onInit(): void;
-  get name(): string;
-  /**
-   * For testing or build purposes.
-   *
-   * 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<{
-    html: string;
-    response: Response;
-  }>;
-  match(url: string): boolean;
-  pathname(config: any): string;
-}
-interface PageConfigSchema {
-  query?: TSchema;
-  params?: TSchema;
-}
-type TPropsDefault = any;
-type TPropsParentDefault = {};
-interface PageDescriptorRenderOptions {
-  params?: Record<string, string>;
-  query?: Record<string, string>;
-  /**
-   * If true, the HTML layout will be included in the response.
-   * If false, only the page content will be returned.
-   *
-   * @default true
-   */
-  html?: boolean;
-  hydration?: boolean;
-}
-interface PageDescriptorRenderResult {
-  html: string;
-  state: ReactRouterState;
-  redirect?: string;
-}
-interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema> {
-  params: TConfig["params"] extends TSchema ? Static<TConfig["params"]> : Record<string, string>;
-  query: TConfig["query"] extends TSchema ? Static<TConfig["query"]> : Record<string, string>;
-}
-type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & Omit<ReactRouterState, "layers" | "onError">;
-type PageAnimation = PageAnimationObject | ((state: ReactRouterState) => PageAnimationObject | undefined);
-type PageAnimationObject = CssAnimationName | {
-  enter?: CssAnimation | CssAnimationName;
-  exit?: CssAnimation | CssAnimationName;
-};
-type CssAnimationName = string;
-type CssAnimation = {
-  name: string;
-  duration?: number;
-  timing?: string;
-};
-//#endregion
-//#region ../alepha/src/security/schemas/userAccountInfoSchema.d.ts
-declare const userAccountInfoSchema: alepha139.TObject<{
-  id: alepha139.TString;
-  name: alepha139.TOptional<alepha139.TString>;
-  email: alepha139.TOptional<alepha139.TString>;
-  username: alepha139.TOptional<alepha139.TString>;
-  picture: alepha139.TOptional<alepha139.TString>;
-  sessionId: alepha139.TOptional<alepha139.TString>;
-  organizations: alepha139.TOptional<alepha139.TArray<alepha139.TString>>;
-  roles: alepha139.TOptional<alepha139.TArray<alepha139.TString>>;
-}>;
-type UserAccount = Static<typeof userAccountInfoSchema>;
-//#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$2: alepha139.TObject<{
-  APP_SECRET: alepha139.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$2>> {}
-}
-//#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 descriptors 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: alepha139.TObject<{
-  name: alepha139.TString;
-  group: alepha139.TOptional<alepha139.TString>;
-  path: alepha139.TString;
-  method: alepha139.TOptional<alepha139.TString>;
-  requestBodyType: alepha139.TOptional<alepha139.TString>;
-  service: alepha139.TOptional<alepha139.TString>;
-}>;
-declare const apiLinksResponseSchema: alepha139.TObject<{
-  prefix: alepha139.TOptional<alepha139.TString>;
-  links: alepha139.TArray<alepha139.TObject<{
-    name: alepha139.TString;
-    group: alepha139.TOptional<alepha139.TString>;
-    path: alepha139.TString;
-    method: alepha139.TOptional<alepha139.TString>;
-    requestBodyType: alepha139.TOptional<alepha139.TString>;
-    service: alepha139.TOptional<alepha139.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$1 extends object>(scope?: ClientScope): HttpVirtualClient<T$1>;
-  /**
-   * 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$1 extends RequestConfigSchema>(name: string, scope?: ClientScope): VirtualAction<T$1>;
-  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$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"> {
-  (config?: ClientRequestEntry<T$1>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<T$1>>;
-  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` descriptors,
- * 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/core/providers/ReactBrowserRouterProvider.d.ts
-interface BrowserRoute extends Route {
-  page: PageRoute;
-}
-declare class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
-  protected readonly log: Logger;
-  protected readonly alepha: Alepha;
-  protected readonly pageApi: ReactPageProvider;
-  add(entry: PageRouteEntry): void;
-  protected readonly configure: alepha139.HookDescriptor<"configure">;
-  transition(url: URL, previous?: PreviousLayerData[], meta?: {}): Promise<string | void>;
-  root(state: ReactRouterState): ReactNode;
-}
-//#endregion
-//#region src/core/providers/ReactBrowserProvider.d.ts
-declare const envSchema$1: alepha139.TObject<{
-  REACT_ROOT_ID: alepha139.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$1>> {}
-}
-/**
- * React browser renderer configuration atom
- */
-declare const reactBrowserOptions: alepha139.Atom<alepha139.TObject<{
-  scrollRestoration: alepha139.TUnsafe<"top" | "manual">;
-}>, "alepha.react.browser.options">;
-type ReactBrowserRendererOptions = Static<typeof reactBrowserOptions.schema>;
-declare module "alepha" {
-  interface State {
-    [reactBrowserOptions.key]: ReactBrowserRendererOptions;
-  }
-}
-declare class ReactBrowserProvider {
-  protected readonly env: {
-    REACT_ROOT_ID: string;
-  };
-  protected readonly log: Logger;
-  protected readonly client: LinkProvider;
-  protected readonly alepha: Alepha;
-  protected readonly router: ReactBrowserRouterProvider;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly options: Readonly<{
-    scrollRestoration: "top" | "manual";
-  }>;
-  protected getRootElement(): HTMLElement;
-  transitioning?: {
-    to: string;
-    from?: string;
-  };
-  get state(): ReactRouterState;
-  /**
-   * Accessor for Document DOM API.
-   */
-  get document(): Document;
-  /**
-   * Accessor for History DOM API.
-   */
-  get history(): History;
-  /**
-   * Accessor for Location DOM API.
-   */
-  get location(): Location;
-  get base(): string;
-  get url(): string;
-  pushState(path: string, replace?: boolean): void;
-  invalidate(props?: Record<string, any>): Promise<void>;
-  go(url: string, options?: RouterGoOptions): Promise<void>;
-  protected render(options?: RouterRenderOptions): Promise<void>;
-  /**
-   * Get embedded layers from the server.
-   */
-  protected getHydrationState(): ReactHydrationState | undefined;
-  protected readonly onTransitionEnd: alepha139.HookDescriptor<"react:transition:end">;
-  readonly ready: alepha139.HookDescriptor<"ready">;
-}
-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;
-};
-interface RouterRenderOptions {
-  url?: string;
-  previous?: PreviousLayerData[];
-  meta?: Record<string, any>;
-}
-//#endregion
-//#region src/core/contexts/AlephaContext.d.ts
-declare const AlephaContext: react1.Context<Alepha | undefined>;
-//#endregion
-//#region src/core/hooks/useAction.d.ts
-/**
- * Hook for handling async actions with automatic error handling and event emission.
- *
- * By default, prevents concurrent executions - if an action is running and you call it again,
- * the second call will be ignored. Use `debounce` option to delay execution instead.
- *
- * Emits lifecycle events:
- * - `react:action:begin` - When action starts
- * - `react:action:success` - When action completes successfully
- * - `react:action:error` - When action throws an error
- * - `react:action:end` - Always emitted at the end
- *
- * @example Basic usage
- * ```tsx
- * const action = useAction({
- *   handler: async (data) => {
- *     await api.save(data);
- *   }
- * }, []);
- *
- * <button onClick={() => action.run(data)} disabled={action.loading}>
- *   Save
- * </button>
- * ```
- *
- * @example With debounce (search input)
- * ```tsx
- * const search = useAction({
- *   handler: async (query: string) => {
- *     await api.search(query);
- *   },
- *   debounce: 300 // Wait 300ms after last call
- * }, []);
- *
- * <input onChange={(e) => search.run(e.target.value)} />
- * ```
- *
- * @example Run on component mount
- * ```tsx
- * const fetchData = useAction({
- *   handler: async () => {
- *     const data = await api.getData();
- *     return data;
- *   },
- *   runOnInit: true // Runs once when component mounts
- * }, []);
- * ```
- *
- * @example Run periodically (polling)
- * ```tsx
- * const pollStatus = useAction({
- *   handler: async () => {
- *     const status = await api.getStatus();
- *     return status;
- *   },
- *   runEvery: 5000 // Run every 5 seconds
- * }, []);
- *
- * // Or with duration tuple
- * const pollStatus = useAction({
- *   handler: async () => {
- *     const status = await api.getStatus();
- *     return status;
- *   },
- *   runEvery: [30, 'seconds'] // Run every 30 seconds
- * }, []);
- * ```
- *
- * @example With AbortController
- * ```tsx
- * const fetch = useAction({
- *   handler: async (url, { signal }) => {
- *     const response = await fetch(url, { signal });
- *     return response.json();
- *   }
- * }, []);
- * // Automatically cancelled on unmount or when new request starts
- * ```
- *
- * @example With error handling
- * ```tsx
- * const deleteAction = useAction({
- *   handler: async (id: string) => {
- *     await api.delete(id);
- *   },
- *   onError: (error) => {
- *     if (error.code === 'NOT_FOUND') {
- *       // Custom error handling
- *     }
- *   }
- * }, []);
- *
- * {deleteAction.error && <div>Error: {deleteAction.error.message}</div>}
- * ```
- *
- * @example Global error handling
- * ```tsx
- * // In your root app setup
- * alepha.events.on("react:action:error", ({ error }) => {
- *   toast.danger(error.message);
- *   Sentry.captureException(error);
- * });
- * ```
- */
-declare function useAction<Args extends any[], Result = void>(options: UseActionOptions<Args, Result>, deps: DependencyList): UseActionReturn<Args, Result>;
-/**
- * Context object passed as the last argument to action handlers.
- * Contains an AbortSignal that can be used to cancel the request.
- */
-interface ActionContext {
-  /**
-   * AbortSignal that can be passed to fetch or other async operations.
-   * The signal will be aborted when:
-   * - The component unmounts
-   * - A new action is triggered (cancels previous)
-   * - The cancel() method is called
-   *
-   * @example
-   * ```tsx
-   * const action = useAction({
-   *   handler: async (url, { signal }) => {
-   *     const response = await fetch(url, { signal });
-   *     return response.json();
-   *   }
-   * }, []);
-   * ```
-   */
-  signal: AbortSignal;
-}
-interface UseActionOptions<Args extends any[] = any[], Result = any> {
-  /**
-   * The async action handler function.
-   * Receives the action arguments plus an ActionContext as the last parameter.
-   */
-  handler: (...args: [...Args, ActionContext]) => Promise<Result>;
-  /**
-   * Custom error handler. If provided, prevents default error re-throw.
-   */
-  onError?: (error: Error) => void | Promise<void>;
-  /**
-   * Custom success handler.
-   */
-  onSuccess?: (result: Result) => void | Promise<void>;
-  /**
-   * Optional identifier for this action (useful for debugging/analytics)
-   */
-  id?: string;
-  /**
-   * Debounce delay in milliseconds. If specified, the action will only execute
-   * after the specified delay has passed since the last call. Useful for search inputs
-   * or other high-frequency events.
-   *
-   * @example
-   * ```tsx
-   * // Execute search 300ms after user stops typing
-   * const search = useAction({ handler: search, debounce: 300 }, [])
-   * ```
-   */
-  debounce?: number;
-  /**
-   * If true, the action will be executed once when the component mounts.
-   *
-   * @example
-   * ```tsx
-   * const fetchData = useAction({
-   *   handler: async () => await api.getData(),
-   *   runOnInit: true
-   * }, []);
-   * ```
-   */
-  runOnInit?: boolean;
-  /**
-   * If specified, the action will be executed periodically at the given interval.
-   * The interval is specified as a DurationLike value (number in ms, Duration object, or [number, unit] tuple).
-   *
-   * @example
-   * ```tsx
-   * // Run every 5 seconds
-   * const poll = useAction({
-   *   handler: async () => await api.poll(),
-   *   runEvery: 5000
-   * }, []);
-   * ```
-   *
-   * @example
-   * ```tsx
-   * // Run every 1 minute
-   * const poll = useAction({
-   *   handler: async () => await api.poll(),
-   *   runEvery: [1, 'minute']
-   * }, []);
-   * ```
-   */
-  runEvery?: DurationLike;
-}
-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 src/core/hooks/useAlepha.d.ts
-/**
- * Main Alepha hook.
- *
- * It provides access to the Alepha instance within a React component.
- *
- * With Alepha, you can access the core functionalities of the framework:
- *
- * - alepha.state() for state management
- * - alepha.inject() for dependency injection
- * - alepha.events.emit() for event handling
- * etc...
- */
-declare const useAlepha: () => Alepha;
-//#endregion
-//#region src/core/hooks/useClient.d.ts
-/**
- * Hook to get a virtual client for the specified scope.
- *
- * It's the React-hook version of `$client()`, from `AlephaServerLinks` module.
- */
-declare const useClient: <T$1 extends object>(scope?: ClientScope) => HttpVirtualClient<T$1>;
-//#endregion
-//#region src/core/hooks/useEvents.d.ts
-/**
- * Allow subscribing to multiple Alepha events. See {@link Hooks} for available events.
- *
- * useEvents is fully typed to ensure correct event callback signatures.
- *
- * @example
- * ```tsx
- * useEvents(
- *   {
- *     "react:transition:begin": (ev) => {
- *       console.log("Transition began to:", ev.to);
- *     },
- *     "react:transition:error": {
- *       priority: "first",
- *       callback: (ev) => {
- *         console.error("Transition error:", ev.error);
- *       },
- *     },
- *   },
- *   [],
- * );
- * ```
- */
-declare const useEvents: (opts: UseEvents, deps: DependencyList) => void;
-type UseEvents = { [T in keyof Hooks]?: Hook<T> | ((payload: Hooks[T]) => Async<void>) };
-//#endregion
-//#region src/core/hooks/useInject.d.ts
-/**
- * Hook to inject a service instance.
- * It's a wrapper of `useAlepha().inject(service)` with a memoization.
- */
-declare const useInject: <T$1 extends object>(service: Service<T$1>) => T$1;
-//#endregion
-//#region src/core/hooks/useSchema.d.ts
-declare const useSchema: <TConfig extends RequestConfigSchema>(action: VirtualAction<TConfig>) => UseSchemaReturn<TConfig>;
-type UseSchemaReturn<TConfig extends RequestConfigSchema> = TConfig & {
-  loading: boolean;
-};
-/**
- * Get an action schema during server-side rendering (SSR) or client-side rendering (CSR).
- */
-declare const ssrSchemaLoading: (alepha: Alepha, name: string) => RequestConfigSchema | {
-  loading: boolean;
-};
-//#endregion
-//#region src/core/hooks/useStore.d.ts
-/**
- * Hook to access and mutate the Alepha state.
- */
-declare function useStore<T$1 extends TAtomObject>(target: Atom<T$1>, defaultValue?: Static<T$1>): UseStoreReturn<Static<T$1>>;
-declare function useStore<Key extends keyof State>(target: Key, defaultValue?: State[Key]): UseStoreReturn<State[Key]>;
-type UseStoreReturn<T$1> = [T$1, (value: T$1) => void];
-//#endregion
-//#region src/core/components/ErrorBoundary.d.ts
-/**
- * Props for the ErrorBoundary component.
- */
-interface ErrorBoundaryProps {
-  /**
-   * Fallback React node to render when an error is caught.
-   * If not provided, a default error message will be shown.
-   */
-  fallback: (error: Error) => ReactNode;
-  /**
-   * Optional callback that receives the error and error info.
-   * Use this to log errors to a monitoring service.
-   */
-  onError?: (error: Error, info: ErrorInfo) => void;
-}
-/**
- * State of the ErrorBoundary component.
- */
-interface ErrorBoundaryState {
-  error?: Error;
-}
-/**
- * A reusable error boundary for catching rendering errors
- * in any part of the React component tree.
- */
-declare class ErrorBoundary extends React.Component<PropsWithChildren<ErrorBoundaryProps>, ErrorBoundaryState> {
-  constructor(props: ErrorBoundaryProps);
-  /**
-   * Update state so the next render shows the fallback UI.
-   */
-  static getDerivedStateFromError(error: Error): ErrorBoundaryState;
-  /**
-   * Lifecycle method called when an error is caught.
-   * You can log the error or perform side effects here.
-   */
-  componentDidCatch(error: Error, info: ErrorInfo): void;
-  render(): ReactNode;
-}
-//#endregion
-//#region src/core/components/ErrorViewer.d.ts
-interface ErrorViewerProps {
-  error: Error;
-  alepha: Alepha;
-}
-declare const ErrorViewer: ({
-  error,
-  alepha
-}: ErrorViewerProps) => react_jsx_runtime0.JSX.Element;
-//#endregion
-//#region src/core/components/Link.d.ts
-interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
-  href: string;
-}
-declare const Link: (props: LinkProps) => react_jsx_runtime0.JSX.Element;
-//#endregion
-//#region src/core/components/NestedView.d.ts
-interface NestedViewProps {
-  children?: ReactNode;
-  errorBoundary?: false | ((error: Error) => ReactNode);
-}
-declare const _default: react1.MemoExoticComponent<(props: NestedViewProps) => react_jsx_runtime0.JSX.Element>;
-//#endregion
-//#region src/core/components/NotFound.d.ts
-declare function NotFoundPage(props: {
-  style?: CSSProperties;
-}): react_jsx_runtime0.JSX.Element;
-//#endregion
-//#region src/core/contexts/RouterLayerContext.d.ts
-interface RouterLayerContextValue {
-  index: number;
-  path: string;
-}
-declare const RouterLayerContext: react1.Context<RouterLayerContextValue | undefined>;
-//#endregion
-//#region src/core/hooks/useActive.d.ts
-interface UseActiveOptions {
-  href: string;
-  startWith?: boolean;
-}
-declare const useActive: (args: string | UseActiveOptions) => UseActiveHook;
-interface UseActiveHook {
-  isActive: boolean;
-  anchorProps: AnchorProps;
-  isPending: boolean;
-}
-//#endregion
-//#region src/core/hooks/useQueryParams.d.ts
-/**
- * Not well tested. Use with caution.
- */
-declare const useQueryParams: <T$1 extends TObject>(schema: T$1, options?: UseQueryParamsHookOptions) => [Partial<Static<T$1>>, (data: Static<T$1>) => void];
-interface UseQueryParamsHookOptions {
-  format?: "base64" | "querystring";
-  key?: string;
-  push?: boolean;
-}
-//#endregion
-//#region src/core/services/ReactRouter.d.ts
-declare class ReactRouter<T$1 extends object> {
-  protected readonly alepha: Alepha;
-  protected readonly pageApi: ReactPageProvider;
-  get state(): ReactRouterState;
-  get pages(): PageRoute[];
-  get concretePages(): PageRoute[];
-  get browser(): ReactBrowserProvider | undefined;
-  isActive(href: string, options?: {
-    startWith?: boolean;
-  }): boolean;
-  path(name: keyof VirtualRouter<T$1> | string, config?: {
-    params?: Record<string, any>;
-    query?: Record<string, any>;
-  }): string;
-  /**
-   * Reload the current page.
-   * This is equivalent to calling `go()` with the current pathname and search.
-   */
-  reload(): Promise<void>;
-  getURL(): URL;
-  get location(): Location;
-  get current(): ReactRouterState;
-  get pathname(): string;
-  get query(): Record<string, string>;
-  back(): Promise<void>;
-  forward(): Promise<void>;
-  invalidate(props?: Record<string, any>): Promise<void>;
-  go(path: string, options?: RouterGoOptions): Promise<void>;
-  go(path: keyof VirtualRouter<T$1>, options?: RouterGoOptions): Promise<void>;
-  anchor(path: string, options?: RouterGoOptions): AnchorProps;
-  anchor(path: keyof VirtualRouter<T$1>, options?: RouterGoOptions): AnchorProps;
-  base(path: string): string;
-  /**
-   * Set query params.
-   *
-   * @param record
-   * @param options
-   */
-  setQueryParams(record: Record<string, any> | ((queryParams: Record<string, any>) => Record<string, any>), options?: {
-    /**
-     * If true, this will add a new entry to the history stack.
-     */
-    push?: boolean;
-  }): void;
-}
-type VirtualRouter<T$1> = { [K in keyof T$1 as T$1[K] extends PageDescriptor ? K : never]: T$1[K] };
-//#endregion
-//#region src/core/hooks/useRouter.d.ts
-/**
- * Use this hook to access the React Router instance.
- *
- * You can add a type parameter to specify the type of your application.
- * This will allow you to use the router in a typesafe way.
- *
- * @example
- * class App {
- *   home = $page();
- * }
- *
- * const router = useRouter<App>();
- * router.go("home"); // typesafe
- */
-declare const useRouter: <T$1 extends object = any>() => ReactRouter<T$1>;
-//#endregion
-//#region src/core/hooks/useRouterState.d.ts
-declare const useRouterState: () => ReactRouterState;
-//#endregion
-//#region ../alepha/src/server-static/descriptors/$serve.d.ts
-interface ServeDescriptorOptions {
-  /**
-   * Prefix for the served path.
-   *
-   * @default "/"
-   */
-  path?: string;
-  /**
-   * Path to the directory to serve.
-   *
-   * @default process.cwd()
-   */
-  root?: string;
-  /**
-   * If true, descriptor will be ignored.
-   *
-   * @default false
-   */
-  disabled?: boolean;
-  /**
-   * Whether to keep dot files (e.g. `.gitignore`, `.env`) in the served directory.
-   *
-   * @default true
-   */
-  ignoreDotEnvFiles?: boolean;
-  /**
-   * Whether to use the index.html file when the path is a directory.
-   *
-   * @default true
-   */
-  indexFallback?: boolean;
-  /**
-   * Force all requests "not found" to be served with the index.html file.
-   * This is useful for single-page applications (SPAs) that use client-side only routing.
-   */
-  historyApiFallback?: boolean;
-  /**
-   * Optional name of the descriptor.
-   * This is used for logging and debugging purposes.
-   *
-   * @default Key name.
-   */
-  name?: string;
-  /**
-   * Whether to use cache control headers.
-   *
-   * @default {}
-   */
-  cacheControl?: Partial<CacheControlOptions> | false;
-}
-interface CacheControlOptions {
-  /**
-   * Whether to use cache control headers.
-   *
-   * @default [.js, .css]
-   */
-  fileTypes: string[];
-  /**
-   * The maximum age of the cache in seconds.
-   *
-   * @default 60 * 60 * 24 * 2 // 2 days
-   */
-  maxAge: DurationLike;
-  /**
-   * Whether to use immutable cache control headers.
-   *
-   * @default true
-   */
-  immutable: boolean;
-}
-//#endregion
-//#region ../alepha/src/file/services/FileDetector.d.ts
-interface FileTypeResult {
-  /**
-   * The detected MIME type
-   */
-  mimeType: string;
-  /**
-   * The detected file extension
-   */
-  extension: string;
-  /**
-   * Whether the file type was verified by magic bytes
-   */
-  verified: boolean;
-  /**
-   * The stream (potentially wrapped to allow re-reading)
-   */
-  stream: Readable;
-}
-/**
- * Service for detecting file types and getting content types.
- *
- * @example
- * ```typescript
- * const detector = alepha.inject(FileDetector);
- *
- * // Get content type from filename
- * const mimeType = detector.getContentType("image.png"); // "image/png"
- *
- * // Detect file type by magic bytes
- * const stream = createReadStream('image.png');
- * const result = await detector.detectFileType(stream, 'image.png');
- * console.log(result.mimeType); // 'image/png'
- * console.log(result.verified); // true if magic bytes match
- * ```
- */
-declare class FileDetector {
-  /**
-   * Magic byte signatures for common file formats.
-   * Each signature is represented as an array of bytes or null (wildcard).
-   */
-  protected static readonly MAGIC_BYTES: Record<string, {
-    signature: (number | null)[];
-    mimeType: string;
-  }[]>;
-  /**
-   * All possible format signatures for checking against actual file content
-   */
-  protected static readonly ALL_SIGNATURES: {
-    signature: (number | null)[];
-    mimeType: string;
-    ext: string;
-  }[];
-  /**
-   * MIME type map for file extensions.
-   *
-   * Can be used to get the content type of file based on its extension.
-   * Feel free to add more mime types in your project!
-   */
-  static readonly mimeMap: Record<string, string>;
-  /**
-   * Reverse MIME type map for looking up extensions from MIME types.
-   * Prefers shorter, more common extensions when multiple exist.
-   */
-  protected static readonly reverseMimeMap: Record<string, string>;
-  /**
-   * Returns the file extension for a given MIME type.
-   *
-   * @param mimeType - The MIME type to look up
-   * @returns The file extension (without dot), or "bin" if not found
-   *
-   * @example
-   * ```typescript
-   * const detector = alepha.inject(FileDetector);
-   * const ext = detector.getExtensionFromMimeType("image/png"); // "png"
-   * const ext2 = detector.getExtensionFromMimeType("application/octet-stream"); // "bin"
-   * ```
-   */
-  getExtensionFromMimeType(mimeType: string): string;
-  /**
-   * Returns the content type of file based on its filename.
-   *
-   * @param filename - The filename to check
-   * @returns The MIME type
-   *
-   * @example
-   * ```typescript
-   * const detector = alepha.inject(FileDetector);
-   * const mimeType = detector.getContentType("image.png"); // "image/png"
-   * ```
-   */
-  getContentType(filename: string): string;
-  /**
-   * Detects the file type by checking magic bytes against the stream content.
-   *
-   * @param stream - The readable stream to check
-   * @param filename - The filename (used to get the extension)
-   * @returns File type information including MIME type, extension, and verification status
-   *
-   * @example
-   * ```typescript
-   * const detector = alepha.inject(FileDetector);
-   * const stream = createReadStream('image.png');
-   * const result = await detector.detectFileType(stream, 'image.png');
-   * console.log(result.mimeType); // 'image/png'
-   * console.log(result.verified); // true if magic bytes match
-   * ```
-   */
-  detectFileType(stream: Readable, filename: string): Promise<FileTypeResult>;
-  /**
-   * Reads all bytes from a stream and returns the first N bytes along with a new stream containing all data.
-   * This approach reads the entire stream upfront to avoid complex async handling issues.
-   *
-   * @protected
-   */
-  protected peekBytes(stream: Readable, numBytes: number): Promise<{
-    buffer: Buffer;
-    stream: Readable;
-  }>;
-  /**
-   * Checks if a buffer matches a magic byte signature.
-   *
-   * @protected
-   */
-  protected matchesSignature(buffer: Buffer, signature: (number | null)[]): boolean;
-}
-//#endregion
-//#region ../alepha/src/server-static/providers/ServerStaticProvider.d.ts
-declare class ServerStaticProvider {
-  protected readonly alepha: Alepha;
-  protected readonly routerProvider: ServerRouterProvider;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly fileDetector: FileDetector;
-  protected readonly log: Logger;
-  protected readonly directories: ServeDirectory[];
-  protected readonly configure: alepha139.HookDescriptor<"configure">;
-  createStaticServer(options: ServeDescriptorOptions): Promise<void>;
-  createFileHandler(filepath: string, options: ServeDescriptorOptions): Promise<ServerHandler>;
-  protected getCacheFileTypes(): string[];
-  protected getCacheControl(filename: string, options: ServeDescriptorOptions): {
-    maxAge: number;
-    immutable: boolean;
-  } | undefined;
-  getAllFiles(dir: string, ignoreDotEnvFiles?: boolean): Promise<string[]>;
-}
-interface ServeDirectory {
-  options: ServeDescriptorOptions;
-  files: string[];
-}
-//#endregion
-//#region src/core/providers/ReactServerProvider.d.ts
-declare const envSchema: alepha139.TObject<{
-  REACT_SSR_ENABLED: alepha139.TOptional<alepha139.TBoolean>;
-  REACT_ROOT_ID: alepha139.TString;
-  REACT_SERVER_TEMPLATE: alepha139.TOptional<alepha139.TString>;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-  interface State {
-    "alepha.react.server.ssr"?: boolean;
-  }
-}
-/**
- * React server provider configuration atom
- */
-declare const reactServerOptions: alepha139.Atom<alepha139.TObject<{
-  publicDir: alepha139.TString;
-  staticServer: alepha139.TObject<{
-    disabled: alepha139.TBoolean;
-    path: alepha139.TString;
-  }>;
-}>, "alepha.react.server.options">;
-type ReactServerProviderOptions = Static<typeof reactServerOptions.schema>;
-declare module "alepha" {
-  interface State {
-    [reactServerOptions.key]: ReactServerProviderOptions;
-  }
-}
-declare class ReactServerProvider {
-  protected readonly log: Logger;
-  protected readonly alepha: Alepha;
-  protected readonly env: {
-    REACT_SSR_ENABLED?: boolean | undefined;
-    REACT_SERVER_TEMPLATE?: string | undefined;
-    REACT_ROOT_ID: string;
-  };
-  protected readonly pageApi: ReactPageProvider;
-  protected readonly serverProvider: ServerProvider;
-  protected readonly serverStaticProvider: ServerStaticProvider;
-  protected readonly serverRouterProvider: ServerRouterProvider;
-  protected readonly serverTimingProvider: ServerTimingProvider;
-  readonly ROOT_DIV_REGEX: RegExp;
-  protected preprocessedTemplate: PreprocessedTemplate | null;
-  protected readonly options: Readonly<{
-    publicDir: string;
-    staticServer: {
-      disabled: boolean;
-      path: string;
-    };
-  }>;
-  /**
-   * Configure the React server provider.
-   */
-  readonly onConfigure: alepha139.HookDescriptor<"configure">;
-  get template(): string;
-  protected registerPages(templateLoader: TemplateLoader): Promise<void>;
-  /**
-   * Get the public directory path where static files are located.
-   */
-  protected getPublicDirectory(): string;
-  /**
-   * Configure the static file server to serve files from the given root directory.
-   */
-  protected configureStaticServer(root: string): Promise<void>;
-  /**
-   * Configure Vite for SSR.
-   */
-  protected configureVite(ssrEnabled: boolean): Promise<void>;
-  /**
-   * For testing purposes, creates a render function that can be used.
-   */
-  render(name: string, options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
-  protected createHandler(route: PageRoute, templateLoader: TemplateLoader): ServerHandler;
-  renderToHtml(template: string, state: ReactRouterState, hydration?: boolean): string | Redirection;
-  protected preprocessTemplate(template: string): PreprocessedTemplate;
-  protected fillTemplate(response: {
-    html: string;
-  }, app: string, script: string): void;
-}
-type TemplateLoader = () => Promise<string | undefined>;
-interface PreprocessedTemplate {
-  beforeApp: string;
-  afterApp: string;
-  beforeScript: string;
-  afterScript: string;
-}
-//#endregion
-//#region src/core/index.d.ts
-declare module "alepha" {
-  interface State {
-    "alepha.react.router.state"?: ReactRouterState;
-  }
-  interface Hooks {
-    /**
-     * Fires when the React application is starting to be rendered on the server.
-     */
-    "react:server:render:begin": {
-      request?: ServerRequest;
-      state: ReactRouterState;
-    };
-    /**
-     * Fires when the React application has been rendered on the server.
-     */
-    "react:server:render:end": {
-      request?: ServerRequest;
-      state: ReactRouterState;
-      html: string;
-    };
-    /**
-     * Fires when the React application is being rendered on the browser.
-     */
-    "react:browser:render": {
-      root: HTMLElement;
-      element: ReactNode;
-      state: ReactRouterState;
-      hydration?: ReactHydrationState;
-    };
-    /**
-     * Fires when a user action is starting.
-     * Action can be a form submission, a route transition, or a custom action.
-     */
-    "react:action:begin": {
-      type: string;
-      id?: string;
-    };
-    /**
-     * Fires when a user action has succeeded.
-     * Action can be a form submission, a route transition, or a custom action.
-     */
-    "react:action:success": {
-      type: string;
-      id?: string;
-    };
-    /**
-     * Fires when a user action has failed.
-     * Action can be a form submission, a route transition, or a custom action.
-     */
-    "react:action:error": {
-      type: string;
-      id?: string;
-      error: Error;
-    };
-    /**
-     * Fires when a user action has completed, regardless of success or failure.
-     * Action can be a form submission, a route transition, or a custom action.
-     */
-    "react:action:end": {
-      type: string;
-      id?: string;
-    };
-    /**
-     * Fires when a route transition is starting.
-     */
-    "react:transition:begin": {
-      previous: ReactRouterState;
-      state: ReactRouterState;
-      animation?: PageAnimation;
-    };
-    /**
-     * Fires when a route transition has succeeded.
-     */
-    "react:transition:success": {
-      state: ReactRouterState;
-    };
-    /**
-     * Fires when a route transition has failed.
-     */
-    "react:transition:error": {
-      state: ReactRouterState;
-      error: Error;
-    };
-    /**
-     * Fires when a route transition has completed, regardless of success or failure.
-     */
-    "react:transition:end": {
-      state: ReactRouterState;
-    };
-  }
-}
-/**
- * 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.
- * 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.
- *
- * @see {@link $page}
- * @module alepha.react
- */
-declare const AlephaReact: alepha139.Service<alepha139.Module>;
-//#endregion
-export { $page, ActionContext, AlephaContext, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, ErrorHandler, ErrorViewer, Layer, Link, type LinkProps, _default as NestedView, NotFoundPage as NotFound, PageAnimation, PageConfigSchema, PageDescriptor, PageDescriptorOptions, PageDescriptorRenderOptions, PageDescriptorRenderResult, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactBrowserRendererOptions, ReactHydrationState, ReactPageProvider, ReactRouter, ReactRouterState, ReactServerProvider, ReactServerProviderOptions, Redirection, RouterGoOptions, RouterLayerContext, RouterLayerContextValue, RouterRenderOptions, RouterStackItem, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActionOptions, UseActionReturn, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, UseSchemaReturn, UseStoreReturn, VirtualRouter, isPageRoute, reactBrowserOptions, reactServerOptions, ssrSchemaLoading, useAction, useActive, useAlepha, useClient, useEvents, useInject, useQueryParams, useRouter, useRouterState, useSchema, useStore };
-//# sourceMappingURL=index.d.cts.map