import { Graph } from '../../../algorithms/graph/graph';
import { Edge, Node } from '../../../algorithms/types/graph';
/**
 * Result of between-graph enumeration.
 */
export interface BetweenGraphResult {
    /** All nodes on any path between seeds */
    nodes: Set<string>;
    /** All edges on any path between seeds */
    edges: Set<string>;
    /** All discovered paths (as node ID arrays) */
    paths: string[][];
    /** Node degrees within the between-graph */
    degrees: Map<string, number>;
    /** Statistics about the enumeration */
    stats: {
        /** Total paths found */
        pathCount: number;
        /** Maximum path length found */
        maxPathLength: number;
        /** Minimum path length found */
        minPathLength: number;
        /** Mean path length */
        meanPathLength: number;
    };
}
/**
 * Options for between-graph enumeration.
 */
export interface BetweenGraphOptions {
    /** Maximum path length to enumerate (default: 6) */
    maxPathLength?: number;
    /** Maximum number of paths to enumerate (default: 10000) */
    maxPaths?: number;
    /** Whether to treat graph as directed (default: false) */
    directed?: boolean;
}
/**
 * Enumerate all paths between two seed nodes up to a maximum length.
 *
 * Uses DFS with backtracking to find all simple paths (no repeated nodes).
 * This is exponential in the worst case but tractable for small graphs
 * and limited path lengths.
 *
 * @param graph - The graph to search
 * @param seedA - First seed node ID
 * @param seedB - Second seed node ID
 * @param options - Enumeration options
 * @returns Between-graph result with all nodes, edges, and paths
 */
export declare const enumerateBetweenGraph: <N extends Node, E extends Edge>(graph: Graph<N, E>, seedA: string, seedB: string, options?: BetweenGraphOptions) => BetweenGraphResult;
/**
 * Enumerate between-graph for multiple seed pairs.
 *
 * The result is the union of all individual between-graphs.
 *
 * @param graph - The graph to search
 * @param seedPairs - Array of seed pairs [[A1, B1], [A2, B2], ...]
 * @param options - Enumeration options
 * @returns Combined between-graph result
 */
export declare const enumerateMultiSeedBetweenGraph: <N extends Node, E extends Edge>(graph: Graph<N, E>, seedPairs: Array<[string, string]>, options?: BetweenGraphOptions) => BetweenGraphResult;
/**
 * Compute k-hop ego network from a single seed node.
 *
 * This is the ground truth for N=1 seed case.
 *
 * @param graph - The graph to search
 * @param seed - Seed node ID
 * @param k - Maximum hops from seed (default: 3)
 * @returns Ego network result
 */
export declare const computeEgoNetwork: <N extends Node, E extends Edge>(graph: Graph<N, E>, seed: string, k?: number) => BetweenGraphResult;
//# sourceMappingURL=between-graph.d.ts.map