/**
 * Phase 8.3 — Lightweight field-based points-to analysis for JS/TS.
 *
 * Resolves higher-order function calls where a named variable is an alias for
 * a function that the syntactic extractor cannot connect directly. Common
 * patterns resolved:
 *
 *   const fn = handler;        arr.map(fn)        → edge to handler
 *   const fn = obj.method;     router.use(fn)     → edge to obj.method
 *   const m = authMiddleware;  app.use(m)         → edge to authMiddleware
 *
 * Algorithm: Andersen-style inclusion-based analysis with allocation-site
 * abstraction and fixed-point constraint propagation.
 *
 * Field-based (not field-sensitive): all instances of obj.field are treated as
 * a single abstract location, matching ACG's sweet spot of 99% precision.
 *
 * Scope: intra-module + cross-module via importedNames (the importedNames map
 * that build-edges.ts already builds per file is the cross-module link — if
 * a variable aliases an imported name, resolveCallTargets follows it).
 */
import type { ArrayCallbackBinding, ArrayElemBinding, FnRefBinding, ForOfBinding, ObjectPropBinding, ObjectRestParamBinding, ParamBinding, SpreadArgBinding } from '../../../types.js';
export type PointsToMap = Map<string, Set<string>>;
/**
 * Build a points-to map for one file.
 *
 * Seeds concrete function names (locally-defined functions + imported names),
 * then propagates assignments through fixed-point iteration until stable.
 *
 * Each "concrete target" in a pts set is a name that `resolveCallTargets` can
 * look up — either a locally-defined function name (found via byNameAndFile) or
 * an imported name (found via importedNames → byNameAndFile in the source file).
 *
 * @param fnRefBindings         - identifier/member-expr bindings from the extractor
 * @param definitionNames       - locally-defined callable names in this file
 * @param importedNames         - names imported into this file (name → resolved file)
 * @param paramBindings         - call-site arg→param bindings (Phase 8.3c)
 * @param definitionParams      - per-function ordered parameter names (Phase 8.3c)
 * @param arrayElemBindings     - array literal element bindings (Phase 8.3e)
 * @param spreadArgBindings     - spread-argument bindings (Phase 8.3e)
 * @param forOfBindings         - for-of iteration variable bindings (Phase 8.3e)
 * @param arrayCallbackBindings - Array.from/callback bindings (Phase 8.3e)
 */
export declare function buildPointsToMap(fnRefBindings: readonly FnRefBinding[], definitionNames: ReadonlySet<string>, importedNames: ReadonlyMap<string, string>, paramBindings?: readonly ParamBinding[], definitionParams?: ReadonlyMap<string, readonly string[]>, arrayElemBindings?: readonly ArrayElemBinding[], spreadArgBindings?: readonly SpreadArgBinding[], forOfBindings?: readonly ForOfBinding[], arrayCallbackBindings?: readonly ArrayCallbackBinding[], objectRestParamBindings?: readonly ObjectRestParamBinding[], objectPropBindings?: readonly ObjectPropBinding[]): PointsToMap;
/**
 * Return the concrete function names that `callName` flows to, excluding
 * itself to prevent circular self-reference edges.
 *
 * Returns an empty array when callName is not in the pts map (i.e., it is
 * not an alias — the caller should fall back to normal resolution failure).
 */
export declare function resolveViaPointsTo(callName: string, pts: PointsToMap): string[];
//# sourceMappingURL=points-to.d.ts.map