import { BaseImplicitGraph } from './BaseImplicitGraph';
import type { NodeID } from './BaseImplicitGraph';
import type { ArkFile } from '../model/ArkFile';
import type { Canonicalizer } from '../../utils/Canonicalizer';
/**
 * File dependency graph, based on BaseImplicitGraph.
 * The node type is ArkFile, and edges represent dependency relationships between files.
 *
 * Similar to ModuleDepGraph but operates at file granularity:
 * - The node is the ArkFile itself, identified by its Canonicalizer-assigned ID
 * - Edge information is implicitly stored via succMap/predMap (Map<NodeID, NodeID[]>)
 * - Works with Canonicalizer<ArkFile> to provide bidirectional ArkFile <-> NodeID mapping
 *
 * SCCDetection is used to compute a topological order of files (depended-on files first).
 */
export declare class FileDepGraph extends BaseImplicitGraph<ArkFile> {
    /**
     * File Canonicalizer for bidirectional ArkFile <-> NodeID mapping.
     */
    private fileCanonicalizer;
    /**
     * Topological order of nodes after SCC computation, populated by computeTopoOrder.
     * Depended-on files appear before their dependents.
     */
    private topoOrder;
    constructor(fileCanonicalizer: Canonicalizer<ArkFile>);
    getGraphName(): string;
    /**
     * Add a file node to the graph.
     * The node's NodeID directly uses the ID assigned by the Canonicalizer.
     */
    addFile(file: ArkFile): void;
    /**
     * Add a dependency edge: src depends on dst (src -> dst).
     * succMap stores successors (dependency targets), predMap stores predecessors (dependents).
     */
    addDependencyEdge(srcId: NodeID, dstId: NodeID): void;
    /**
     * Remove a dependency edge.
     */
    removeDependencyEdge(srcId: NodeID, dstId: NodeID): void;
    /**
     * Remove a node ID from an adjacency list entry.
     */
    private removeFromAdjacencyList;
    /**
     * Get all successor (dependency target) file IDs of the specified file.
     */
    getSuccFileIds(fileId: NodeID): NodeID[];
    /**
     * Get all predecessor (dependent) file IDs of the specified file.
     */
    getPredFileIds(fileId: NodeID): NodeID[];
    /**
     * Check whether a dependency edge exists between two files.
     */
    hasDependencyEdge(srcId: NodeID, dstId: NodeID): boolean;
    /**
     * Get the total number of edges in the graph.
     */
    getEdgeCount(): number;
    /**
     * Get the topological order produced by the last computeTopoOrder call.
     * Depended-on files appear before their dependents.
     */
    getTopoOrder(): NodeID[];
    /**
     * Compute the topological order of all files using SCCDetection.
     * Each SCC representative in the topological stack is expanded to its members,
     * so every node appears exactly once. The result is stored in topoOrder and returned.
     * Depended-on files appear before their dependents.
     */
    computeTopoOrder(): NodeID[];
}
//# sourceMappingURL=FileDepGraph.d.ts.map