import type { QueryReadModelProvider } from './QueryReadModelProvider.ts';
interface TraversalOptions {
    dir?: string;
    labelFilter?: string | string[];
    maxDepth?: number;
    signal?: AbortSignal;
}
/** @deprecated Use GraphTraversal + QueryReadModelNeighborProvider directly. */
export default class LogicalTraversal {
    private readonly _provider;
    constructor(provider: QueryReadModelProvider);
    /** Prepares engine from the current query read model. Does NOT validate start nodes. */
    private _prepareEngine;
    /** Prepares engine and validates a single start node. */
    private _prepare;
    /** Validates one or more start nodes exist. */
    private _validateStarts;
    /** Breadth-first traversal. */
    bfs(start: string, options?: TraversalOptions): Promise<string[]>;
    /** Breadth-first traversal stream. */
    bfsStream(start: string, options?: TraversalOptions): AsyncGenerator<string>;
    /** Depth-first traversal (pre-order). */
    dfs(start: string, options?: TraversalOptions): Promise<string[]>;
    /** Depth-first traversal stream. */
    dfsStream(start: string, options?: TraversalOptions): AsyncGenerator<string>;
    /** Shortest path (unweighted BFS). */
    shortestPath(from: string, to: string, options?: TraversalOptions): Promise<{
        found: boolean;
        path: string[];
        length: number;
    }>;
    /** Connected component (undirected BFS). */
    connectedComponent(start: string, options?: Omit<TraversalOptions, 'dir'>): Promise<string[]>;
    /** Reachability check — BFS with early termination. Non-existent nodes are unreachable. */
    isReachable(from: string, to: string, options?: TraversalOptions): Promise<{
        reachable: boolean;
    }>;
    /** Weighted shortest path (Dijkstra). */
    weightedShortestPath(from: string, to: string, options?: TraversalOptions & {
        weightFn?: (from: string, to: string, label: string) => number | Promise<number>;
        nodeWeightFn?: (nodeId: string) => number | Promise<number>;
    }): Promise<{
        path: string[];
        totalCost: number;
    }>;
    /** A* search with heuristic guidance. */
    aStarSearch(from: string, to: string, options?: TraversalOptions & {
        weightFn?: (from: string, to: string, label: string) => number | Promise<number>;
        nodeWeightFn?: (nodeId: string) => number | Promise<number>;
        heuristicFn?: (nodeId: string, goalId: string) => number;
    }): Promise<{
        path: string[];
        totalCost: number;
        nodesExplored: number;
    }>;
    /** Bidirectional A* search. Direction fixed: forward=out, backward=in. */
    bidirectionalAStar(from: string, to: string, options?: Omit<TraversalOptions, 'dir'> & {
        weightFn?: (from: string, to: string, label: string) => number | Promise<number>;
        nodeWeightFn?: (nodeId: string) => number | Promise<number>;
        forwardHeuristic?: (nodeId: string, goalId: string) => number;
        backwardHeuristic?: (nodeId: string, goalId: string) => number;
    }): Promise<{
        path: string[];
        totalCost: number;
        nodesExplored: number;
    }>;
    /** Topological sort (Kahn's algorithm). */
    topologicalSort(start: string | string[], options?: TraversalOptions & {
        throwOnCycle?: boolean;
    }): Promise<{
        sorted: string[];
        hasCycle: boolean;
    }>;
    /** Common ancestors — multi-source ancestor intersection. Direction fixed to 'in'. */
    commonAncestors(nodes: string[], options?: TraversalOptions & {
        maxResults?: number;
    }): Promise<{
        ancestors: string[];
    }>;
    /** Weighted longest path via topological sort + DP (DAGs only). */
    weightedLongestPath(from: string, to: string, options?: TraversalOptions & {
        weightFn?: (from: string, to: string, label: string) => number | Promise<number>;
        nodeWeightFn?: (nodeId: string) => number | Promise<number>;
    }): Promise<{
        path: string[];
        totalCost: number;
    }>;
    /** Longest-path level assignment (DAGs only). */
    levels(start: string | string[], options?: TraversalOptions): Promise<{
        levels: Map<string, number>;
        maxLevel: number;
    }>;
    /** Transitive reduction — minimal edge set preserving reachability (DAGs only). */
    transitiveReduction(start: string | string[], options?: TraversalOptions): Promise<{
        edges: Array<{
            from: string;
            to: string;
            label: string;
        }>;
        removed: number;
    }>;
    /** Transitive closure — all implied reachability edges. */
    transitiveClosure(start: string | string[], options?: TraversalOptions & {
        maxEdges?: number;
    }): Promise<{
        edges: Array<{
            from: string;
            to: string;
        }>;
    }>;
    /** Transitive closure stream — yields implied reachability edges lazily. */
    transitiveClosureStream(start: string | string[], options?: TraversalOptions & {
        maxEdges?: number;
    }): AsyncGenerator<{
        from: string;
        to: string;
    }>;
    /** Find all root ancestors (in-degree-0 nodes) reachable backward from start. */
    rootAncestors(start: string, options?: Omit<TraversalOptions, 'dir'>): Promise<{
        roots: string[];
    }>;
}
export {};
