/**
 * Failure Learning Module
 *
 * Learns from API extraction failures to build anti-patterns
 * and implement smart retry strategies.
 *
 * This module:
 * 1. Classifies failures by type (auth, rate limit, timeout, etc.)
 * 2. Tracks failure patterns per domain/pattern
 * 3. Creates anti-patterns to avoid repeating mistakes
 * 4. Provides retry strategies based on failure type
 */
import type { AntiPattern, FailureCategory, FailureClassification, FailureCounts, FailureRecord, RetryStrategy } from '../types/api-patterns.js';
/**
 * Classify a failure based on HTTP response and/or error
 *
 * @param statusCode - HTTP status code (optional)
 * @param errorMessage - Error message string, Error object, or any error-like object
 * @param responseTime - Response time in ms (optional)
 */
export declare function classifyFailure(statusCode: number | undefined, errorMessage: string | Error | unknown, responseTime?: number): FailureClassification;
/**
 * Create a failure record from classification
 */
export declare function createFailureRecord(classification: FailureClassification, domain: string, attemptedUrl: string, patternId: string, statusCode?: number, responseTime?: number): FailureRecord;
/**
 * Create an empty failure counts object
 */
export declare function createEmptyFailureCounts(): FailureCounts;
/**
 * Increment failure count for a category
 */
export declare function incrementFailureCount(counts: FailureCounts, category: FailureCategory): FailureCounts;
/**
 * Add a failure record to a list, keeping only the most recent
 */
export declare function addFailureRecord(records: FailureRecord[], newRecord: FailureRecord): FailureRecord[];
/**
 * Get failures within a time window
 */
export declare function getRecentFailures(records: FailureRecord[], windowMs?: number): FailureRecord[];
/**
 * Count failures by category within a time window
 */
export declare function countRecentFailuresByCategory(records: FailureRecord[], category: FailureCategory, windowMs?: number): number;
/**
 * Create an anti-pattern from repeated failures
 *
 * Note: The caller (maybeCreateAntiPattern) pre-filters failures by category,
 * so all failures will have the same category. We just take from the first.
 */
export declare function createAntiPattern(failures: FailureRecord[], sourcePatternId?: string): AntiPattern | null;
/**
 * Check if an anti-pattern is still active
 */
export declare function isAntiPatternActive(antiPattern: AntiPattern): boolean;
/**
 * Check if a URL matches any active anti-patterns
 */
export declare function matchAntiPatterns(url: string, antiPatterns: AntiPattern[]): AntiPattern[];
/**
 * Update an existing anti-pattern with new failure data
 */
export declare function updateAntiPattern(existing: AntiPattern, newFailure: FailureRecord): AntiPattern;
/**
 * Calculate wait time for retry based on category and attempt number
 */
export declare function calculateRetryWait(category: FailureCategory, attemptNumber: number): number;
/**
 * Check if a failure category should be retried
 */
export declare function shouldRetry(category: FailureCategory, attemptNumber: number): boolean;
/**
 * Get the retry strategy for a failure category
 */
export declare function getRetryStrategy(category: FailureCategory): RetryStrategy;
/**
 * Analyze pattern failure history to determine if it should be suppressed
 */
export declare function analyzePatternHealth(recentFailures: FailureRecord[], successCount: number, failureCount: number): {
    isHealthy: boolean;
    dominantFailureType: FailureCategory | null;
    suggestedAction: RetryStrategy;
    reason: string;
};
/**
 * Log a failure with classification details
 */
export declare function logFailure(classification: FailureClassification, context: {
    domain: string;
    url: string;
    patternId?: string;
    statusCode?: number;
}): void;
/**
 * Get a human-readable summary of failure history
 */
export declare function getFailureSummary(counts: FailureCounts): string;
/**
 * Helper function to add an anti-pattern to a pattern registry.
 * Used by LearningEngine to load persisted anti-patterns.
 * @param registry The ApiPatternRegistry to add the anti-pattern to
 * @param antiPattern The anti-pattern to add
 * @returns true if added, false if already exists or expired
 */
export declare function addAntiPatternToRegistry(registry: import('./api-pattern-learner.js').ApiPatternRegistry, antiPattern: AntiPattern): boolean;
//# sourceMappingURL=failure-learning.d.ts.map