/**
 * Stealth Browser - Anti-bot evasion for Playwright
 *
 * Wraps playwright-extra with the stealth plugin to bypass common bot detection.
 * This module is OPTIONAL - falls back to regular Playwright if stealth deps aren't installed.
 *
 * The stealth plugin handles:
 * - navigator.webdriver removal
 * - chrome.runtime patching
 * - WebGL vendor/renderer spoofing
 * - Plugin array spoofing
 * - User agent consistency fixes
 * - Permission API overrides
 * - iframe.contentWindow fixes
 *
 * Install optional dependencies:
 *   npm install playwright-extra puppeteer-extra-plugin-stealth
 */
import type { Browser, BrowserContext, LaunchOptions } from 'playwright';
/**
 * Browser fingerprint profile for consistent identity
 */
export interface BrowserFingerprint {
    userAgent: string;
    viewport: {
        width: number;
        height: number;
    };
    deviceScaleFactor: number;
    locale: string;
    timezoneId: string;
    platform: string;
    clientHints?: {
        brands: Array<{
            brand: string;
            version: string;
        }>;
        mobile: boolean;
        platform: string;
        platformVersion: string;
    };
}
/**
 * Generate a random but consistent browser fingerprint
 * @param seed Optional seed for deterministic fingerprint (e.g., domain name)
 */
export declare function generateFingerprint(seed?: string): BrowserFingerprint;
/**
 * Check if stealth mode is available
 */
export declare function isStealthAvailable(): boolean;
/**
 * Get the stealth load error if any
 */
export declare function getStealthError(): string | null;
/**
 * Stealth browser configuration
 */
export interface StealthBrowserConfig {
    /** Enable stealth mode (default: true if deps available) */
    stealth?: boolean | 'auto';
    /** Custom fingerprint to use */
    fingerprint?: BrowserFingerprint;
    /** Generate fingerprint from seed (e.g., domain name for consistency) */
    fingerprintSeed?: string;
    /** Standard Playwright launch options */
    launchOptions?: LaunchOptions;
}
/**
 * Launch a browser with stealth mode if available
 */
export declare function launchStealthBrowser(config?: StealthBrowserConfig): Promise<{
    browser: Browser;
    fingerprint: BrowserFingerprint;
    stealthEnabled: boolean;
}>;
/**
 * Context initialization scripts for additional evasion
 * These run before any page scripts and patch detectable properties
 */
export declare const EVASION_SCRIPTS: {
    /**
     * Remove navigator.webdriver property
     */
    removeWebdriver: string;
    /**
     * Patch navigator.permissions.query to hide automation
     */
    patchPermissions: string;
    /**
     * Spoof plugins array to look like real browser
     */
    spoofPlugins: string;
    /**
     * Spoof mimeTypes to match plugins
     */
    spoofMimeTypes: string;
    /**
     * Fix chrome.runtime to exist but be empty (expected on real Chrome)
     */
    fixChromeRuntime: string;
    /**
     * Patch languages to be consistent
     */
    patchLanguages: (locale: string) => string;
};
/**
 * Get all evasion scripts combined for a fingerprint
 */
export declare function getEvasionScripts(fingerprint: BrowserFingerprint): string;
/**
 * Create a stealth browser context with all evasion measures
 */
export declare function createStealthContext(browser: Browser, fingerprint: BrowserFingerprint, options?: {
    /** Apply evasion scripts (default: true) */
    applyEvasionScripts?: boolean;
}): Promise<BrowserContext>;
/**
 * Get Accept-Language header for a fingerprint
 */
export declare function getAcceptLanguage(fingerprint: BrowserFingerprint): string;
/**
 * Get headers that should match the fingerprint
 */
export declare function getFingerprintHeaders(fingerprint: BrowserFingerprint): Record<string, string>;
/**
 * Get HTTP fetch headers for stealth requests
 * This applies to ContentIntelligence and LightweightRenderer (non-Playwright tiers)
 */
export declare function getStealthFetchHeaders(options?: {
    fingerprint?: BrowserFingerprint;
    fingerprintSeed?: string;
    /** Merge with additional headers */
    extraHeaders?: Record<string, string>;
}): Record<string, string>;
/**
 * Behavioral delay utilities for human-like timing
 */
