/**
 * Dynamic Content Loading Detection (GAP-008)
 *
 * Learns which XHR/fetch calls load essential page content:
 * 1. Monitors network traffic during page load
 * 2. Identifies API endpoints that return content-like data
 * 3. Learns content response structure (data paths, arrays, etc.)
 * 4. Enables waiting for specific endpoints instead of generic networkidle
 *
 * Expected result: 20-50% faster page loads for dynamic sites
 */
import type { NetworkRequest } from '../types/index.js';
/**
 * Trigger type for content loading
 */
export type ContentTriggerType = 'immediate' | 'delayed' | 'on_scroll' | 'on_interaction' | 'on_visibility';
/**
 * Learned content loading pattern
 */
export interface ContentLoadingPattern {
    /** Unique identifier */
    id: string;
    /** Domain this pattern applies to */
    domain: string;
    /** API endpoint that loads content */
    endpoint: string;
    /** URL pattern for matching (regex-safe) */
    urlPattern: string;
    /** HTTP method */
    method: 'GET' | 'POST';
    /** When content is triggered to load */
    triggerType: ContentTriggerType;
    /** Delay in ms for 'delayed' trigger */
    triggerDelay?: number;
    /** Parameters that vary between requests */
    variableParams: string[];
    /** Response structure information */
    responseStructure: ContentResponseStructure;
    /** Whether this endpoint is essential for page content */
    isEssential: boolean;
    /** Confidence in this pattern (0-1) */
    confidence: number;
    /** Pattern metrics */
    metrics: ContentLoadingMetrics;
    /** When pattern was discovered */
    discoveredAt: number;
    /** When pattern was last used */
    lastUsedAt: number;
    /** Whether pattern is validated */
    isValidated: boolean;
}
/**
 * Response structure for content API
 */
export interface ContentResponseStructure {
    /** Path to data in response (e.g., "data.items", "results") */
    dataPath: string;
    /** Type of data at the path */
    dataType: 'array' | 'object' | 'string';
    /** Estimated item count (for arrays) */
    itemCount?: number;
    /** Size of response in bytes */
    responseSize: number;
    /** Fields that look like content */
    contentFields: string[];
}
/**
 * Metrics for content loading pattern
 */
export interface ContentLoadingMetrics {
    /** Times pattern was matched */
    timesMatched: number;
    /** Successful loads */
    successCount: number;
    /** Failed loads */
    failureCount: number;
    /** Average response time (ms) */
    avgResponseTime: number;
    /** Average response size (bytes) */
    avgResponseSize: number;
    /** Time saved vs networkidle (ms) */
    timeSaved: number;
}
/**
 * Result from content loading analysis
 */
export interface ContentLoadingAnalysisResult {
    /** Whether content loading patterns were detected */
    detected: boolean;
    /** Detected patterns (sorted by relevance) */
    patterns: ContentLoadingPattern[];
    /** Confidence in the detection (0-1) */
    confidence: number;
    /** Reasons for detection/non-detection */
    reasons: string[];
    /** Recommended wait strategy */
    recommendedStrategy: 'networkidle' | 'endpoint' | 'domcontentloaded';
    /** If endpoint strategy, which endpoint to wait for */
    recommendedEndpoint?: string;
}
/**
 * Context for content loading detection
 */
export interface ContentLoadingContext {
    /** Original page URL */
    originalUrl: string;
    /** Network requests during page load */
    networkRequests: NetworkRequest[];
    /** Initial HTML before JS execution (if available) */
    initialHtml?: string;
    /** Final HTML after JS execution */
    finalHtml?: string;
    /** Time from navigation start to networkidle (ms) */
    loadTime: number;
}
export declare class ContentLoadingDetector {
    private patterns;
    private patternsByDomain;
    /**
     * Analyze network requests to detect content loading patterns
     */
    analyze(context: ContentLoadingContext): Promise<ContentLoadingAnalysisResult>;
    /**
     * Get patterns for a domain
     */
    getPatternsForDomain(domain: string): ContentLoadingPattern[];
    /**
     * Get the best pattern for waiting
     */
    getBestWaitPattern(domain: string): ContentLoadingPattern | undefined;
    /**
     * Record a successful pattern match
     */
    recordSuccess(patternId: string, responseTime: number, responseSize: number): void;
    /**
     * Record a pattern failure
     */
    recordFailure(patternId: string, reason: string): void;
    /**
     * Export patterns for persistence
     */
    exportPatterns(): ContentLoadingPattern[];
    /**
     * Import patterns from storage
     */
    importPatterns(patterns: ContentLoadingPattern[]): void;
    /**
     * Check if a request is a content API request
     */
    private isContentApiRequest;
    /**
     * Analyze a request for content characteristics
     */
    private analyzeRequest;
    /**
     * Analyze response body for content structure
     */
    private analyzeResponseBody;
    /**
     * Find content-like fields in an object
     */
    private findContentFields;
    /**
     * Get value by dot-separated path
     */
    private getValueByPath;
    /**
     * Create a pattern from a request
     */
    private createPattern;
    /**
     * Extract variable parameters from URL
     */
    private extractVariableParams;
    /**
     * Create a regex-safe URL pattern
     */
    private createUrlPattern;
    /**
     * Store a pattern
     */
    private storePattern;
}
/** Default content loading detector instance */
export declare const contentLoadingDetector: ContentLoadingDetector;
/**
 * Create a new content loading detector
 */
export declare function createContentLoadingDetector(): ContentLoadingDetector;
//# sourceMappingURL=content-loading-detector.d.ts.map