import { Graph } from '../../algorithms/graph/graph';
import { Edge, Node } from '../../algorithms/types/graph';
import { GraphExpander, Neighbor } from '../../interfaces/graph-expander';
/**
 * Test node with optional attributes for MI computation.
 */
export interface ProofTestNode extends Node {
    id: string;
    type: string;
    degree?: number;
    attributes?: number[];
}
/**
 * Test edge with optional weight and MI override.
 */
export interface ProofTestEdge extends Edge {
    id: string;
    source: string;
    target: string;
    type: string;
    weight?: number;
    /** Override MI value for testing specific scenarios */
    miOverride?: number;
}
/**
 * Test implementation of GraphExpander for proof tests.
 * Wraps a Graph instance to provide the expansion interface.
 */
export declare class ProofTestExpander implements GraphExpander<ProofTestNode> {
    private readonly directed;
    private adjacency;
    private degrees;
    private nodes;
    private discoveredEdges;
    constructor(edges: Array<[string, string]>, directed?: boolean);
    getNeighbors(nodeId: string): Promise<Neighbor[]>;
    getDegree(nodeId: string): number;
    getNode(nodeId: string): Promise<ProofTestNode | null>;
    addEdge(source: string, target: string, relationshipType: string): void;
    calculatePriority(nodeId: string, options?: {
        nodeWeight?: number;
        epsilon?: number;
    }): number;
    getNodeCount(): number;
    getAllNodeIds(): string[];
    getDiscoveredEdges(): Array<{
        source: string;
        target: string;
        relationshipType: string;
    }>;
    clearDiscoveredEdges(): void;
}
/**
 * Creates a linear chain graph: N0 -- N1 -- N2 -- ... -- N(n-1)
 * @param length
 */
export declare const createChainGraph: (length: number) => ProofTestExpander;
/**
 * Creates a star graph with a central hub connected to all spokes.
 * @param numSpokes
 * @param numberSpokes
 */
export declare const createStarGraph: (numberSpokes: number) => ProofTestExpander;
/**
 * Creates a grid (lattice) graph of rows × cols.
 * @param rows
 * @param cols
 */
export declare const createGridGraph: (rows: number, cols: number) => ProofTestExpander;
/**
 * Creates a complete graph K_n where every node connects to every other node.
 * @param n
 */
export declare const createCompleteGraph: (n: number) => ProofTestExpander;
/**
 * Creates a tree graph with specified branching factor and depth.
 * @param branchingFactor
 * @param depth
 */
export declare const createTreeGraph: (branchingFactor: number, depth: number) => ProofTestExpander;
/**
 * Creates a graph with multiple disconnected components.
 * @param numComponents
 * @param numberComponents
 * @param nodesPerComponent
 */
export declare const createDisconnectedGraph: (numberComponents: number, nodesPerComponent: number) => ProofTestExpander;
/**
 * Creates a cycle graph: N0 -- N1 -- N2 -- ... -- N(n-1) -- N0
 * @param n
 */
export declare const createCycleGraph: (n: number) => ProofTestExpander;
/**
 * Creates an Erdős-Rényi random graph G(n, p).
 * Each edge exists independently with probability p.
 * @param n
 * @param p
 * @param seed
 */
export declare const createErdosRenyiGraph: (n: number, p: number, seed?: number) => ProofTestExpander;
/**
 * Creates a Barabási-Albert preferential attachment graph.
 * @param n
 * @param m
 * @param seed
 */
export declare const createBarabasiAlbertGraph: (n: number, m: number, seed?: number) => ProofTestExpander;
/**
 * Creates a Graph instance for path ranking tests.
 * @param edges
 * @param directed
 */
export declare const createTestGraph: (edges: Array<{
    source: string;
    target: string;
    weight?: number;
    type?: string;
}>, directed?: boolean) => Graph<ProofTestNode, ProofTestEdge>;
/**
 * Creates a Graph with explicit MI values for edges.
 * Used for testing path ranking properties.
 * @param edges
 * @param directed
 */
export declare const createTestGraphWithMI: (edges: Array<{
    source: string;
    target: string;
    miOverride: number;
}>, directed?: boolean) => Graph<ProofTestNode, ProofTestEdge>;
/**
 * Creates a mock MI cache with specified values.
 * @param miValues
 */
export declare const createMockMICache: (miValues: Map<string, number>) => {
    get: (id: string) => number | undefined;
    keys: () => IterableIterator<string>;
    size: number;
};
/**
 * Creates a seeded pseudo-random number generator.
 * Uses mulberry32 algorithm for deterministic results.
 * @param seed
 */
export declare const createSeededRng: (seed: number) => (() => number);
/**
 * Computes the geometric mean of an array of positive numbers.
 * @param values
 */
export declare const geometricMean: (values: number[]) => number;
/**
 * Checks if two sets contain the same elements.
 * @param a
 * @param b
 */
export declare const setsEqual: <T>(a: Set<T>, b: Set<T>) => boolean;
/**
 * Computes union of multiple sets.
 * @param sets
 */
export declare const setUnion: <T>(...sets: Set<T>[]) => Set<T>;
//# sourceMappingURL=test-utils.d.ts.map