import type { TaintPath, TaintSource, SecuritySink } from '../types/taint';
import type { ParsedWorkflow } from '../types/workflow';
import type { WorkflowGraph } from '../types/graph';
export type FindingCategory = 'injection' | 'ssrf' | 'xss' | 'credential-exposure' | 'prompt-injection' | 'configuration' | 'information-disclosure' | 'prototype-pollution';
export type FindingSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
export type FindingConfidence = 'high' | 'medium' | 'low';
export interface SecurityReferences {
    cwe?: string;
    owasp?: string;
    capec?: string;
    documentation?: string;
}
export interface RemediationGuidance {
    summary: string;
    steps: string[];
    safePattern?: string;
    exampleCode?: string;
}
export interface FindingSource {
    node: string;
    nodeType: string;
    field: string;
}
export interface FindingSink {
    node: string;
    nodeType: string;
    parameter: string;
    dangerousExpression?: string;
}
export interface Finding {
    id: string;
    ruleId: string;
    severity: FindingSeverity;
    confidence: FindingConfidence;
    title: string;
    description: string;
    category: FindingCategory;
    source: FindingSource;
    sink: FindingSink;
    path: string[];
    remediation: RemediationGuidance;
    references: SecurityReferences;
    metadata: Record<string, unknown>;
}
export interface RuleMetadata {
    id: string;
    name: string;
    description: string;
    category: FindingCategory;
    severity: FindingSeverity;
    tags: string[];
    references: SecurityReferences;
}
export interface RuleContext {
    workflow: ParsedWorkflow;
    graph: WorkflowGraph;
    sources: TaintSource[];
    sinks: SecuritySink[];
    taintPaths: TaintPath[];
}
export interface DetectionRule {
    metadata: RuleMetadata;
    isApplicable(context: RuleContext): boolean;
    detect(context: RuleContext): Finding[];
}
export interface RuleConfig {
    enabled: boolean;
    severityOverride?: FindingSeverity;
    customPatterns?: string[];
}
export type RulesConfig = Record<string, RuleConfig>;
export interface RunRulesOptions {
    config?: RulesConfig;
    ruleIds?: string[];
    categories?: FindingCategory[];
    minSeverity?: FindingSeverity;
}
export interface RulesResult {
    findings: Finding[];
    rulesRun: number;
    rulesSkipped: number;
    errors: RuleError[];
    duration: number;
}
export interface RuleError {
    ruleId: string;
    message: string;
    stack?: string;
}
export interface FindingBuilder {
    fromTaintPath(taintPath: TaintPath, options: {
        ruleId: string;
        title: string;
        description: string;
        category: FindingCategory;
        confidence: FindingConfidence;
        remediation: RemediationGuidance;
        references: SecurityReferences;
        metadata?: Record<string, unknown>;
    }): Finding;
}
export declare function createFindingId(ruleId: string): string;
export declare function getEffectiveSeverity(baseSeverity: FindingSeverity, isSanitized: boolean): FindingSeverity;
export declare const SEVERITY_ORDER: Record<FindingSeverity, number>;
export declare function compareSeverity(a: FindingSeverity, b: FindingSeverity): number;
export declare function meetsSeverityThreshold(severity: FindingSeverity, minSeverity: FindingSeverity): boolean;