@qwik.dev/router 2.0.0-beta.3 → 2.0.0-beta.31

package/lib/index.d.ts

@@ -1,17 +1,19 @@
 /// <reference path="./modules.d.ts" />
 
+import type { AsyncSignal } from '@qwik.dev/core';
 import { Component } from '@qwik.dev/core';
 import { Cookie } from '@qwik.dev/router/middleware/request-handler';
 import { CookieOptions } from '@qwik.dev/router/middleware/request-handler';
 import { CookieValue } from '@qwik.dev/router/middleware/request-handler';
 import { DeferReturn } from '@qwik.dev/router/middleware/request-handler';
 import type { EnvGetter } from '@qwik.dev/router/middleware/request-handler';
-import { JSXOutput as JSXOutput_2 } from '@qwik.dev/core';
+import { JSXOutput } from '@qwik.dev/core';
 import { QRL } from '@qwik.dev/core';
 import { QRLEventHandlerMulti } from '@qwik.dev/core';
 import { QwikIntrinsicElements } from '@qwik.dev/core';
 import { QwikJSX } from '@qwik.dev/core';
-import type { ReadonlySignal } from '@qwik.dev/core';
+import { Render } from '@qwik.dev/core/server';
+import { RenderOptions } from '@qwik.dev/core/server';
 import { RequestEvent } from '@qwik.dev/router/middleware/request-handler';
 import { RequestEventAction } from '@qwik.dev/router/middleware/request-handler';
 import { RequestEventBase } from '@qwik.dev/router/middleware/request-handler';
@@ -19,8 +21,11 @@ import { RequestEventCommon } from '@qwik.dev/router/middleware/request-handler'
 import { RequestEventLoader } from '@qwik.dev/router/middleware/request-handler';
 import { RequestHandler } from '@qwik.dev/router/middleware/request-handler';
 import type { ResolveSyncValue } from '@qwik.dev/router/middleware/request-handler';
+import type { SerializationStrategy } from '@qwik.dev/core/internal';
+import type { Signal } from '@qwik.dev/core';
 import type * as v from 'valibot';
 import type { ValueOrPromise } from '@qwik.dev/core';
+import { ValueOrPromise as ValueOrPromise_2 } from '@qwik.dev/core/internal';
 import { z } from 'zod';
 import type * as z_2 from 'zod';
 
@@ -156,6 +161,17 @@ export declare type ActionStore<RETURN, INPUT, OPTIONAL extends boolean = true>
 
 declare type AnchorAttributes = QwikIntrinsicElements['a'];
 
