import { CognitiveTrace, LoopDetectionResult, SentinelConfig } from './types.js';
export declare class Sentinel {
    private stateHistory;
    private readonly maxHistorySize;
    private config;
    constructor(config?: Partial<SentinelConfig>);
    /**
     * Enhanced statistical anomaly detection using entropy and advanced metrics
     */
    private detectStatisticalAnomalies;
    /**
     * Time series analysis for detecting temporal patterns
     */
    private detectTemporalPatterns;
    /**
     * Strategy 1: Domain-Agnostic Action Pattern Analysis
     * Detects loops using semantic action similarity and behavioral patterns
     */
    detectActionAnomalies(trace: CognitiveTrace & {
        recent_actions: string[];
    }, windowSize?: number, sessionId?: string): Promise<LoopDetectionResult>;
    /**
     * Strategy 2: Domain-Agnostic State Invariance Tracking
     * Detects when the agent returns to functionally equivalent states
     */
    detectStateInvariance(trace: CognitiveTrace & {
        recent_actions: string[];
    }, threshold?: number, windowSize?: number): LoopDetectionResult;
    /**
     * Strategy 3: Enhanced Progress Heuristic Evaluation
     * Uses domain-agnostic analysis with progressive thresholds for stagnation detection
     */
    detectProgressStagnation(trace: CognitiveTrace & {
        recent_actions: string[];
    }, windowSize?: number, sessionId?: string, similarityMatrix?: number[][]): Promise<LoopDetectionResult>;
    /**
     * Hybrid loop detection combining all three strategies
     */
    detectLoop(trace: CognitiveTrace & {
        recent_actions: string[];
    }, method?: 'statistical' | 'pattern' | 'hybrid', windowSize?: number, sessionId?: string): Promise<LoopDetectionResult>;
    private calculateHashSimilarity;
    /**
     * Update configuration for progress indicators and thresholds
     */
    updateConfig(newConfig: Partial<SentinelConfig>): void;
    /**
     * Get current configuration
     */
    getConfig(): SentinelConfig;
    /**
     * Helper method to calculate action frequencies
     */
    private calculateActionFrequencies;
    /**
     * Helper method to hash actions for numerical analysis
     */
    private hashAction;
    /**
     * Advanced time series analysis for detecting complex temporal patterns
     */
    private analyzeActionTimeSeries;
    /**
     * Simple FFT implementation for frequency analysis
     */
    private simpleFFT;
    /**
     * Find dominant frequency in FFT output
     */
    private findDominantFrequency;
    /**
     * Calculate entropy manually since simple-statistics doesn't have it
     */
    private calculateEntropy;
    /**
     * Calculate autocorrelation manually
     */
    private calculateAutocorrelation;
    /**
     * Calculate moving average manually
     */
    private calculateMovingAverage;
    /**
     * Reset internal state (useful for testing or starting new sessions)
     */
    reset(): void;
    /**
     * Identify specific actions involved in the loop based on dominant detection method
     */
    private getActionsInvolvedInLoop;
    /**
     * Get actions with repeated parameters by leveraging existing parameter detection logic
     */
    private getParameterRepeatedActions;
    /**
     * PERFORMANCE OPTIMIZED: Cluster actions using precomputed similarity matrix
     */
    private clusterWithPrecomputedSimilarity;
    /**
     * Calculate semantic similarity between two action strings using semantic analyzer
     */
    private semanticSimilarity;
    /**
     * Extract action name and parameters from action string
     */
    private extractActionParameters;
    /**
     * Calculate similarity between parameter sets
     */
    private parameterSimilarity;
    /**
     * Calculate token-level similarity between strings
     */
    private tokenSimilarity;
    /**
     * Calculate semantic repetition ratio from clustered actions
     */
    private calculateSemanticRepetition;
    /**
     * Detect patterns in action parameters
     */
    private detectParameterPatterns;
    /**
     * PERFORMANCE OPTIMIZED: Detect cyclical patterns using precomputed similarity matrix
     */
    private detectCyclicalPatterns;
    /**
     * PERFORMANCE OPTIMIZED: Detect oscillation patterns using precomputed similarity matrix
     */
    private detectOscillationPatterns;
    /**
     * Detect alternating patterns using semantic clusters
     */
    private detectAlternatingPatterns;
    /**
     * Extract domain-agnostic state features from context string
     */
    private extractStateFeatures;
    /**
     * Create a hash from state features for comparison
     */
    private hashStateFeatures;
    /**
     * Calculate semantic similarity between state hashes using their features
     */
    private calculateSemanticStateSimilarity;
    /**
     * Detect if states are converging over time (becoming more similar)
     */
    private detectStateConvergence;
    /**
     * Calculate the velocity of action changes (domain-agnostic pattern analysis)
     */
    private calculateActionChangeVelocity;
    /**
     * PERFORMANCE OPTIMIZED: Calculate semantic variation using fast embedding-based diversity
     */
    private calculateSemanticVariation;
    /**
     * PERFORMANCE OPTIMIZED: Check for progress indicators using batch processing
     */
    private checkProgressIndicators;
}