/**
 * Network-call vocabulary shared by the browser SDK and the server.
 */
/**
 * What issued a network-shaped call. Desktop apps (Electron, Tauri) reach their backend over IPC
 * rather than HTTP, so an IPC call is recorded as a request with `initiator: 'ipc'` — that keeps
 * `reticle_network`, settle-waiting and `assert { net }` working on desktop with no new wire shape.
 */
export declare const NetInitiator: {
    readonly FETCH: "fetch";
    readonly XHR: "xhr";
    readonly BEACON: "beacon";
    readonly IPC: "ipc";
    /**
     * The request that fetched the DOCUMENT itself, read once from `PerformanceNavigationTiming`.
     *
     * A server-rendered app answers a click with a full document load: the old document is torn down
     * with the SDK inside it, and the SDK comes back up in a page whose defining request happened
     * before it existed. No patched transport could have seen it, so without this initiator the net
     * channel has no record of it at all: a `net` clause naming the destination MISSES and the verdict
     * comes back `unknown` even though route and heading verified.
     *
     * DISTINCT FROM the document-INITIATED subresource initiators (`link`, `css`, `img`, `script`,
     * `manifest`, `other`) that the resource-timing observer stamps. Those prove that observer is
     * alive on this page and gate a downgrade in `predicate-eval`; this one does not, because the
     * navigation entry exists on every page with Navigation Timing including ones where
     * `PerformanceObserver` never fired. Conflating them would turn an honest "cannot tell" into a
     * false red over favicons and fonts.
     */
    readonly DOCUMENT: "document";
    /**
     * The browser is LEAVING for this URL, recorded at the moment of departure.
     *
     * Emitted as a NET_PENDING that can never be matched, because that is exactly what it is: a
     * request the browser is about to make and whose outcome this SDK will never see, having died with
     * the document. Absence of a completion is honest here rather than a defect, and `reconcileNet`
     * already renders an unmatched pending as `{status: 'pending'}` — so a `urlContains` assertion
     * matches it and a `status: 200` one correctly does not.
     *
     * It exists because leaving the instrumented origin returned `observation_lost` and nothing else.
     * "Sign in with <provider>" is on a large share of real apps, and the checkable claim is narrow:
     * does the app hand the browser to the expected provider, with the expected parameters? Nobody
     * expects Reticle to verify the provider's own pages. That modest claim came back as `unknown`,
     * and the reporter's fallback was to read the local endpoint's 302 by hand and report the whole
     * flow unverified.
     *
     * The same event covers a native download — an `<a download href="/api/export.pdf">` produces no
     * fetch and no new document, so an export was equally unprovable.
     *
     * MUST be excluded from the settle oracle: a pending that by construction never completes would
     * otherwise mean no page containing an outbound link ever settles again.
     */
    readonly NAVIGATION: "navigation";
};
export type NetInitiator = (typeof NetInitiator)[keyof typeof NetInitiator];
/**
 * Synthetic URL scheme for an IPC call, so a channel/command name occupies the `url` field the way a
 * real endpoint does: `ipc://get_user`. Agents filter and assert on it with the ordinary net tools.
 */
export declare const IPC_URL_SCHEME = "ipc://";
/**
 * IPC has no status code, but every existing filter and assertion in Reticle keys on one
 * (`reticle_network { status: 500 }`, "did POST /x return 200?"). Mapping a settled IPC call onto
 * these two synthetic codes is what makes a FAILED main-process handler or Rust command visible to
 * the tools an agent already uses — without it, an IPC failure is unqueryable and the desktop story
 * is a false green by construction. `ok` is still emitted alongside and is the authoritative field.
 */
export declare const IpcStatus: {
    readonly OK: 200;
    readonly ERROR: 500;
};
/**
 * `202 Accepted` — the server took the request and has NOT finished processing it.
 *
 * The only status in HTTP whose meaning is "no outcome yet". Folding it into the 2xx success band is
 * how an asynchronous workflow gets verified at exactly the moment nothing has been decided: a
 * dispatch answers 202, the UI renders success, the page settles, and the server reverts the write
 * a second later.
 */