export declare const BehavioralDelays: {
    /**
     * Random delay between actions (simulates human reaction time)
     * @param min Minimum delay in ms (default: 100)
     * @param max Maximum delay in ms (default: 500)
     */
    randomDelay(min?: number, max?: number): number;
    /**
     * Sleep for a random duration
     */
    sleep(min?: number, max?: number): Promise<void>;
    /**
     * Get a jittered delay (for rate limiting backoff)
     * Adds randomness to avoid synchronized retries
     */
    jitteredDelay(baseDelay: number, jitterFactor?: number): number;
    /**
     * Exponential backoff with jitter
     */
    exponentialBackoff(attempt: number, baseDelay?: number, maxDelay?: number): number;
};
/**
 * Human-like mouse movement simulation
 * Uses Bezier curves to simulate natural hand movements
 */
export declare const HumanMouseMovement: {
    /**
     * Generate a random point within the viewport
     */
    randomPoint(width: number, height: number): {
        x: number;
        y: number;
    };
    /**
     * Generate control points for a Bezier curve (human-like path)
     * Humans don't move in straight lines - they curve slightly
     */
    generateBezierPath(start: {
        x: number;
        y: number;
    }, end: {
        x: number;
        y: number;
    }, steps?: number): Array<{
        x: number;
        y: number;
    }>;
    /**
     * Calculate realistic movement duration based on distance
     * Uses Fitts's Law approximation
     */
    calculateDuration(distance: number, targetSize?: number): number;
    /**
     * Generate random "looking around" movements
     * Humans often move mouse while reading/thinking
     */
    generateIdleMovements(viewport: {
        width: number;
        height: number;
    }, currentPos: {
        x: number;
        y: number;
    }, count?: number): Array<{
        x: number;
        y: number;
    }>;
};
/**
 * Stealth configuration that applies to all tiers
 */
export interface StealthConfig {
    /** Enable stealth mode (default: true) */
    enabled: boolean;
    /** Fingerprint to use (or generate from seed) */
    fingerprint?: BrowserFingerprint;
    /** Seed for consistent fingerprint generation (e.g., domain name) */
    fingerprintSeed?: string;
    /** Apply behavioral delays */
    behavioralDelays: boolean;
    /** Minimum delay between requests in ms */
    minDelay: number;
    /** Maximum delay between requests in ms */
    maxDelay: number;
}
export declare const DEFAULT_STEALTH_CONFIG: StealthConfig;
/**
 * Get stealth configuration from environment or defaults
 */
export declare function getStealthConfig(overrides?: Partial<StealthConfig>): StealthConfig;
/**
 * Human-like typing simulation
 * Varies typing speed to mimic natural human typing patterns
 */
export declare const HumanTyping: {
    /**
     * Calculate delay for next keystroke
     * Humans type faster for common letters, slower at word boundaries
     */
    getKeystrokeDelay(char: string, prevChar: string | null): number;
    /**
     * Generate typing sequence with realistic delays
     */
    generateTypingSequence(text: string): Array<{
        char: string;
        delayAfter: number;
    }>;
};
/**
 * Helper functions to apply human-like behavior to Playwright pages
 * These wrap common actions with realistic timing and movement
 */
export declare const HumanActions: {
    /**
     * Move mouse to element and click with human-like behavior
     * Includes curved path, variable speed, and pre-click pause
     */
    clickLikeHuman(page: {
        mouse: {
            move: (x: number, y: number) => Promise<void>;
            click: (x: number, y: number) => Promise<void>;
        };
        evaluate: (fn: () => {
            width: number;
            height: number;
        }) => Promise<{
            width: number;
            height: number;
        }>;
    }, targetX: number, targetY: number, currentPos?: {
        x: number;
        y: number;
    }): Promise<void>;
    /**
     * Type text with human-like variable speed
     */
    typeLikeHuman(page: {
        keyboard: {
            type: (char: string) => Promise<void>;
        };
    }, text: string): Promise<void>;
    /**
     * Scroll page naturally (not instant jumps)
     */
    scrollLikeHuman(page: {
        evaluate: (fn: (scrollTo: number) => void, arg: number) => Promise<void>;
        waitForTimeout: (ms: number) => Promise<void>;
    }, targetY: number, currentY?: number): Promise<void>;
    /**
     * Simulate "reading" the page - random mouse movements and pauses
     */
    simulateReading(page: {
        mouse: {
            move: (x: number, y: number) => Promise<void>;
        };
        evaluate: (fn: () => {
            width: number;
            height: number;
        }) => Promise<{
            width: number;
            height: number;
        }>;
    }, durationMs?: number): Promise<void>;
    /**
     * Wait a random "human" amount of time before taking action
     * Simulates reading/thinking time
     */
    thinkBeforeAction(minMs?: number, maxMs?: number): Promise<void>;
};
//# sourceMappingURL=stealth-browser.d.ts.map