/**
 * @fileoverview Security Rule Engine
 * @module @nahisaho/musubix-security/rules/engine/rule-engine
 * @trace REQ-RULE-001, REQ-RULE-002, REQ-RULE-004
 */
import type { RuleResult, RuleFinding, RuleConfig, RuleSeverity } from '../types.js';
import { RuleRegistry } from './rule-registry.js';
/**
 * Rule engine options
 */
export interface RuleEngineOptions {
    /** Rule registry to use */
    registry?: RuleRegistry;
    /** Project root directory */
    projectRoot?: string;
    /** Number of concurrent file processing */
    concurrency?: number;
    /** Progress callback */
    onProgress?: (progress: RuleEngineProgress) => void;
    /** File processed callback */
    onFileProcessed?: (filePath: string, findings: RuleFinding[]) => void;
    /** Abort signal */
    signal?: AbortSignal;
}
/**
 * Progress information
 */
export interface RuleEngineProgress {
    phase: 'init' | 'scanning' | 'analyzing' | 'complete';
    totalFiles: number;
    processedFiles: number;
    totalRules: number;
    currentFile?: string;
    currentRule?: string;
    findingsCount: number;
}
/**
 * Engine run result
 */
export interface RuleEngineResult {
    /** All findings */
    findings: RuleFinding[];
    /** Results by rule */
    resultsByRule: Map<string, RuleResult>;
    /** Results by file */
    resultsByFile: Map<string, RuleFinding[]>;
    /** Files processed */
    filesProcessed: number;
    /** Total execution time in ms */
    executionTimeMs: number;
    /** Errors encountered */
    errors: RuleEngineError[];
    /** Summary statistics */
    summary: RuleEngineSummary;
}
/**
 * Engine error
 */
export interface RuleEngineError {
    type: 'file' | 'rule' | 'system';
    filePath?: string;
    ruleId?: string;
    message: string;
    stack?: string;
}
/**
 * Summary statistics
 */
export interface RuleEngineSummary {
    totalFindings: number;
    bySeverity: Record<RuleSeverity, number>;
    byRule: Record<string, number>;
    byCategory: Record<string, number>;
}
/**
 * Security Rule Engine
 * Main orchestrator for running security rules against source files
 */
export declare class RuleEngine {
    private registry;
    private projectRoot;
    private concurrency;
    private onProgress?;
    private onFileProcessed?;
    private signal?;
    constructor(options?: RuleEngineOptions);
    /**
     * Run rules against files
     */
    run(config: RuleConfig): Promise<RuleEngineResult>;
    /**
     * Run rules against a single file
     */
    runOnFile(filePath: string, config: RuleConfig): Promise<RuleFinding[]>;
    /**
     * Run rules against source code string
     */
    runOnSource(sourceCode: string, config: RuleConfig, fileName?: string): Promise<RuleFinding[]>;
    /**
     * Process a single file
     */
    private processFile;
    /**
     * Get files to scan
     */
    private getFilesToScan;
    /**
     * Walk directory recursively
     */
    private walkDirectory;
    /**
     * Get rules to run based on config
     */
    private getRulesToRun;
    /**
     * Get rules for a profile
     */
    private getProfileRules;
    /**
     * Calculate summary statistics
     */
    private calculateSummary;
    /**
     * Emit progress
     */
    private emitProgress;
}
/**
 * Create a rule engine
 */
export declare function createRuleEngine(options?: RuleEngineOptions): RuleEngine;
//# sourceMappingURL=rule-engine.d.ts.map