export declare const HTTP_ACCEPTED = 202;
/**
 * Traffic the DEV TOOLCHAIN makes about itself — never the app under test.
 *
 * A CLOSED list, deliberately. Without it a correct navigation grades `verified: "no"` because the
 * dev overlay is fetching a source map for an unrelated React warning (`POST
 * /__nextjs_original-stack-frames`) and that in-flight request counts as "the UI advanced over a
 * request that never settled" — a false negative on every action in any app that logs one dev
 * warning.
 *
 * The rule for adding an entry: it must be a channel the FRAMEWORK owns, that no application route
 * can occupy, and that fires as a consequence of running in dev rather than of anything the user
 * did. Widening one of these until it can swallow an app endpoint converts this false negative into
 * a false GREEN, so each pattern is anchored to a reserved prefix or a build-tool file suffix:
 *
 *  - `/__nextjs` — every Next dev-overlay endpoint shares this reserved prefix (`_original-stack-frames`,
 *    `_original-stack-frame`, `_launch-editor`, `_source-map`, `_error_feedback`, `_server_status`,
 *    `_devtools_config`, `_font`, …). Verified against next@15 and next@16 `dist`.
 *  - `/_next/webpack-hmr` + `/_next/static/webpack/` — Next's HMR channel and the `.hot-update.*`
 *    chunks it fetches. `/_next/static/chunks/` and `/_next/image` are NOT here: those are the app.
 *  - `.hot-update.` — the webpack HMR file suffix, for any webpack app (CRA, Rspack, plain webpack).
 *  - `/@vite/` (`client`, `env`), `/@react-refresh`, `/__vite_ping` — the Vite dev client, which is
 *    what SvelteKit, Astro, Remix and plain Vite all run. Verified present in vite@7/vite@8 and in
 *    astro@7's dist. Vite's `/@id/` and `/@fs/` are NOT here: those load the app's own modules.
 */
export declare const DevToolingChannel: {
    readonly NEXT_DEV_OVERLAY: "/__nextjs";
    readonly NEXT_HMR: "/_next/webpack-hmr";
    readonly NEXT_HMR_CHUNKS: "/_next/static/webpack/";
    readonly WEBPACK_HOT_UPDATE: ".hot-update.";
    readonly VITE_CLIENT: "/@vite/";
    readonly VITE_REACT_REFRESH: "/@react-refresh";
    readonly VITE_PING: "/__vite_ping";
};
export type DevToolingChannel = (typeof DevToolingChannel)[keyof typeof DevToolingChannel];
/**
 * Is this URL dev tooling rather than the app? Used to keep such calls out of the settle decision and
 * out of contradiction hunting. Never used to HIDE the call: the event stays in the timeline and the
 * exclusion is disclosed alongside the verdict.
 */
export declare function isDevToolingUrl(url: string | undefined): boolean;
/**
 * Is this call to somebody ELSE's site — an analytics beacon, a vendor SDK bootstrap, a CDN ping?
 *
 * The axis a verdict needs and never had. A contradiction is a statement about the app under test,
 * and a failed third-party request says nothing about whether the caller's action worked: reported
 * from several apps, any analytics package installed was enough to grade a correct drive
 * `contradicted`, and on one app every assertion came back that way forever.
 *
 * Deliberately NOT a vendor list. `DevToolingChannel` above states why a list is the wrong shape
 * here: widening it until it can swallow an app endpoint turns a false negative into a false GREEN.
 * An origin comparison has no list to widen — it asks one structural question about the page itself.
 *
 * Ports are deliberately ignored: a dev app on :3000 talking to its API on :8787 is the ordinary
 * local setup, and grading that as a stranger's traffic would silence the detector on our own bench.
 *
 * Absence of `appUrl` disables the axis entirely — the same rule the document scoping follows, so a
 * caller who cannot say which page is under test gets exactly the behaviour it had before this.
 */
export declare function isThirdPartyUrl(url: string | undefined, appUrl: string | undefined): boolean;
/**
 * The unredacted URL, kept so a grader can match `urlContains` against the path the app actually
 * requested. `url` is what is rendered to the agent and stored as the displayed value; this field
 * is the match haystack and must not be projected back into a transcript.
 *
 * Redaction runs at emit time and there is otherwise no raw copy. Public REST segments that happen
 * to follow a sensitive name (`/auth/token/refresh-context`, `/verify/CERT_INFY_10`) are rewritten
 * to `[REDACTED]`, so matching only `url` reports "the request did not happen".
 */
export declare const URL_RAW = "urlRaw";
/**
 * The URL a filter or predicate should match against: the raw request when the observer kept one,
 * otherwise the displayed (possibly redacted) `url`.
 */
export declare function urlForMatch(data: Record<string, unknown>): string;