/**
 * Phase 8.5: Class Hierarchy Analysis (CHA) + Rapid Type Analysis (RTA)
 *
 * CHA resolves virtual/interface method dispatch to all known concrete
 * implementations.  RTA refines the CHA set by filtering out types that are
 * never instantiated in the program (no `new X()` anywhere in the codebase).
 *
 * Used by:
 *   - buildFileCallEdges (WASM/JS path) — inline during per-file edge building
 *   - buildChaPostPass (native path)    — JS post-pass on top of native edges
 */
import type { ExtractorOutput } from '../../../types.js';
import type { CallNodeLookup } from './call-resolver.js';
export interface ChaContext {
    /** interface/class name → concrete classes that implement or extend it */
    readonly implementors: ReadonlyMap<string, readonly string[]>;
    /** class name → direct parent class name (from `extends`) */
    readonly parents: ReadonlyMap<string, string>;
    /** RTA: class names that appear in `new X()` anywhere in the project */
    readonly instantiatedTypes: ReadonlySet<string>;
}
export declare const EMPTY_CHA_CONTEXT: ChaContext;
/**
 * Build the CHA context from all parsed file symbols.
 *
 * Must be called AFTER cross-file return-type propagation so that typeMap
 * confidence values reflect propagated types (used for RTA seeding).
 */
export declare function buildChaContext(fileSymbols: ReadonlyMap<string, ExtractorOutput>): ChaContext;
/**
 * Resolve `this.method()`, `self.method()`, or `super.method()` through the
 * class hierarchy of the calling method.
 *
 * callerName must be a qualified method name ("ClassName.callerFn") for the
 * class context to be determinable.  Returns [] for plain functions.
 *
 * For `super`, resolution starts from the parent of the caller's class.
 * For `this`/`self`, resolution starts from the caller's own class and walks
 * up the inheritance chain (supporting inherited method lookup).
 */
export declare function resolveThisDispatch(methodName: string, callerName: string | null, receiver: 'this' | 'self' | 'super', chaCtx: ChaContext, lookup: CallNodeLookup): ReadonlyArray<{
    id: number;
    file: string;
}>;
/**
 * CHA + RTA: given a receiver type (class or interface), return all concrete
 * method implementations reachable via the class hierarchy.
 *
 * Only returns methods on types that are actually instantiated somewhere in
 * the project (RTA filter).  Returns [] when no concrete instantiated type
 * overrides the given method.
 *
 * BFS over the implementors map handles multi-level hierarchies (e.g.
 * IFoo → AbstractFoo → ConcreteFoo) so that abstract intermediate classes
 * are transparently skipped while their concrete subclasses are still reached.
 */
export declare function resolveChaTargets(typeName: string, methodName: string, chaCtx: ChaContext, lookup: CallNodeLookup): ReadonlyArray<{
    id: number;
    file: string;
}>;
//# sourceMappingURL=cha.d.ts.map