/**
 * Search Query Optimizer (GAP-006)
 *
 * Learns search API patterns from network traffic during browsing:
 * 1. Monitors network requests when user performs searches
 * 2. Detects search API endpoints that return results
 * 3. Learns query parameter patterns (q, query, search, etc.)
 * 4. Enables direct API calls for subsequent searches (bypasses form rendering)
 *
 * Expected result: 6-25x speedup for search operations
 */
import type { NetworkRequest } from '../types/index.js';
/**
 * Learned search API pattern
 */
export interface SearchApiPattern {
    /** Unique identifier */
    id: string;
    /** Domain this pattern applies to */
    domain: string;
    /** Base endpoint URL (without query parameters) */
    endpointUrl: string;
    /** Query parameter name for search term */
    queryParamName: string;
    /** HTTP method */
    method: 'GET' | 'POST';
    /** Required headers for API calls */
    requiredHeaders: Record<string, string>;
    /** Response structure information */
    responseStructure: SearchResponseStructure;
    /** Optional pagination support */
    pagination?: SearchPaginationInfo;
    /** Pattern metrics */
    metrics: SearchPatternMetrics;
    /** When pattern was discovered */
    discoveredAt: number;
    /** When pattern was last used */
    lastUsedAt: number;
    /** Whether pattern is validated */
    isValidated: boolean;
}
/**
 * Search response structure
 */
export interface SearchResponseStructure {
    /** Path to results array in response */
    resultsPath: string;
    /** Number of results typically returned */
    typicalResultCount: number;
    /** Path to total count (optional) */
    totalCountPath?: string;
    /** Detected result fields */
    resultFields: SearchResultFields;
}
/**
 * Fields detected in search results
 */
export interface SearchResultFields {
    /** Path to result title */
    title?: string;
    /** Path to result URL */
    url?: string;
    /** Path to description/snippet */
    description?: string;
    /** Other detected fields */
    [key: string]: string | undefined;
}
/**
 * Pagination info for search results
 */
export interface SearchPaginationInfo {
    /** Pagination parameter name */
    paramName: string;
    /** Pagination type */
    type: 'page' | 'offset' | 'cursor';
    /** Start value */
    startValue: number | string;
    /** Increment (for page/offset) */
    increment?: number;
}
/**
 * Metrics for search pattern usage
 */
export interface SearchPatternMetrics {
    /** Times pattern was used */
    timesUsed: number;
    /** Successful searches */
    successCount: number;
    /** Failed searches */
    failureCount: number;
    /** Average response time (ms) */
    avgResponseTime: number;
    /** Total queries processed */
    totalQueries: number;
    /** Time saved vs form rendering (ms) */
    timeSaved: number;
}
/**
 * Context for search detection
 */
export interface SearchContext {
    /** Original page URL where search happened */
    originalUrl: string;
    /** Network requests during search */
    networkRequests: NetworkRequest[];
    /** Search term used (if known) */
    searchTerm?: string;
}
/**
 * Result from search analysis
 */
export interface SearchAnalysisResult {
    /** Whether search API was detected */
    detected: boolean;
    /** Detected pattern (if any) */
    pattern?: SearchApiPattern;
    /** Confidence in the detection (0-1) */
    confidence: number;
    /** Reasons for detection/non-detection */
    reasons: string[];
}
/**
 * Search execution result
 */
export interface SearchExecutionResult {
    /** Whether search was successful */
    success: boolean;
    /** Search results */
    results?: any[];
    /** Total count (if available) */
    totalCount?: number;
    /** Response time (ms) */
    responseTime: number;
    /** Error message (if failed) */
    error?: string;
}
export declare class SearchQueryOptimizer {
    private patterns;
    private patternsByDomain;
    /**
     * Analyze network requests to detect search API patterns
     */
    analyze(context: SearchContext): Promise<SearchAnalysisResult>;
    /**
     * Check if a network request is a JSON API request
     */
    private isApiRequest;
    /**
     * Find requests that look like search API calls
     */
    private findSearchCandidates;
    /**
     * Check if response contains an array of results
     */
    private hasResultsArray;
    /**
     * Analyze a search candidate request
     */
    private analyzeSearchCandidate;
    /**
     * Detect search query parameter name
     */
    private detectQueryParamName;
    /**
     * Analyze response structure to understand search results
     */
    private analyzeResponseStructure;
    /**
     * Detect common fields in a result object
     */
    private detectResultFields;
    /**
     * Detect pagination support in URL
     */
    private detectPagination;
    /**
     * Infer pagination type from parameter name
     */
    private inferPaginationType;
    /**
     * Infer pagination start value based on parameter name
     */
    private inferStartValue;
    /**
     * Build endpoint URL without query parameter and volatile parameters
     * Filters out session IDs, timestamps, nonces, and other non-stable params
     */
    private buildEndpointUrl;
    /**
     * Extract relevant headers for API calls
     */
    private extractRelevantHeaders;
    /**
     * Parse response body if it's a string
     */
    private parseResponseBody;
    /**
     * Get value by dot-notation path
     * Handles keys containing dots by first checking if the path exists as a single key
     */
    private getValueByPath;
    /**
     * Generate unique pattern ID
     */
    private generatePatternId;
    /**
     * Create empty metrics object
     */
    private createEmptyMetrics;
    /**
     * Store a discovered pattern
     */
    private storePattern;
    /**
     * Get pattern by ID
     */
    getPattern(id: string): SearchApiPattern | undefined;
    /**
     * Get patterns for a domain
     */
    getPatternsForDomain(domain: string): SearchApiPattern[];
    /**
     * Find matching pattern for a domain
     */
    findMatchingPattern(domain: string): SearchApiPattern | null;
    /**
     * Generate search URL from pattern and query
     */
    generateSearchUrl(pattern: SearchApiPattern, query: string): string;
    /**
     * Generate search URL with pagination
     */
    generateSearchUrlWithPage(pattern: SearchApiPattern, query: string, pageValue: number | string): string;
    /**
     * Extract results from API response using learned structure
     */
    extractResults(pattern: SearchApiPattern, responseBody: any): any[];
    /**
     * Extract total count from API response
     */
    extractTotalCount(pattern: SearchApiPattern, responseBody: any): number | undefined;
    /**
     * Record pattern usage result
     */
    recordUsage(patternId: string, success: boolean, responseTime: number, resultCount?: number): void;
    /**
     * Update running average
     */
    private updateRunningAverage;
    /**
     * Get optimizer statistics
     */
    getStatistics(): {
        totalPatterns: number;
        validatedPatterns: number;
        byDomain: Record<string, number>;
        totalTimeSaved: number;
        totalQueries: number;
        avgResponseTime: number;
    };
    /**
     * Clear all patterns
     */
    clear(): void;
}
/** Default search query optimizer instance */
export declare const searchQueryOptimizer: SearchQueryOptimizer;
//# sourceMappingURL=search-query-optimizer.d.ts.map