/**
 * Dynamic rule evaluator for runtime scanning.
 * Evaluates dynamic-capable rules against request/response contexts without enforcement.
 */
import type { DynamicRuleDefinition } from "./dynamic-rules";
import { type AuditSink } from "./audit-sink";
import { PrivacyControls } from "./privacy-controls";
import { type PromptInjectionClassifierRunner } from "./prompt-injection-classifier";
import type { AuditLogEntry, CanaryConfig, ClassifierConfig, EnforcementMode, FindingFeedbackResult, FindingFeedbackVerdict, RuntimeEventPipelineConfig, RuntimeEventPipelineMetrics, RuntimeContext, DynamicFinding, SDKStats, RuntimePolicyConfig, ToolAuthorizationPolicyConfig, SessionRiskTrackingConfig, RuleThresholdOverrides } from "./types";
/**
 * Evaluates dynamic rules against a request/response context in observe-only mode.
 * Findings are emitted but never block traffic.
 */
export declare class DynamicEvaluator {
    private static readonly SESSION_RULE_BASE;
    private rules;
    private stats;
    private onFinding?;
    private onError?;
    private evaluationTimeoutMs;
    private readonly policyEvaluator;
    private readonly actionEngine;
    private readonly auditPipeline;
    private readonly privacyControls;
    private readonly environment;
    private readonly runtimeEventPipelineConfig?;
    private runtimeEventMetrics;
    private readonly circuitBreaker;
    private readonly onShadowBlockAlert?;
    private readonly criticalAlerting;
    private readonly findingRuleIndex;
    private readonly findingRuleInsertionOrder;
    private readonly feedbackByRule;
    private readonly feedbackInsertionOrder;
    private readonly disabledRuleIds;
    private static readonly MAX_FINDING_INDEX_ENTRIES;
    private static readonly MAX_FEEDBACK_ENTRIES;
    private ruleThresholdOverrides;
    private readonly sessions;
    private readonly streamWindows;
    private readonly maxSessionTurns;
    private readonly sessionTtlMs;
    private readonly streamTtlMs;
    private readonly tokenBudget?;
    private readonly toolAuthorization;
    private readonly sessionRiskTracking;
    private readonly maxPayloadBytes;
    private readonly classifierConfig?;
    private classifierRunner?;
    constructor(rules?: DynamicRuleDefinition[], config?: {
        onFinding?: (finding: DynamicFinding) => void | Promise<void>;
        onError?: (error: Error) => void;
        evaluationTimeoutMs?: number;
        environment?: string;
        policy?: RuntimePolicyConfig;
        enforcementMode?: EnforcementMode;
        canary?: CanaryConfig;
        onAuditLog?: (entry: AuditLogEntry) => void | Promise<void>;
        auditSink?: AuditSink;
        runtimeEventPipeline?: RuntimeEventPipelineConfig;
        privacyControls?: PrivacyControls;
        routePinning?: {
            enforcedRoutes?: readonly string[];
        };
        circuitBreaker?: {
            mode?: "disabled" | "fail-open";
            errorRateThresholdPercent?: number;
            minRequests?: number;
        };
        onShadowBlockAlert?: (alert: {
            finding: DynamicFinding;
            decision: import("./types").ActionDecision;
            timestamp: number;
        }) => void | Promise<void>;
        criticalAlerting?: {
            enabled?: boolean;
            pagerDuty?: {
                routingKey?: string;
                eventAction?: "trigger";
            };
            opsGenie?: {
                apiKey?: string;
                apiUrl?: string;
                priority?: "P1" | "P2" | "P3" | "P4" | "P5";
            };
        };
        canaryToken?: string;
        tokenBudget?: {
            maxPerSessionTokens: number;
            windowMs: number;
        };
        maxPayloadBytes?: number;
        classifierConfig?: ClassifierConfig;
        classifierRunner?: PromptInjectionClassifierRunner;
        toolAuthorization?: ToolAuthorizationPolicyConfig;
        sessionRiskTracking?: SessionRiskTrackingConfig;
    });
    /**
     * Evaluates all dynamic rules against a captured request/response context.
     * Returns findings in canonical FindingSchema format.
     * Never blocks execution - failures are logged and processing continues.
     */
    evaluate(context: RuntimeContext): Promise<DynamicFinding[]>;
    /**
     * Evaluates a partial streaming response chunk.
     * This keeps runtime fail-open semantics while allowing early detection.
     */
    evaluateStreamChunk(chunkText: string, context: RuntimeContext): Promise<DynamicFinding[]>;
    /**
     * Gets or creates the classifier runner, falling back to heuristic
     * detection when the ONNX model is unavailable.
     */
    private getOrCreateClassifierRunner;
    private evaluatePromptInjectionClassifier;
    private evaluateResponseRiskClassifier;
    /**
     * Creates a DynamicFinding from a rule match.
     */
    private createFinding;
    private processRuleMatches;
    private emitRuntimeFallbackFinding;
    private pruneExpiredStreamWindows;
    private getRecentSessionContext;
    private parseToolCalls;
    private extractUrlFromArgs;
    private isAllowedWebhookDomain;
    private evaluateToolCalls;
    private updateSessionRisk;
    private pruneExpiredSessions;
    private evaluateSessionWindow;
    /**
     * Records an error non-fatally.
     * Errors are logged but never block execution (observe-only mode).
     */
    private recordError;
    /**
     * Gets current evaluation statistics.
     */
    getStats(): SDKStats;
    /**
     * Resets statistics counters.
     */
    resetStats(): void;
    /**
     * Gets the number of active dynamic rules.
     */
    getRuleCount(): number;
    /**
     * Gets recorded runtime decision audit entries.
     */
    getAuditLogEntries(): readonly AuditLogEntry[];
    getAuditLogEntriesForTenant(tenantId: string): readonly AuditLogEntry[];
    deleteAuditLogEntriesForTenant(tenantId: string): number;
    /**
     * Gets runtime event pipeline metrics.
     */
    getRuntimeEventMetrics(): RuntimeEventPipelineMetrics;
    incrementAccessDenied(): void;
    incrementRequestsSkipped(): void;
    setRuleThresholdOverrides(overrides: RuleThresholdOverrides): void;
    setDisabledRuleIds(ruleIds: readonly string[]): void;
    submitFeedback(findingId: string, verdict: FindingFeedbackVerdict): FindingFeedbackResult | null;
    setFeedbackPrior(ruleId: string, alpha: number, beta: number): void;
    private applyBayesianCalibration;
    private triggerCriticalAlert;
    private triggerPagerDutyAlert;
    private triggerOpsGenieAlert;
}