/**
 * `analyze_error_propagation` MCP handler (change: add-error-propagation-graph).
 *
 * The call graph answers *who calls whom*; it is silent on *what can throw out of
 * here, and is it handled*. This tool answers that, as a conclusion: given a query
 * function, the exception types that can propagate OUT of it to its callers
 * (`escapes`) and the ones thrown somewhere in its reachable subtree but caught
 * within it (`handledInternally`) — each with provenance — plus the honesty
 * `boundaries` that make the result a sound lower bound.
 *
 * It is the error-handling analogue of `analyze_impact` (blast radius of a change)
 * and `select_tests` (tests reaching a change). Computed live from the cached call
 * graph (callee edges + call-site lines) plus a re-read and tree-sitter parse of
 * the source the reachable functions span — the `find_clones` precedent: no new
 * persisted artifact, no schema migration, no edit to the hot analyze walk.
 *
 * Scope: TypeScript / JavaScript / Python (the languages with cleanly extractable
 * throw + typed/untyped catch semantics). A query in any other language returns an
 * explicit `unsupported` result, never an empty escape set.
 */
export interface AnalyzeErrorPropagationInput {
    directory: string;
    /** A function in the index: its name, or `name::path` to disambiguate. */
    symbol?: string;
    /** Callee-traversal depth bound (default 10, clamped to [1, 30]). */
    maxDepth?: number;
}
/**
 * Compute the exceptions that escape a query function. Read-only, deterministic,
 * offline. Returns `unknown` (additive-by-cast), conclusion-shaped — labeled
 * escape/handled sets with provenance and disclosed boundaries, never a graph.
 */
export declare function handleAnalyzeErrorPropagation(input: AnalyzeErrorPropagationInput): Promise<unknown>;
//# sourceMappingURL=error-propagation.d.ts.map