/**
 * Circle-IR Analyzer
 *
 * Main entry point for analyzing source code and producing Circle-IR output.
 * This is the core static analyzer. LLM-based verification and discovery are out of scope for this library.
 *
 * The analysis pipeline runs forty sequential passes over a shared CodeGraph:
 *   1. TaintMatcherPass        — config-based source/sink extraction
 *   2. ConstantPropagationPass — dead-code detection, symbol table, field taint
 *   3. LanguageSourcesPass     — language-specific sources/sinks (JS, Python, getters)
 *   4. SinkFilterPass          — four-stage false-positive elimination
 *   5. TaintPropagationPass    — DFG-based flow verification
 *   6. InterproceduralPass     — cross-method taint propagation
 *   7. DeadCodePass            — CFG blocks unreachable from entry (CWE-561)
 *   8. MissingAwaitPass        — unawaited async calls in JS/TS (CWE-252)
 *   9. NPlusOnePass            — DB/HTTP calls inside loop bodies (CWE-1049)
 *  10. MissingPublicDocPass    — public methods/types without doc comments
 *  11. TodoInProdPass          — TODO/FIXME/HACK markers in production code
 *  12. StringConcatLoopPass    — string += inside loops, O(n²) allocations (CWE-1046)
 *  13. SyncIoAsyncPass         — blocking *Sync calls inside async functions (CWE-1050)
 *  14. UncheckedReturnPass     — ignored boolean return from File.delete etc. (CWE-252)
 *  15. NullDerefPass           — null-assigned var dereferenced without guard (CWE-476)
 *  16. ResourceLeakPass        — stream/connection opened but never closed (CWE-772)
 *  17. VariableShadowingPass   — inner scope re-declares outer name (CWE-1109)
 *  18. LeakedGlobalPass        — assignment without declaration in JS/TS (CWE-1109)
 *  19. UnusedVariablePass      — local variable declared but value never read (CWE-561)
 *  20. DependencyFanOutPass    — module imports 20+ other modules (architecture smell)
 *  21. StaleDocRefPass         — doc comment references unknown symbol (CWE: none)
 *  22. InfiniteLoopPass        — loops with no reachable exit edge (CWE-835)
 *  23. DeepInheritancePass     — class inheritance depth > 5 (CWE-1086)
 *  24. RedundantLoopPass       — loop-invariant .length/.size()/Math.* (CWE-1050)
 *  25. UnboundedCollectionPass — collection grows in loop with no size limit (CWE-770)
 *  26. SerialAwaitPass         — sequential awaits with no data dependency (performance)
 *  27. ReactInlineJsxPass      — inline objects/functions in JSX props (performance)
 *  28. SwallowedExceptionPass  — catch blocks with no throw/log/return (CWE-390)
 *  29. BroadCatchPass          — catch(Exception) / bare except (CWE-396)
 *  30. UnhandledExceptionPass  — throw/raise outside any try/catch (CWE-390)
 *  31. DoubleClosePass         — resource closed twice in same method (CWE-675)
 *  32. UseAfterClosePass       — method call on resource after close() (CWE-672)
 *  33. CleanupVerifyPass       — close() does not post-dominate acquisition (CWE-772)
 *  34. MissingOverridePass     — overriding method lacks @Override (Java)
 *  35. UnusedInterfaceMethodPass — interface method never called in file
 *  36. BlockingMainThreadPass  — blocking crypto/*Sync calls in request handlers (CWE-1050)
 *  37. ExcessiveAllocationPass — collection/object allocation inside loop bodies (CWE-770)
 *  38. MissingStreamPass       — whole-file read without streaming (performance)
 *  39. GodClassPass            — class with high WMC/LCOM2/CBO metrics (CWE-1060)
 *  40. NamingConventionPass    — class/method names violate language conventions
 *  41. ScanSecretsPass         — hardcoded credentials: provider regexes + Shannon entropy (CWE-798)
 *
 * Removed from default pipeline (raw IR signals still available for circle-ir-ai):
 *  – MissingGuardDomPass  — false positives in framework-auth codebases (see pass file)
 *  – FeatureEnvyPass      — fires on legitimate delegation patterns (see pass file)
 */
