import type { ScreenIrResult } from "./irTypes.js";
import type { StructuralTestItem } from "./screenIrTestBaseline.js";
/** A graph node: one screen. */
export interface NavNode {
    readonly screenId: string;
    readonly screenName: string;
}
/** A resolved transition between two screens (both endpoints own a screen). */
export interface NavEdge {
    readonly fromScreenId: string;
    readonly trigger: string;
    readonly toScreenId: string;
    readonly sourceNodeId: string;
    readonly targetNodeId: string;
}
/** A raw link whose target node id resolves to no screen — an edge that leaves the known screens. */
export interface UnresolvedLink {
    readonly sourceNodeId: string;
    readonly trigger: string;
    readonly targetNodeId: string;
}
/** The deterministic navigation graph plus reachability analysis. */
export interface NavGraph {
    readonly nodes: readonly NavNode[];
    readonly edges: readonly NavEdge[];
    readonly unresolvedLinks: readonly UnresolvedLink[];
    /** Screens that are flow entry points (or the synthetic first-screen entry when none exist). */
    readonly entryScreenIds: readonly string[];
    /** Reachable-by-no-edge-or-entry screens, stable-sorted. */
    readonly unreachableScreenIds: readonly string[];
    /** Reachable screens with no outgoing edge, stable-sorted. */
    readonly deadEndScreenIds: readonly string[];
}
/** A bounded, acyclic multi-step path through the graph. */
export interface NavFlow {
    readonly screenIds: readonly string[];
}
/** A framework-agnostic routing hint: one screen and its outgoing transitions. */
export interface RoutingHint {
    readonly screenId: string;
    readonly transitions: readonly {
        readonly trigger: string;
        readonly toScreenId: string;
    }[];
}
/**
 * Derive the deterministic navigation graph from a Screen-IR result. When the IR carries no
 * flow-entry link, the first screen in stable id order is used as the synthetic entry so reachability
 * is still well-defined. The result is byte-identical for a given input.
 */
export declare function deriveNavGraph(ir: ScreenIrResult): NavGraph;
/**
 * Derive bounded, acyclic multi-step flow paths from the graph's entry screens. `maxDepth` caps the
 * number of screens per path (default {@link DEFAULT_MAX_FLOW_DEPTH}); the per-path visited set makes
 * every path acyclic, so a cycle or self-loop never yields an unbounded path set. Stable-sorted.
 */
export declare function deriveNavFlows(graph: NavGraph, maxDepth?: number): readonly NavFlow[];
/**
 * Framework-agnostic routing hints for design-to-code (#755): every screen mapped to its outgoing
 * transitions (`trigger` + `toScreenId`). No router, path, or framework vocabulary — a neutral
 * structure the target adapter shapes into its own routing. Stable-sorted per screen and transition.
 */
export declare function deriveRoutingHints(graph: NavGraph): readonly RoutingHint[];
/**
 * Derive per-screen navigation/flow/coverage test items, keyed by the screen they are attributed to.
 * Reuses #754's StructuralTestItem shape so the items compose additively through
 * `deriveScreenTestBaseline(screen, extraItems)`. Every edge → a navigation item on its source
 * screen; every multi-step flow → a flow item on its entry screen; every unreachable/dead-end screen
 * → a coverage-notice item. Deterministic: items are emitted in the graph's stable order.
 */
export declare function deriveNavTestItemsByScreen(graph: NavGraph, maxFlowDepth?: number): ReadonlyMap<string, readonly StructuralTestItem[]>;
//# sourceMappingURL=navGraph.d.ts.map