import { IFileSystem, ILogger, IConfigParser } from '../../domain/interfaces';
import { ValidationIssue, RuleCoverage } from './ruleset-validator.types';
import { IRuleEvaluatorStrategy, RuleEvaluationResult } from './evaluators/evaluator.interface';
import { IRulesetRepository } from '../../domain/ports/ruleset-repository.port';
import type { EvaluationFacts } from '../../domain/satellite-manifest';
import { NormalizedRule as CorpusRule } from '../../domain/models/normalized-rule';
import { ApplicabilityContext, NotApplicableReason, RuleApplicabilityIndex } from './rule-applicability';
import { RulesetSelection, SelectionOutcome } from './ruleset-selection';
import { RulesetCatalog } from './ruleset-catalog';
import { OverridesReport, RuleOverridesInput } from './rule-overrides';
export interface NormalizedRule {
    id: string;
    severity: 'MUST' | 'SHOULD' | 'COULD' | 'MUST NOT';
    category: string;
    title: string;
    description: string;
    blocking: boolean;
    validationQuery?: string;
    sourceFile: string;
}
export type RuleResult = 'passed' | 'failed' | 'skipped' | 'errored';
export declare function summarizeRuleCoverage(results: readonly RuleEvaluationResult[]): RuleCoverage;
export declare function blockingSkippedIssue(r: RuleEvaluationResult): ValidationIssue;
export declare function emptyRuleCoverage(): RuleCoverage;
export interface NotApplicableRule {
    readonly rule: CorpusRule;
    readonly reason: NotApplicableReason;
}
export interface CorpusEvaluation {
    readonly results: RuleEvaluationResult[];
    readonly notApplicable: NotApplicableRule[];
    readonly selection?: SelectionOutcome;
    readonly overrides: OverridesReport;
}
export interface RuleApplicabilityFilter {
    readonly index: RuleApplicabilityIndex;
    readonly context: ApplicabilityContext;
}
export declare function partitionByApplicability(rules: readonly CorpusRule[], filter?: RuleApplicabilityFilter): {
    applicable: CorpusRule[];
    notApplicable: NotApplicableRule[];
};
export declare function mergeRuleCoverage(a: RuleCoverage, b: RuleCoverage): RuleCoverage;
export declare class RuleEvaluationEngine {
    private readonly logger;
    private readonly strategy;
    private readonly rulesetRepo;
    constructor(options?: {
        fileSystem?: IFileSystem;
        logger?: ILogger;
        strategy?: IRuleEvaluatorStrategy;
        rulesetRepo?: IRulesetRepository;
        configParser?: IConfigParser;
    });
    discoverAndEvaluate(satellitePath: string, corePath: string, filter?: RuleApplicabilityFilter, selection?: RulesetSelection, facts?: EvaluationFacts, overrides?: RuleOverridesInput, now?: Date): Promise<CorpusEvaluation>;
    discoverCatalog(corePath: string): Promise<RulesetCatalog>;
    summarizeCoverage(results: readonly RuleEvaluationResult[]): RuleCoverage;
    toValidationIssues(results: RuleEvaluationResult[]): ValidationIssue[];
    private nonExecutableAdvisory;
}