+/**
+ * The cacheKey export type. When exported from a page module alongside eTag, enables in-memory SSR
+ * caching.
+ *
+ * - `true`: use the default cache key `status|eTag|pathname`
+ * - Function: receives status, eTag, and pathname; returns a cache key string or null (no cache)
+ *
+ * @public
+ */
+export declare type CacheKeyFn = true | ((status: number, eTag: string, pathname: string) => string | null);
+
 /** @public */
 export declare interface ContentHeading {
     readonly text: string;
@@ -172,9 +188,17 @@ export declare interface ContentMenu {
 
 declare type ContentModule = PageModule | LayoutModule;
 
-declare type ContentModuleHead = DocumentHead | ResolvedDocumentHead;
+/**
+ * The eTag export type: a static string or a function receiving DocumentHeadProps.
+ *
+ * @public
+ */
+export declare type ContentModuleETag = string | ((props: DocumentHeadProps) => string | null);
+
+/** @public */
+export declare type ContentModuleHead = DocumentHead | ResolvedDocumentHead;
 
-declare type ContentModuleLoader = () => Promise<ContentModule>;
+declare type ContentModuleLoader = () => ValueOrPromise<ContentModule>;
 
 /** @public */
 declare interface ContentState {
@@ -188,6 +212,38 @@ export { CookieOptions }
 
 export { CookieValue }
 
+/**
+ * Creates the `render()` function that is required by `createQwikRouter()`. It requires a function
+ * that returns the `jsx` and `options` for the renderer.
+ *
+ * @example
+ *
+ * ```tsx
+ * const renderer = createRenderer((opts) => {
+ *   if (opts.requestHeaders['x-hello'] === 'world') {
+ *     return { jsx: <Hello />, options: opts };
+ *   }
+ *   return { jsx: <Root />, options: {
+ *     ...opts,
+ *     serverData: {
+ *       ...opts.serverData,
+ *       documentHead: {
+ *         meta: [
+ *           { name: 'renderedAt', content: new Date().toISOString() },
+ *         ],
+ *       },
+ *     },
+ *   } };
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare const createRenderer: (getOptions: (options: RendererOptions) => {
+    jsx: JSXOutput;
+    options: RendererOutputOptions;
+}) => Render;
+
 /** @public */
 export declare type DataValidator<T extends Record<string, any> = {}> = {
     validate(ev: RequestEvent, data: unknown): Promise<ValidatorReturn<T>>;
@@ -195,32 +251,48 @@ export declare type DataValidator<T extends Record<string, any> = {}> = {
 
 export { DeferReturn }
 
-/** @public */
-declare interface DevJSX {
-    fileName: string;
-    lineNumber: number;
-    columnNumber: number;
-    stack?: string;
-}
-
 /** @public */
 export declare type DocumentHead = DocumentHeadValue | ((props: DocumentHeadProps) => DocumentHeadValue);
 
 /** @public */
 export declare interface DocumentHeadProps extends RouteLocation {
     readonly head: ResolvedDocumentHead;
+    /** The HTTP status code of the response (e.g. 200, 404). */
+    readonly status: number;
+    /** @deprecated This is not necessary, it works correctly without */
     readonly withLocale: <T>(fn: () => T) => T;
     readonly resolveValue: ResolveSyncValue;
 }
 
+/**
+ * This renders all the tags collected from `head`.
+ *
+ * You can partially override the head, for example if you want to change the title:
+ *
+ * ```tsx
+ * import { DocumentHeadTags, useDocumentHead } from '@qwik.dev/router';
+ *
+ * export default component$(() => {
+ *   const head = useDocumentHead();
+ *   return <DocumentHeadTags title={`${head.title} - My App`} />;
+ * });
+ * ```
+ *
+ * You don't have to use this component, you can also do it yourself for full control. Just copy the
+ * code from this component and modify it to your needs.
+ *
+ * Note that this component normally only runs once, during SSR. You can use Signals in your
+ * `src/root.tsx` to make runtime changes to `<head>` if needed.
+ *
+ * @public
+ */
+export declare const DocumentHeadTags: Component<DocumentHeadValue<Record<string, unknown>>>;
+
 /** @public */
 export declare interface DocumentHeadValue<FrontMatter extends Record<string, any> = Record<string, unknown>> {
     /** Sets `document.title`. */
     readonly title?: string;
-    /**
-     * Used to manually set meta tags in the head. Additionally, the `data` property could be used to
-     * set arbitrary data which the `<head>` component could later use to generate `<meta>` tags.
-     */
+    /** Used to manually set meta tags in the head. */
     readonly meta?: readonly DocumentMeta[];
     /** Used to manually append `<link>` elements to the `<head>`. */
     readonly links?: readonly DocumentLink[];
@@ -237,53 +309,60 @@ export declare interface DocumentHeadValue<FrontMatter extends Record<string, an
 }
 
 /** @public */
-export declare interface DocumentLink {
-    as?: string;
-    crossorigin?: string;
-    disabled?: boolean;
-    href?: string;
-    hreflang?: string;
-    id?: string;
-    imagesizes?: string;
-    imagesrcset?: string;
-    integrity?: string;
-    media?: string;
-    prefetch?: string;
-    referrerpolicy?: string;
-    rel?: string;
-    sizes?: string;
-    title?: string;
-    type?: string;
-    key?: string;
-}
+export declare type DocumentLink = QwikIntrinsicElements['link'];
 
 /** @public */
-export declare interface DocumentMeta {
-    readonly content?: string;
-    readonly httpEquiv?: string;
-    readonly name?: string;
-    readonly property?: string;
-    readonly key?: string;
-    readonly itemprop?: string;
-    readonly media?: string;
-}
-
-/** @beta */
-export declare interface DocumentScript {
-    readonly script?: string;
-    readonly props?: Readonly<QwikIntrinsicElements['script']>;
-    readonly key?: string;
-}
+export declare type DocumentMeta = QwikIntrinsicElements['meta'];
 
 /** @public */
-export declare interface DocumentStyle {
-    readonly style: string;
-    readonly props?: Readonly<QwikIntrinsicElements['style']>;
-    readonly key?: string;
+export declare type DocumentScript = ((Omit<QwikIntrinsicElements['script'], 'dangerouslySetInnerHTML'> & {
+    props?: never;
+}) | {
+    key?: string;
+    /**
+     * The props of the script element. @deprecated Prefer setting the properties directly instead
+     * of using this property.
+     */
+    props: Readonly<QwikIntrinsicElements['script']>;
+}) & ({
+    /** The inline script content. */
+    script?: string;
+    dangerouslySetInnerHTML?: never;
+} | {
+    dangerouslySetInnerHTML?: string;
+    script?: never;
+});
+
+/** @public */
+export declare type DocumentStyle = Readonly<((Omit<QwikIntrinsicElements['style'], 'dangerouslySetInnerHTML'> & {
+    props?: never;
+}) | {
+    key?: string;
+    /**
+     * The props of the style element. @deprecated Prefer setting the properties directly
+     * instead of using this property.
+     */
+    props: Readonly<QwikIntrinsicElements['style']>;
+}) & ({
+    /** The inline style content. */
+    style?: string;
+    dangerouslySetInnerHTML?: never;
+} | {
+    dangerouslySetInnerHTML?: string;
+    style?: never;
+})>;
+
+declare type EndpointModuleLoader = () => ValueOrPromise<RouteModule>;
+
+declare interface EndpointResponse {
+    status: number;
+    statusMessage?: string;
+    loaders: Record<string, unknown>;
+    loadersSerializationStrategy: Map<string, SerializationStrategy>;
+    formData?: FormData;
+    action?: string;
 }
 
-declare type EndpointModuleLoader = () => Promise<RouteModule>;
-
 /** @public */
 export declare const ErrorBoundary: Component<ErrorBoundaryProps>;
 
@@ -303,7 +382,7 @@ export declare type FailOfRest<REST extends readonly DataValidator[]> = REST ext
 export declare type FailReturn<T> = T & Failed;
 
 /** @public */
-export declare const Form: <O, I>({ action, spaReset, reloadDocument, onSubmit$, ...rest }: FormProps<O, I>, key: string | null) => JSXOutput_2;
+export declare const Form: <O, I>({ action, spaReset, reloadDocument, onSubmit$, ...rest }: FormProps<O, I>, key: string | null) => JSXOutput;
 
 /** @public */
 export declare interface FormProps<O, I> extends Omit<QwikJSX.IntrinsicElements['form'], 'action' | 'method'> {
@@ -334,17 +413,6 @@ export declare interface FormSubmitSuccessDetail<T> {
     value: T;
 }
 
-/**
- * Any function taking a props object that returns JSXOutput.
- *
- * The `key`, `flags` and `dev` parameters are for internal use.
- *
- * @public
- */
-declare type FunctionComponent<P = unknown> = {
-    renderFn(props: P, key: string | null, flags: number, dev?: DevJSX): JSXOutput;
-}['renderFn'];
-
 /** @public */
 export declare type GetValidatorInputType<VALIDATOR extends TypedDataValidator> = VALIDATOR extends ValibotDataValidator<infer TYPE> ? v.InferInput<TYPE> : VALIDATOR extends ZodDataValidator<infer TYPE> ? z_2.input<TYPE> : never;
 
@@ -359,6 +427,14 @@ export declare const globalAction$: ActionConstructor;
 
 /* Excluded from this release type: globalActionQrl */
 
+/** @public */
+export declare type HttpErrorProps = {
+    /** The HTTP status code, e.g. 404 */
+    status: number;
+    /** The error message, e.g. "Not Found" */
+    message: string;
+};
+
 declare type IsAny<Type> = 0 extends 1 & Type ? true : false;
 
 /** @public */
@@ -371,31 +447,9 @@ export declare type JSONValue = string | number | boolean | {
     [x: string]: JSONValue;
 } | Array<JSONValue>;
 
-/** @public */
-declare type JSXChildren = string | number | boolean | null | undefined | Function | RegExp | JSXChildren[] | Promise<JSXChildren> | Signal<JSXChildren> | JSXNode;
-
-/**
- * A JSX Node, an internal structure. You probably want to use `JSXOutput` instead.
- *
- * @public
- */
-declare interface JSXNode<T extends string | FunctionComponent | unknown = unknown> {
-    type: T;
-    props: T extends FunctionComponent<infer P> ? P : Record<any, unknown>;
-    children: JSXChildren | null;
-    key: string | null;
-    dev?: DevJSX;
-}
-
-/**
- * Any valid output for a component
- *
- * @public
- */
-declare type JSXOutput = JSXNode | string | number | boolean | null | undefined | JSXOutput[];
-
 declare interface LayoutModule extends RouteModule {
-    readonly default: unknown;
+    readonly default?: (props: Record<string, never>) => JSXOutput;
+    readonly routeConfig?: RouteConfig;
     readonly head?: ContentModuleHead;
 }
 
@@ -412,7 +466,7 @@ export declare interface LinkProps extends AnchorAttributes {
      *
      * This **improves UX performance** for client-side (**SPA**) navigations.
      *
-     * Prefetching occurs when a the Link enters the viewport in production (**`on:qvisible`**), or
+     * Prefetching occurs when a the Link enters the viewport in production (**`q-e:qvisible`**), or
      * with **`mouseover`/`focus`** during dev.
      *
      * Prefetching will not occur if the user has the **data saver** setting enabled.
@@ -426,6 +480,24 @@ export declare interface LinkProps extends AnchorAttributes {
     scroll?: boolean;
 }
 
+/** The route to render */
+declare interface LoadedRoute {
+    /** The canonical path of the route, e.g. `/products/[id]` */
+    $routeName$: string;
+    /** The route parameters, e.g. `{ id: '123' }` */
+    $params$: PathParams;
+    /** The modules associated with this route (on 404, contains only the error component) */
+    $mods$: (RouteModule | ContentModule)[];
+    /** The menu associated with this route */
+    $menu$?: ContentMenu | undefined;
+    /** The bundle names for this route */
+    $routeBundleNames$?: string[] | undefined;
+    /** Whether this route is a not-found (404) route */
+    $notFound$?: boolean;
+    /** The error module loader (nearest _E ancestor), for rendering ServerErrors */
+    $errorLoader$?: ContentModuleLoader;
+}
+
 /** @public */
 declare type Loader_2<RETURN> = {
     /**
@@ -450,14 +522,13 @@ declare type LoaderConstructorQRL = {
 
 /** @public */
 declare type LoaderOptions = {
-    id?: string;
+    readonly id?: string;
+    readonly validation?: DataValidator[];
+    readonly serializationStrategy?: SerializationStrategy;
 };
 
 /** @public */
-export declare type LoaderSignal<TYPE> = TYPE extends () => ValueOrPromise<infer VALIDATOR> ? ReadonlySignal<ValueOrPromise<VALIDATOR>> : ReadonlySignal<TYPE>;
-
-/** @public */
-export declare type MenuData = [pathname: string, menuLoader: MenuModuleLoader];
+export declare type LoaderSignal<TYPE> = (TYPE extends () => ValueOrPromise<infer VALIDATOR> ? Signal<ValueOrPromise<VALIDATOR>> : Signal<TYPE>) & Pick<AsyncSignal, 'promise' | 'loading' | 'error'>;
 
 declare interface MenuModule {
     readonly default: ContentMenu;
@@ -480,12 +551,15 @@ export { NavigationType_2 as NavigationType }
 export declare function omitProps<T, KEYS extends keyof T>(obj: T, keys: KEYS[]): Omit<T, KEYS>;
 
 /** @public */
-export declare interface PageModule extends RouteModule {
-    readonly default: unknown;
+export declare type PageModule = RouteModule & {
+    readonly default: (props: Record<string, never>) => JSXOutput;
+    readonly routeConfig?: RouteConfig;
     readonly head?: ContentModuleHead;
+    readonly eTag?: ContentModuleETag;
+    readonly cacheKey?: CacheKeyFn;
     readonly headings?: ContentHeading[];
     readonly onStaticGenerate?: StaticGenerateHandler;
-}
+};
 
 /** @public */
 export declare type PathParams = Record<string, string>;
@@ -507,6 +581,9 @@ declare type Prettify<T> = {} & {
  */
 export declare type PreventNavigateCallback = (url?: number | URL) => ValueOrPromise<boolean>;
 
+/** @public */
+export declare const Q_ROUTE = "q:route";
+
 /**
  * @deprecated Use `QWIK_ROUTER_SCROLLER` instead (will be removed in V3)
  * @public
@@ -517,13 +594,7 @@ export declare const QWIK_CITY_SCROLLER = "_qCityScroller";
 export declare const QWIK_ROUTER_SCROLLER = "_qRouterScroller";
 
 /**
- * @deprecated Use `QwikRouterMockProps` instead. will be removed in V3
- * @public
- */
-export declare type QwikCityMockProps = QwikRouterMockProps;
-
-/**
- * @deprecated Use `QwikRouterMockProvider` instead. Will be removed in V3
+ * @deprecated Use `useQwikMockRouter()` instead. Will be removed in V3
  * @public
  */
 export declare const QwikCityMockProvider: Component<QwikRouterMockProps>;
@@ -535,32 +606,93 @@ export declare const QwikCityMockProvider: Component<QwikRouterMockProps>;
 export declare type QwikCityPlan = QwikRouterConfig;
 
 /**
- * @deprecated Use `QwikRouterProps` instead. will be removed in V3
+ * @deprecated Use `QwikRouterProps` instead. Will be removed in v3.
  * @public
  */
 export declare type QwikCityProps = QwikRouterProps;
 
 /**
- * @deprecated Use `QwikRouterProvider` instead. will be removed in V3
+ * @deprecated Use `useQwikRouter()` instead. Will be removed in v3.
  * @public
  */
 export declare const QwikCityProvider: Component<QwikRouterProps>;
 
 /** @public */
 export declare interface QwikRouterConfig {
-    readonly routes: RouteData[];
+    readonly routes: RouteData;
     readonly serverPlugins?: RouteModule[];
     readonly basePathname?: string;
-    readonly menus?: MenuData[];
     readonly trailingSlash?: boolean;
     readonly cacheModules?: boolean;
+    /** When true, return null instead of rendering the 404 page, letting the adapter handle it */
+    readonly fallthrough?: boolean;
+}
+
+/** @public */
+export declare interface QwikRouterEnvData {
+    routeName: string;
+    ev: RequestEvent;
+    params: PathParams;
+    response: EndpointResponse;
+    loadedRoute: LoadedRoute;
+}
+
+/** @public */
+export declare interface QwikRouterMockActionProp<T = any> {
+    /** The action function to mock. */
+    action: Action<T>;
+    /** The QRL function that will be called when the action is submitted. */
+    handler: QRL<(data: T) => ValueOrPromise_2<RouteActionResolver>>;
+}
+
+/** @public */
+export declare interface QwikRouterMockLoaderProp<T = any> {
+    /** The loader function to mock. */
+    loader: Loader_2<T>;
+    /** The data to return when the loader is called. */
+    data: T;
 }
 
 /** @public */
 export declare interface QwikRouterMockProps {
+    /**
+     * Allow mocking the url returned by `useLocation` hook.
+     *
+     * Default: `http://localhost/`
+     */
     url?: string;
+    /** Allow mocking the route params returned by `useLocation` hook. */
     params?: Record<string, string>;
+    /** Allow mocking the `goto` function returned by `useNavigate` hook. */
     goto?: RouteNavigate;
+    /**
+     * Allow mocking data for loaders defined with `routeLoader$` function.
+     *
+     * ```
+     * [
+     *   {
+     *     loader: useProductData,
+     *     data: { product: { name: 'Test Product' } },
+     *   },
+     * ];
+     * ```
+     */
+    loaders?: Array<QwikRouterMockLoaderProp<any>>;
+    /**
+     * Allow mocking actions defined with `routeAction$` function.
+     *
+     * ```
+     * [
+     *   {
+     *     action: useAddUser,
+     *     handler: $(async (data) => {
+     *       console.log('useAddUser action called with data:', data);
+     *     }),
+     *   },
+     * ];
+     * ```
+     */
+    actions?: Array<QwikRouterMockActionProp<any>>;
 }
 
 /** @public */
@@ -575,18 +707,25 @@ export declare interface QwikRouterProps {
      *
      * @see https://github.com/WICG/view-transitions/blob/main/explainer.md
      * @see https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API
-     * @see https://caniuse.com/mdn-api_viewtransition
+     * @see https://caniuse.com/mdn_api_viewtransition
      */
     viewTransition?: boolean;
 }
 
-/** @public */
+/** @public This is a wrapper around the `useQwikRouter()` hook. We recommend using the hook instead of this component, unless you have a good reason to make your root component reactive. */
 export declare const QwikRouterProvider: Component<QwikRouterProps>;
 
 /** @public */
-declare interface ReadonlySignal_2<T = unknown> {
-    readonly value: T;
-}
+export declare type RendererOptions = Omit<RenderOptions, 'serverData'> & {
+    serverData: ServerData;
+};
+
+/** @public */
+export declare type RendererOutputOptions = Omit<RenderOptions, 'serverData'> & {
+    serverData: ServerData & {
+        documentHead?: DocumentHeadValue;
+    } & Record<string, unknown>;
+};
 
 export { RequestEvent }
 
@@ -601,20 +740,88 @@ export { RequestEventLoader }
 export { RequestHandler }
 
 /** @public */
-export declare type ResolvedDocumentHead<FrontMatter extends Record<string, any> = Record<string, unknown>> = Required<DocumentHeadValue<FrontMatter>>;
+export declare type ResolvedDocumentHead<FrontMatter extends Record<string, any> = Record<string, unknown>> = Required<DocumentHeadValue<FrontMatter>> & {
+    /** The build's manifest hash, used for per-loader data URLs. Always defined (`'dev'` in dev). */
+    readonly manifestHash: string;
+};
 
 /** @public */
 export declare const routeAction$: ActionConstructor;
 
 /* Excluded from this release type: routeActionQrl */
 
-/** @public */
-export declare type RouteData = [routeName: string, loaders: ModuleLoader[]] | [
-routeName: string,
-loaders: ModuleLoader[],
-originalPathname: string,
-routeBundleNames: string[]
-];
+declare type RouteActionResolver = {
+    status: number;
+    result: unknown;
+};
+
+/**
+ * Unified route configuration export. Groups head, eTag, and cacheKey with the same resolution
+ * rules as DocumentHead: can be a static object or a function receiving DocumentHeadProps.
+ *
+ * When a module exports `routeConfig`, the separate `head`, `eTag`, and `cacheKey` exports are
+ * ignored for that module.
+ *
+ * @public
+ */
+export declare type RouteConfig = RouteConfigValue | ((props: DocumentHeadProps) => RouteConfigValue);
+
+/**
+ * The value shape returned by a routeConfig export (object form or function return).
+ *
+ * @public
+ */
+export declare interface RouteConfigValue {
+    readonly head?: DocumentHeadValue;
+    readonly eTag?: ContentModuleETag;
+    readonly cacheKey?: CacheKeyFn;
+}
+
+/**
+ * A nested route trie structure. The root represents `/` and each level represents a URL segment.
+ *
+ * Keys starting with `_` are metadata; all other keys are child route segments.
+ *
+ * - Use `_W` as the key for a single dynamic segment (param); `_P` on that node names the param.
+ * - Use `_A` as the key for a rest/catch-all segment; `_P` on that node names the param.
+ * - For infix params like `pre[slug]post`, use `_W` with `_0` (prefix) and `_9` (suffix).
+ * - Use `_M` for an array of group (pathless layout) nodes, sorted by group name.
+ *
+ * When matching, exact segments are tried first (case-insensitive), then `_W` (with optional
+ * prefix/suffix), then `_A`. When no route matches, the closest `_E` (error.tsx) or `_4` (404.tsx)
+ * loader in the ancestor chain is used to render the error page.
+ *
+ * @public
+ */
+export declare interface RouteData {
+    /** This node's layout loader (single). Runtime accumulates these during trie traversal. */
+    _L?: ContentModuleLoader;
+    /**
+     * This node's index/page loader. Single = normal (runtime prepends gathered _L). Array = override
+     * (layout stop / named layout — IS the complete chain).
+     */
+    _I?: ContentModuleLoader | ModuleLoader[];
+    /** Rewrite/goto target path. Matcher re-walks trie from root using this path's keys. */
+    _G?: string;
+    /** The JS bundle names for this route (SSR only) */
+    _B?: string[];
+    /** The not-found (404) module loader for this subtree */
+    _4?: ContentModuleLoader;
+    /** The error page module loader for this subtree (error.tsx, takes precedence over _4) */
+    _E?: ContentModuleLoader;
+    /** The parameter name when this node is reached via `_W` or `_A` from the parent */
+    _P?: string;
+    /** Prefix for infix params (e.g. "pre" for `pre[slug]post`) — only on `_W` nodes */
+    _0?: string;
+    /** Suffix for infix params (e.g. "post" for `pre[slug]post`) — only on `_W` nodes */
+    _9?: string;
+    /** Group (pathless layout) nodes merged into this level, sorted by group name */
+    _M?: RouteData[];
+    /** Menu loader for this subtree (from menu.md). Runtime uses nearest ancestor during traversal. */
+    _N?: MenuModuleLoader;
+    /** Child route segments (any key not starting with `_`) */
+    [part: string]: RouteData | RouteData[] | ModuleLoader[] | ContentModuleLoader | MenuModuleLoader | string[] | string | undefined;
+}
 
 /** @public */
 export declare const routeLoader$: LoaderConstructor;
@@ -662,6 +869,18 @@ declare interface ServerConfig {
     fetchOptions?: any;
 }
 
+/** @public The server data that is provided by Qwik Router during SSR rendering. It can be retrieved with `useServerData(key)` in the server, but it is not available in the client. */
+export declare type ServerData = {
+    url: string;
+    requestHeaders: Record<string, string>;
+    locale: string | undefined;
+    nonce: string | undefined;
+    containerAttributes: Record<string, string> & {
+        [Q_ROUTE]: string;
+    };
+    qwikrouter: QwikRouterEnvData;
+};
+
 /** @public */
 export declare type ServerFunction = {
     (this: RequestEventBase, ...args: any[]): any;
@@ -683,28 +902,18 @@ export declare type ServerQRL<T extends ServerFunction> = QRL<((abort: AbortSign
  * JS extensions are allowed) will be picked up, bundled into a separate file, and registered as a
  * service worker.
  *
+ * Qwik 1.14.0 and above now use `<link rel="modulepreload">` by default. If you didn't add custom
+ * service-worker logic, you should remove your service-worker.ts file(s) for the
+ * `ServiceWorkerRegister` Component to actually unregister the service-worker.js and delete its
+ * related cache. Make sure to keep the `ServiceWorkerRegister` Component in your app (without any
+ * service-worker.ts file) as long as you want to unregister the service-worker.js for your users.
+ *
  * @public
  */
 export declare const ServiceWorkerRegister: (props: {
     nonce?: string;
 }) => JSXOutput;
 
-/**
- * A signal is a reactive value which can be read and written. When the signal is written, all tasks
- * which are tracking the signal will be re-run and all components that read the signal will be
- * re-rendered.
- *
- * Furthermore, when a signal value is passed as a prop to a component, the optimizer will
- * automatically forward the signal. This means that `return <div title={signal.value}>hi</div>`
- * will update the `title` attribute when the signal changes without having to re-render the
- * component.
- *
- * @public
- */
-declare interface Signal<T = any> extends ReadonlySignal_2<T> {
-    value: T;
-}
-
 /** @public */
 export declare interface StaticGenerate {
     params?: PathParams[];
@@ -741,6 +950,9 @@ export declare const useContent: () => ContentState;
  */
 export declare const useDocumentHead: <FrontMatter extends Record<string, unknown> = Record<string, any>>() => Required<ResolvedDocumentHead<FrontMatter>>;
 
+/** @public */
+export declare const useHttpStatus: () => HttpErrorProps;
+
 /** @public */
 export declare const useLocation: () => RouteLocation;
 
@@ -785,6 +997,14 @@ export declare const usePreventNavigate$: (qrl: PreventNavigateCallback) => void
 
 /* Excluded from this release type: usePreventNavigateQrl */
 
+/**
+ * @public
+ * This hook initializes Qwik Router, providing the necessary context for it to work.
+ *
+ * This hook should be used once, at the root of your application.
+ */
+export declare const useQwikRouter: (props?: QwikRouterProps) => void;
+
 /** @beta */
 export declare const valibot$: ValibotConstructor;