@alepha/react 0.14.1 → 0.14.2

package/dist/router/index.d.ts

@@ -0,0 +1,1334 @@
+import { ClientOnlyProps } from "@alepha/react";
+import * as alepha12 from "alepha";
+import { Alepha, AlephaError, Async, KIND, Primitive, Static, TObject, TSchema } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
+import * as alepha_logger0 from "alepha/logger";
+import { LinkProvider } from "alepha/server/links";
+import { Route, RouterProvider } from "alepha/router";
+import * as react0 from "react";
+import { AnchorHTMLAttributes, CSSProperties, FC, ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as alepha_server0 from "alepha/server";
+import { ServerHandler, ServerRequest, ServerRouterProvider, ServerTimingProvider } from "alepha/server";
+import { ServerStaticProvider } from "alepha/server/static";
+import * as alepha_server_cache0 from "alepha/server/cache";
+import { ServerRouteCache } from "alepha/server/cache";
+
+//#region ../../src/router/errors/Redirection.d.ts
+
+/**
+ * Used for Redirection during the page loading.
+ *
+ * Depends on the context, it can be thrown or just returned.
+ *
+ * @example
+ * ```ts
+ * import { Redirection } from "@alepha/react";
+ *
+ * const MyPage = $page({
+ *   resolve: async () => {
+ *    if (needRedirect) {
+ *      throw new Redirection("/new-path");
+ *    }
+ *   },
+ * });
+ * ```
+ */
+declare class Redirection extends AlephaError {
+  readonly redirect: string;
+  constructor(redirect: string);
+}
+//#endregion
+//#region ../../src/router/providers/ReactPageProvider.d.ts
+declare const envSchema$2: alepha12.TObject<{
+  REACT_STRICT_MODE: alepha12.TBoolean;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$2>> {}
+}
+/**
+ * Handle page routes for React applications. (Browser and Server)
+ */
+declare class ReactPageProvider {
+  protected readonly log: alepha_logger0.Logger;
+  protected readonly env: {
+    REACT_STRICT_MODE: boolean;
+  };
+  protected readonly alepha: Alepha;
+  protected readonly pages: PageRoute[];
+  getPages(): PageRoute[];
+  getConcretePages(): ConcretePageRoute[];
+  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 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: alepha12.HookPrimitive<"configure">;
+  protected map(pages: Array<PagePrimitive>, target: PagePrimitive): 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<PagePrimitiveOptions, "children" | "parent"> {
+  children?: PageRouteEntry[];
+}
+interface ConcretePageRoute extends PageRoute {
+  /**
+   * When exported, static routes can be split into multiple pages with different params.
+   * We replace 'name' by the new name for each static entry, and old 'name' becomes 'staticName'.
+   */
+  staticName?: string;
+  params?: Record<string, string>;
+}
+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>;
+  name?: string;
+}
+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/router/services/ReactPageService.d.ts
+/**
+ * $page methods interface.
+ */
+declare abstract class ReactPageService {
+  fetch(pathname: string, options?: PagePrimitiveRenderOptions): Promise<{
+    html: string;
+    response: Response;
+  }>;
+  render(name: string, options?: PagePrimitiveRenderOptions): Promise<PagePrimitiveRenderResult>;
+}
+//#endregion
+//#region ../../src/router/primitives/$page.d.ts
+/**
+ * Main primitive for defining a React route in the application.
+ *
+ * The $page primitive 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: PagePrimitiveOptions<TConfig, TProps, TPropsParent>): PagePrimitive<TConfig, TProps, TPropsParent>;
+  [KIND]: typeof PagePrimitive;
+};
+interface PagePrimitiveOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
+  /**
+   * Identifier name for the page. Must be unique.
+   *
+   * @default Primitive 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 (params, query, etc.)
+   * - 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>;
+  /**
+   * Default props to pass to the component when rendering the page.
+   *
+   * Resolved props from the `resolve` function will override these default props.
+   */
+  props?: () => Partial<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<PagePrimitive> | (() => Array<PagePrimitive>);
+  /**
+   * Define a parent page for nested routing.
+   */
+  parent?: PagePrimitive<PageConfigSchema, TPropsParent, any>;
+  /**
+   * Function to determine if the page can be accessed.
+   *
+   * If it returns false, the page will not be accessible and a 403 Forbidden error will be returned.
+   * This function can be used to implement permission-based access control.
+   */
+  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 PagePrimitive<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Primitive<PagePrimitiveOptions<TConfig, TProps, TPropsParent>> {
+  protected readonly reactPageService: ReactPageService;
+  protected onInit(): void;
+  get name(): string;
+  /**
+   * 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?: PagePrimitiveRenderOptions): Promise<PagePrimitiveRenderResult>;
+  fetch(options?: PagePrimitiveRenderOptions): 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 PagePrimitiveRenderOptions {
+  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 PagePrimitiveRenderResult {
+  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 ../../src/router/providers/ReactBrowserRouterProvider.d.ts
+interface BrowserRoute extends Route {
+  page: PageRoute;
+}
+/**
+ * Implementation of AlephaRouter for React in browser environment.
+ */
+declare class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
+  protected readonly log: alepha_logger0.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly pageApi: ReactPageProvider;
+  add(entry: PageRouteEntry): void;
+  protected readonly configure: alepha12.HookPrimitive<"configure">;
+  transition(url: URL, previous?: PreviousLayerData[], meta?: {}): Promise<string | void>;
+  root(state: ReactRouterState): ReactNode;
+}
+//#endregion
+//#region ../../src/core/components/ClientOnly.d.ts
+interface ClientOnlyProps$1 {
+  fallback?: ReactNode;
+  disabled?: boolean;
+}
+//#endregion
+//#region ../../src/core/index.d.ts
+declare module "alepha" {
+  interface Hooks {
+    /**
+     * 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;
+    };
+  }
+}
+/**
+ * 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` primitive on class properties.
+ * It delivers seamless server-side rendering, automatic code splitting, and client-side navigation with full
+ * type safety and schema validation for route parameters and data.
+ *
+ * @see {@link $page}
+ * @module alepha.react
+ */
+//#endregion
+//#region ../../src/router/services/ReactRouter.d.ts
+interface RouterGoOptions {
+  replace?: boolean;
+  params?: Record<string, string>;
+  query?: Record<string, string>;
+  meta?: Record<string, any>;
+  /**
+   * Recreate the whole page, ignoring the current state.
+   */
+  force?: boolean;
+}
+/**
+ * Friendly browser router API.
+ *
+ * Can be safely used server-side, but most methods will be no-op.
+ */
+declare class ReactRouter<T$1 extends object> {
+  protected readonly alepha: Alepha;
+  protected readonly pageApi: ReactPageProvider;
+  get state(): ReactRouterState;
+  get pages(): PageRoute[];
+  get concretePages(): ConcretePageRoute[];
+  get browser(): ReactBrowserProvider | undefined;
+  isActive(href: string, options?: {
+    startWith?: boolean;
+  }): boolean;
+  node(name: keyof VirtualRouter<T$1> | string, config?: {
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+  }): {
+    label: any;
+    children: undefined;
+    type: "page";
+    name: string;
+    parent?: PageRoute;
+    match: string;
+    path?: string | undefined;
+    schema?: PageConfigSchema | undefined;
+    resolve?: ((context: PageResolve<PageConfigSchema, TPropsParentDefault>) => any) | undefined;
+    props?: (() => Partial<any>) | undefined;
+    component?: react0.FC<any> | undefined;
+    lazy?: (() => Promise<{
+      default: react0.FC<any>;
+    }>) | undefined;
+    can?: (() => boolean) | undefined;
+    errorHandler?: ErrorHandler | undefined;
+    static?: boolean | {
+      entries?: Partial<PageRequestConfig<PageConfigSchema>>[] | undefined;
+    } | undefined;
+    cache?: alepha_server_cache0.ServerRouteCache | undefined;
+    client?: (boolean | ClientOnlyProps$1) | undefined;
+    onServerResponse?: ((request: alepha_server0.ServerRequest) => unknown) | undefined;
+    onLeave?: (() => void) | undefined;
+    animation?: PageAnimation | undefined;
+  } | {
+    label: any;
+    href: string;
+    children: undefined;
+    type: "page";
+    name: string;
+    parent?: PageRoute;
+    match: string;
+    path?: string | undefined;
+    schema?: PageConfigSchema | undefined;
+    resolve?: ((context: PageResolve<PageConfigSchema, TPropsParentDefault>) => any) | undefined;
+    props?: (() => Partial<any>) | undefined;
+    component?: react0.FC<any> | undefined;
+    lazy?: (() => Promise<{
+      default: react0.FC<any>;
+    }>) | undefined;
+    can?: (() => boolean) | undefined;
+    errorHandler?: ErrorHandler | undefined;
+    static?: boolean | {
+      entries?: Partial<PageRequestConfig<PageConfigSchema>>[] | undefined;
+    } | undefined;
+    cache?: alepha_server_cache0.ServerRouteCache | undefined;
+    client?: (boolean | ClientOnlyProps$1) | undefined;
+    onServerResponse?: ((request: alepha_server0.ServerRequest) => unknown) | undefined;
+    onLeave?: (() => void) | undefined;
+    animation?: PageAnimation | undefined;
+  };
+  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 PagePrimitive ? K : never]: T$1[K] };
+//#endregion
+//#region ../../src/router/providers/ReactBrowserProvider.d.ts
+declare const envSchema$1: alepha12.TObject<{
+  REACT_ROOT_ID: alepha12.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$1>> {}
+}
+/**
+ * React browser renderer configuration atom
+ */
+declare const reactBrowserOptions: alepha12.Atom<alepha12.TObject<{
+  scrollRestoration: alepha12.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: alepha_logger0.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: alepha12.HookPrimitive<"react:transition:end">;
+  readonly ready: alepha12.HookPrimitive<"ready">;
+}
+type ReactHydrationState = {
+  layers?: Array<PreviousLayerData>;
+} & {
+  [key: string]: any;
+};
+interface RouterRenderOptions {
+  url?: string;
+  previous?: PreviousLayerData[];
+  meta?: Record<string, any>;
+}
+//#endregion
+//#region ../../src/router/components/ErrorViewer.d.ts
+interface ErrorViewerProps {
+  error: Error;
+  alepha: Alepha;
+}
+/**
+ * Error viewer component that displays error details in development mode
+ */
+declare const ErrorViewer: ({
+  error,
+  alepha
+}: ErrorViewerProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region ../../src/router/components/Link.d.ts
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+  href: string;
+}
+/**
+ * Link component for client-side navigation.
+ *
+ * It's a simple wrapper around an anchor (`<a>`) element using the `useRouter` hook.
+ */
+declare const Link: (props: LinkProps) => react0.DetailedReactHTMLElement<{
+  href: string;
+  onClick: (ev?: any) => any;
+  download?: any;
+  hrefLang?: string | undefined;
+  media?: string | undefined;
+  ping?: string | undefined;
+  target?: react0.HTMLAttributeAnchorTarget | undefined;
+  type?: string | undefined;
+  referrerPolicy?: react0.HTMLAttributeReferrerPolicy | undefined;
+  defaultChecked?: boolean | undefined;
+  defaultValue?: string | number | readonly string[] | undefined;
+  suppressContentEditableWarning?: boolean | undefined;
+  suppressHydrationWarning?: boolean | undefined;
+  accessKey?: string | undefined;
+  autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
+  autoFocus?: boolean | undefined;
+  className?: string | undefined;
+  contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+  contextMenu?: string | undefined;
+  dir?: string | undefined;
+  draggable?: (boolean | "true" | "false") | undefined;
+  enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
+  hidden?: boolean | undefined;
+  id?: string | undefined;
+  lang?: string | undefined;
+  nonce?: string | undefined;
+  slot?: string | undefined;
+  spellCheck?: (boolean | "true" | "false") | undefined;
+  style?: react0.CSSProperties | undefined;
+  tabIndex?: number | undefined;
+  title?: string | undefined;
+  translate?: "yes" | "no" | undefined;
+  radioGroup?: string | undefined;
+  role?: react0.AriaRole | undefined;
+  about?: string | undefined;
+  content?: string | undefined;
+  datatype?: string | undefined;
+  inlist?: any;
+  prefix?: string | undefined;
+  property?: string | undefined;
+  rel?: string | undefined;
+  resource?: string | undefined;
+  rev?: string | undefined;
+  typeof?: string | undefined;
+  vocab?: string | undefined;
+  autoCorrect?: string | undefined;
+  autoSave?: string | undefined;
+  color?: string | undefined;
+  itemProp?: string | undefined;
+  itemScope?: boolean | undefined;
+  itemType?: string | undefined;
+  itemID?: string | undefined;
+  itemRef?: string | undefined;
+  results?: number | undefined;
+  security?: string | undefined;
+  unselectable?: "on" | "off" | undefined;
+  popover?: "" | "auto" | "manual" | "hint" | undefined;
+  popoverTargetAction?: "toggle" | "show" | "hide" | undefined;
+  popoverTarget?: string | undefined;
+  inert?: boolean | undefined;
+  inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+  is?: string | undefined;
+  exportparts?: string | undefined;
+  part?: string | undefined;
+  "aria-activedescendant"?: string | undefined;
+  "aria-atomic"?: (boolean | "true" | "false") | undefined;
+  "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+  "aria-braillelabel"?: string | undefined;
+  "aria-brailleroledescription"?: string | undefined;
+  "aria-busy"?: (boolean | "true" | "false") | undefined;
+  "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+  "aria-colcount"?: number | undefined;
+  "aria-colindex"?: number | undefined;
+  "aria-colindextext"?: string | undefined;
+  "aria-colspan"?: number | undefined;
+  "aria-controls"?: string | undefined;
+  "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+  "aria-describedby"?: string | undefined;
+  "aria-description"?: string | undefined;
+  "aria-details"?: string | undefined;
+  "aria-disabled"?: (boolean | "true" | "false") | undefined;
+  "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+  "aria-errormessage"?: string | undefined;
+  "aria-expanded"?: (boolean | "true" | "false") | undefined;
+  "aria-flowto"?: string | undefined;
+  "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+  "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+  "aria-hidden"?: (boolean | "true" | "false") | undefined;
+  "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+  "aria-keyshortcuts"?: string | undefined;
+  "aria-label"?: string | undefined;
+  "aria-labelledby"?: string | undefined;
+  "aria-level"?: number | undefined;
+  "aria-live"?: "off" | "assertive" | "polite" | undefined;
+  "aria-modal"?: (boolean | "true" | "false") | undefined;
+  "aria-multiline"?: (boolean | "true" | "false") | undefined;
+  "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+  "aria-orientation"?: "horizontal" | "vertical" | undefined;
+  "aria-owns"?: string | undefined;
+  "aria-placeholder"?: string | undefined;
+  "aria-posinset"?: number | undefined;
+  "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+  "aria-readonly"?: (boolean | "true" | "false") | undefined;
+  "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+  "aria-required"?: (boolean | "true" | "false") | undefined;
+  "aria-roledescription"?: string | undefined;
+  "aria-rowcount"?: number | undefined;
+  "aria-rowindex"?: number | undefined;
+  "aria-rowindextext"?: string | undefined;
+  "aria-rowspan"?: number | undefined;
+  "aria-selected"?: (boolean | "true" | "false") | undefined;
+  "aria-setsize"?: number | undefined;
+  "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+  "aria-valuemax"?: number | undefined;
+  "aria-valuemin"?: number | undefined;
+  "aria-valuenow"?: number | undefined;
+  "aria-valuetext"?: string | undefined;
+  children?: react0.ReactNode | undefined;
+  dangerouslySetInnerHTML?: {
+    __html: string | TrustedHTML;
+  } | undefined;
+  onCopy?: react0.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+  onCopyCapture?: react0.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+  onCut?: react0.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+  onCutCapture?: react0.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+  onPaste?: react0.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+  onPasteCapture?: react0.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+  onCompositionEnd?: react0.CompositionEventHandler<HTMLAnchorElement> | undefined;
+  onCompositionEndCapture?: react0.CompositionEventHandler<HTMLAnchorElement> | undefined;
+  onCompositionStart?: react0.CompositionEventHandler<HTMLAnchorElement> | undefined;
+  onCompositionStartCapture?: react0.CompositionEventHandler<HTMLAnchorElement> | undefined;
+  onCompositionUpdate?: react0.CompositionEventHandler<HTMLAnchorElement> | undefined;
+  onCompositionUpdateCapture?: react0.CompositionEventHandler<HTMLAnchorElement> | undefined;
+  onFocus?: react0.FocusEventHandler<HTMLAnchorElement> | undefined;
+  onFocusCapture?: react0.FocusEventHandler<HTMLAnchorElement> | undefined;
+  onBlur?: react0.FocusEventHandler<HTMLAnchorElement> | undefined;
+  onBlurCapture?: react0.FocusEventHandler<HTMLAnchorElement> | undefined;
+  onChange?: react0.FormEventHandler<HTMLAnchorElement> | undefined;
+  onChangeCapture?: react0.FormEventHandler<HTMLAnchorElement> | undefined;
+  onBeforeInput?: react0.InputEventHandler<HTMLAnchorElement> | undefined;
+  onBeforeInputCapture?: react0.FormEventHandler<HTMLAnchorElement> | undefined;
+  onInput?: react0.FormEventHandler<HTMLAnchorElement> | undefined;
+  onInputCapture?: react0.FormEventHandler<HTMLAnchorElement> | undefined;
+  onReset?: react0.FormEventHandler<HTMLAnchorElement> | undefined;
+  onResetCapture?: react0.FormEventHandler<HTMLAnchorElement> | undefined;
+  onSubmit?: react0.FormEventHandler<HTMLAnchorElement> | undefined;
+  onSubmitCapture?: react0.FormEventHandler<HTMLAnchorElement> | undefined;
+  onInvalid?: react0.FormEventHandler<HTMLAnchorElement> | undefined;
+  onInvalidCapture?: react0.FormEventHandler<HTMLAnchorElement> | undefined;
+  onLoad?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onError?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onErrorCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onKeyDown?: react0.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+  onKeyDownCapture?: react0.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+  onKeyPress?: react0.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+  onKeyPressCapture?: react0.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+  onKeyUp?: react0.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+  onKeyUpCapture?: react0.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+  onAbort?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onAbortCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onCanPlay?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onCanPlayCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onCanPlayThrough?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onCanPlayThroughCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onDurationChange?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onDurationChangeCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onEmptied?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onEmptiedCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onEncrypted?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onEncryptedCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onEnded?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onEndedCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadedData?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadedDataCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadedMetadata?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadedMetadataCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadStart?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadStartCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onPause?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onPauseCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onPlay?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onPlayCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onPlaying?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onPlayingCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onProgress?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onProgressCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onRateChange?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onRateChangeCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSeeked?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSeekedCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSeeking?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSeekingCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onStalled?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onStalledCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSuspend?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSuspendCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onTimeUpdate?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onTimeUpdateCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onVolumeChange?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onVolumeChangeCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onWaiting?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onWaitingCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onAuxClick?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onAuxClickCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onClickCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onContextMenu?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onContextMenuCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onDoubleClick?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onDoubleClickCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onDrag?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragEnd?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragEndCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragEnter?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragEnterCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragExit?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragExitCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragLeave?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragLeaveCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragOver?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragOverCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragStart?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragStartCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDrop?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDropCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onMouseDown?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseDownCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseEnter?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseLeave?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseMove?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseMoveCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseOut?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseOutCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseOver?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseOverCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseUp?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseUpCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onSelect?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSelectCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onTouchCancel?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchCancelCapture?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchEnd?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchEndCapture?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchMove?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchMoveCapture?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchStart?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchStartCapture?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onPointerDown?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerDownCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerMove?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerMoveCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerUp?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerUpCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerCancel?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerCancelCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerEnter?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerLeave?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerOver?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerOverCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerOut?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerOutCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onGotPointerCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onGotPointerCaptureCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onLostPointerCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onLostPointerCaptureCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onScroll?: react0.UIEventHandler<HTMLAnchorElement> | undefined;
+  onScrollCapture?: react0.UIEventHandler<HTMLAnchorElement> | undefined;
+  onScrollEnd?: react0.UIEventHandler<HTMLAnchorElement> | undefined;
+  onScrollEndCapture?: react0.UIEventHandler<HTMLAnchorElement> | undefined;
+  onWheel?: react0.WheelEventHandler<HTMLAnchorElement> | undefined;
+  onWheelCapture?: react0.WheelEventHandler<HTMLAnchorElement> | undefined;
+  onAnimationStart?: react0.AnimationEventHandler<HTMLAnchorElement> | undefined;
+  onAnimationStartCapture?: react0.AnimationEventHandler<HTMLAnchorElement> | undefined;
+  onAnimationEnd?: react0.AnimationEventHandler<HTMLAnchorElement> | undefined;
+  onAnimationEndCapture?: react0.AnimationEventHandler<HTMLAnchorElement> | undefined;
+  onAnimationIteration?: react0.AnimationEventHandler<HTMLAnchorElement> | undefined;
+  onAnimationIterationCapture?: react0.AnimationEventHandler<HTMLAnchorElement> | undefined;
+  onToggle?: react0.ToggleEventHandler<HTMLAnchorElement> | undefined;
+  onBeforeToggle?: react0.ToggleEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionCancel?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionCancelCapture?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionEnd?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionEndCapture?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionRun?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionRunCapture?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionStart?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionStartCapture?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+}, HTMLElement>;
+//#endregion
+//#region ../../src/router/components/NestedView.d.ts
+interface NestedViewProps {
+  children?: ReactNode;
+  errorBoundary?: false | ((error: Error) => ReactNode);
+}
+declare const _default: react0.MemoExoticComponent<(props: NestedViewProps) => react_jsx_runtime0.JSX.Element>;
+//#endregion
+//#region ../../src/router/components/NotFound.d.ts
+/**
+ * Default 404 Not Found page component.
+ */
+declare const NotFound: (props: {
+  style?: CSSProperties;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region ../../src/router/contexts/RouterLayerContext.d.ts
+interface RouterLayerContextValue {
+  index: number;
+  path: string;
+  onError: ErrorHandler;
+}
+declare const RouterLayerContext: react0.Context<RouterLayerContextValue | undefined>;
+//#endregion
+//#region ../../src/router/hooks/useActive.d.ts
+interface UseActiveOptions {
+  href: string;
+  startWith?: boolean;
+}
+/**
+ * Hook to determine if a given route is active and to provide anchor props for navigation.
+ * This hook refreshes on router state changes.
+ */
+declare const useActive: (args: string | UseActiveOptions) => UseActiveHook;
+interface UseActiveHook {
+  isActive: boolean;
+  anchorProps: AnchorProps;
+  isPending: boolean;
+}
+//#endregion
+//#region ../../src/router/hooks/useQueryParams.d.ts
+/**
+ * Hook to manage query parameters in the URL using a defined schema.
+ */
+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/router/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/router/hooks/useRouterState.d.ts
+declare const useRouterState: () => ReactRouterState;
+//#endregion
+//#region ../../src/router/providers/ReactServerProvider.d.ts
+declare const envSchema: alepha12.TObject<{
+  REACT_SSR_ENABLED: alepha12.TOptional<alepha12.TBoolean>;
+  REACT_ROOT_ID: alepha12.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+  interface State {
+    "alepha.react.server.ssr"?: boolean;
+    "alepha.react.server.template"?: string;
+  }
+}
+/**
+ * React server provider configuration atom
+ */
+declare const reactServerOptions: alepha12.Atom<alepha12.TObject<{
+  publicDir: alepha12.TString;
+  staticServer: alepha12.TObject<{
+    disabled: alepha12.TBoolean;
+    path: alepha12.TString;
+  }>;
+}>, "alepha.react.server.options">;
+type ReactServerProviderOptions = Static<typeof reactServerOptions.schema>;
+declare module "alepha" {
+  interface State {
+    [reactServerOptions.key]: ReactServerProviderOptions;
+  }
+}
+/**
+ * React server provider responsible for SSR and static file serving.
+ *
+ * Use `react-dom/server` under the hood.
+ */
+declare class ReactServerProvider {
+  protected readonly log: alepha_logger0.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly env: {
+    REACT_SSR_ENABLED?: boolean | undefined;
+    REACT_ROOT_ID: string;
+  };
+  protected readonly pageApi: ReactPageProvider;
+  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: alepha12.HookPrimitive<"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?: PagePrimitiveRenderOptions): Promise<PagePrimitiveRenderResult>;
+  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/router/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 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 declarative routing with the `$page` primitive for building type-safe React routes.
+ *
+ * This module enables:
+ * - URL pattern matching with parameters (e.g., `/users/:id`)
+ * - Nested routing with parent-child relationships
+ * - Type-safe URL parameter and query string validation
+ * - Server-side data fetching with the `resolve` function
+ * - Lazy loading and code splitting
+ * - Page animations and error handling
+ *
+ * @see {@link $page}
+ * @module alepha.react.router
+ */
+declare const AlephaReactRouter: alepha12.Service<alepha12.Module>;
+//#endregion
+export { $page, AlephaReactRouter, AnchorProps, ConcretePageRoute, CreateLayersResult, ErrorHandler, ErrorViewer, Layer, Link, type LinkProps, _default as NestedView, NestedViewProps, NotFound, PageAnimation, PageConfigSchema, PagePrimitive, PagePrimitiveOptions, PagePrimitiveRenderOptions, PagePrimitiveRenderResult, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactBrowserRendererOptions, ReactHydrationState, ReactPageProvider, ReactPageService, ReactRouter, ReactRouterState, ReactServerProvider, ReactServerProviderOptions, Redirection, type RouterGoOptions, RouterLayerContext, RouterLayerContextValue, RouterRenderOptions, RouterStackItem, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, VirtualRouter, isPageRoute, reactBrowserOptions, reactServerOptions, useActive, useQueryParams, useRouter, useRouterState };
+//# sourceMappingURL=index.d.ts.map