import type { CircleIR, AnalysisResponse, ProjectAnalysis } from './types/index.js';
import type { TaintConfig } from './types/config.js';
import { type SupportedLanguage } from './core/index.js';
import { isFalsePositive } from './analysis/index.js';
import { type DependencyFanOutOptions } from './analysis/passes/dependency-fan-out-pass.js';
import { type UnboundedCollectionOptions } from './analysis/passes/unbounded-collection-pass.js';
import { type NamingConventionOptions } from './analysis/passes/naming-convention-pass.js';
import { type SecurityHeadersOptions } from './analysis/passes/security-headers-pass.js';
export interface AnalyzerOptions {
    /**
     * Path to tree-sitter.wasm for parser initialization.
     */
    wasmPath?: string;
    /**
     * Pre-compiled WebAssembly.Module for tree-sitter.wasm.
     * For Cloudflare Workers where dynamic WASM compilation is blocked.
     */
    wasmModule?: WebAssembly.Module;
    /**
     * Paths to language-specific WASM files.
     */
    languagePaths?: Partial<Record<SupportedLanguage, string>>;
    /**
     * Pre-compiled WebAssembly.Module for language grammars.
     * For Cloudflare Workers where dynamic WASM compilation is blocked.
     */
    languageModules?: Partial<Record<SupportedLanguage, WebAssembly.Module>>;
    /**
     * Custom taint configuration.
     */
    taintConfig?: TaintConfig;
    /**
     * Per-pass configuration options.
     */
    passOptions?: PassOptions;
    /**
     * Passes to disable entirely. Use pass names (e.g., 'naming-convention').
     */
    disabledPasses?: string[];
}
/**
 * Per-pass configuration options.
 * Each key corresponds to a pass name with pass-specific settings.
 */
export interface PassOptions {
    /** Options for NamingConventionPass (#88). */
    namingConvention?: NamingConventionOptions;
    /** Options for DependencyFanOutPass (#72). */
    dependencyFanOut?: DependencyFanOutOptions;
    /** Options for UnboundedCollectionPass (#31). */
    unboundedCollection?: UnboundedCollectionOptions;
    /** Options for SecurityHeadersPass (#89). */
    securityHeaders?: SecurityHeadersOptions;
}
/**
 * Initialize the analyzer. Must be called before analyze().
 */
export declare function initAnalyzer(options?: AnalyzerOptions): Promise<void>;
/**
 * Analyze source code and produce Circle-IR output.
 */
export declare function analyze(code: string, filePath: string, language: SupportedLanguage, options?: AnalyzerOptions): Promise<CircleIR>;
/**
 * Analyze code and return a simplified API response format.
 */
export declare function analyzeForAPI(code: string, filePath: string, language: SupportedLanguage, options?: AnalyzerOptions): Promise<AnalysisResponse>;
/**
 * Check if the analyzer is initialized.
 */
export declare function isAnalyzerInitialized(): boolean;
/**
 * Reset the analyzer (mainly for testing).
 */
export declare function resetAnalyzer(): void;
/**
 * Analyze a set of files as a project, finding cross-file taint flows.
 *
 * Runs single-file `analyze()` on each file in order, then uses
 * `ProjectGraph` + `CrossFileResolver` to surface flows that cross file
 * boundaries.  The per-file `CircleIR` outputs are preserved unchanged in
 * `ProjectAnalysis.files`.
 *
 * `findings` is always empty — it requires LLM enrichment which is out of
 * scope for this library (see CLAUDE.md and SPEC.md section 11).
 */
export declare function analyzeProject(files: Array<{
    code: string;
    filePath: string;
    language: SupportedLanguage;
}>, options?: AnalyzerOptions): Promise<ProjectAnalysis>;
export { isFalsePositive };
//# sourceMappingURL=analyzer.d.ts.map