import type { NavigationOptions, NavigationTarget, Params, Router, SearchParams, State } from "@real-router/core";
/**
 * Resolved navigation channels for a `<Link>` — the single `{ name, params,
 * search }` shape every adapter feeds into `buildHref` / `navigateWithHash` /
 * the active-route source, regardless of which prop form the consumer used.
 */
export interface ResolvedLinkTarget {
    name: string;
    params: Params | undefined;
    search: SearchParams | undefined;
}
/**
 * Collapses a `<Link>`'s two prop forms (RFC-4 M2 B2, #1548) into one channel
 * triple:
 *
 * - **Descriptor** — `to={{ name, params?, search? }}` (a `NavigationTarget`).
 * - **Channel props** — `routeName` + `routeParams?` + `routeSearch?`.
 *
 * The forms are mutually exclusive: the TS union on each adapter's `LinkProps`
 * rejects mixing them at compile time, and this helper is the runtime backstop —
 * when `to` is present it **wins**, and a `dev`-visible `console.warn` fires if
 * channel props were also supplied (a JS consumer, an object spread, or an
 * adapter without a strict union can still slip both through). `routeOptions` /
 * `hash` are separate props under BOTH forms (hash is not part of
 * `NavigationTarget` — #532), so they are resolved by the caller, not here.
 */
export declare function resolveLinkTarget(to: NavigationTarget | undefined, routeName: string, routeParams: Params | undefined, routeSearch: SearchParams | undefined): ResolvedLinkTarget;
export declare function shouldNavigate(evt: MouseEvent): boolean;
/**
 * Does an anchor's `target` send this navigation somewhere the router cannot
 * follow? (#1834)
 *
 * `target` names the browsing context the author wants the URL loaded into.
 * Three values are the router's — absent, empty, `_self` — and every other one
 * goes to the browser, the only thing that can resolve a context name.
 * Intercepting instead is how a `<Link target="_blank">` ends up reloading the
 * same tab rather than opening a new one. React Router's
 * `shouldProcessLinkClick` and TanStack Router's `handleClick` split the same
 * way; neither reproduces browsing contexts inside the router, and neither does
 * this.
 *
 * ⚠ The split is by SPELLING, not by where the value resolves to, and three
 * spellings resolve back to this context anyway: `_parent` and `_top` fall back
 * to `_self` in a document with no ancestor, and `_SELF` matches `_self`
 * ASCII-case-insensitively (MDN, `<a>` § target). All three are handed to the
 * browser, which reaches the right destination by a full page load instead of a
 * transition. Resolving them properly means reproducing frame ancestry and
 * keyword folding here; both reference routers decline, and the cost is a page
 * load rather than a wrong destination.
 *
 * ⚠ Ask this only about an `<a>`. On a `<button v-link>` or a `<div use:link>`
 * the attribute is inert markup the browser will not act on, so deferring there
 * would leave the activation unhandled by anyone. Callers that cannot assume an
 * anchor ask {@link anchorTargetsAnotherContext} instead, which narrows first;
 * `target-predicate-authority-1834` owns which call site is in which set.
 */
export declare function targetsAnotherContext(target: string | null | undefined): boolean;
/**
 * The same question, asked about an ELEMENT — for the `use:link` / `v-link`
 * forms, which attach to whatever element the consumer wrote and so cannot
 * assume an anchor (#1834). The `<Link>` components pass a value instead
 * (they render the anchor), and so does Angular's directive (its selector is
 * `a[realLink]`).
 *
 * ⚠ `tagName`, never `instanceof HTMLAnchorElement`, for the reason
 * `applyLinkA11y` sets out below: the constructor belongs to the realm this
 * module loaded in, so a real anchor from an iframe `contentDocument` or a
 * micro-frontend fails the check. Failing it HERE re-intercepts the very
 * `target="_blank"` click this predicate exists to leave alone.
 *
 * Anything that is not an HTML anchor answers `false`: `target` is
 * anchor-specific markup the browser will not act on, so a `<button use:link>`
 * or a `<div v-link>` carrying one must still navigate in-app.
 */
export declare function anchorTargetsAnotherContext(element: Element | null | undefined): boolean;
/**
 * Builds an href for a `<Link>` element.
 *
 * - Prefers the URL plugin's `buildUrl` (browser-plugin, navigation-plugin,
 *   hash-plugin) when present.
 * - Falls back to `router.buildPath` for runtimes without a URL plugin
 *   (memory-plugin, console UIs, NativeScript). In that fallback the hash
 *   is appended manually so the rendered href is still correct.
 * - The optional 4th argument is the decoded hash fragment (no leading "#";
 *   `<Link hash="#section">` is accepted defensively — leading "#" stripped),
 *   passed positionally to mirror `navigateWithHash(router, name, params, hash)`
 *   (#1442). Previous 3-arg call sites continue to work unchanged.
 */
export declare function buildHref(router: Router, routeName: string, routeParams: Params, routeSearch?: SearchParams, hash?: string): string | undefined;
export declare function navigateWithHash(router: Router, routeName: string, routeParams: Params, routeSearch: SearchParams | undefined, hash: string | undefined, extraOptions?: NavigationOptions): Promise<State>;
export declare function buildActiveClassName(isActive: boolean, activeClassName: string | undefined, baseClassName: string | undefined): string | undefined;
/**
 * One-level structural equality using `Object.is` per key.
 *
 * **String-keyed properties only (Mini-sprint E.3 — audit-5 §4.2 #3).**
 * Implementation walks `Object.keys()` which by spec returns only
 * enumerable own STRING keys. Symbol-keyed properties — created via
 * `obj[Symbol("brand")] = value` or `{ [Symbol(...)]: value }` — are
 * NOT compared. Two records that differ only in a Symbol-keyed value
 * will compare as equal.
 *
 * This is intentional: route params and Link options are documented as
 * string-keyed primitives (string | number | boolean) — Symbol-keyed
 * metadata (e.g. brand markers, private state) doesn't belong in a
 * cache-key comparison. Switching to `Reflect.ownKeys()` would extend
 * the contract to symbols at the cost of one extra allocation per call
 * (Reflect.ownKeys composes string-keys + symbol-keys arrays). If a
 * consumer relies on symbol-keyed metadata for navigation
 * disambiguation, they should encode it into a string key instead.
 *
 * Mirrors React's `shallowEqual` (packages/shared/shallowEqual.js) in
 * both the string-keys-only semantics and the `hasOwnProperty` guard
 * below.
 */
export declare function shallowEqual(prev: object | undefined, next: object | undefined): boolean;
export declare function applyLinkA11y(element: HTMLElement | null | undefined): void;