export interface RouteMatch {
    /** Route component path — the manifest key + __PYLON_DATA__.component value. */
    component: string;
    /** Decoded dynamic params captured from the path (e.g. `{ slug: "shoe-x" }`). */
    params: Record<string, string>;
}
/** The slice of the build manifest this module needs. */
export interface MatchableManifest {
    routes: Record<string, {
        path?: string;
        /** The route's own entry chunk (outdir-relative). */
        file?: string;
        /** Shared chunks the browser needs before that entry runs. */
        imports?: string[];
    }>;
}
/**
 * Resolve a concrete pathname to the route that would render it, plus its
 * decoded dynamic params. Returns null when no page route matches (the caller
 * then falls back to a normal server round-trip). When several patterns match,
 * the most specific wins: fewer catch-alls first, then fewer dynamic segments —
 * so `/orders/new` beats `/orders/[id]` beats `/[...all]`.
 */
export declare function matchRoute(manifest: MatchableManifest | null | undefined, pathname: string): RouteMatch | null;
/** What `<Link prefetch>` should warm for a destination href. */
export interface PrefetchTargets {
    /** The destination route's own entry chunk, or "" when no page route matches. */
    file: string;
    /** Chunks to warm alongside it. */
    imports: string[];
}
/**
 * The chunks a click on `pathname` will need before anything can render: the
 * destination route's entry, plus the chunks (React, the client runtime,
 * common layouts) it pulls in.
 *
 * Warming the page payload alone leaves the entry chunk to be fetched after
 * the click, and the route cannot render until it lands — so the prefetch
 * covers only the half that was already fast.
 *
 * Size is deliberately NOT a factor. Build output is content-hashed and served
 * immutable, so warming a heavy route costs its bytes once per browser and
 * makes every later visit to it instant; skipping it would trade a permanent
 * win for a one-time saving, and would skip exactly the routes slowest to
 * fetch on demand. The warm is deferred to the load event, so those bytes
 * never compete with the current page's own render.
 *
 * An href matching no page route (an API path, a route this build doesn't
 * serve) yields the union of every route's chunks: no destination is known,
 * but those are needed by any navigation.
 */
export declare function prefetchTargets(manifest: MatchableManifest | null | undefined, pathname: string): PrefetchTargets;