import { EventEmitter } from 'events';
import CDP from 'chrome-remote-interface';
export interface WaitForResponseOptions {
    urlPattern: string | RegExp;
    timeout?: number;
    statusCode?: number;
}
export interface Viewport {
    width: number;
    height: number;
}
export interface Cookie {
    name: string;
    value: string;
    domain?: string;
    path?: string;
    expires?: number;
    size?: number;
    httpOnly?: boolean;
    secure?: boolean;
    session?: boolean;
    sameSite?: 'Strict' | 'Lax' | 'None';
}
export interface GotoOptions {
    waitUntil?: "domcontentloaded" | "load";
    timeout?: number;
}
export interface SelectOptionOptions {
    /** Maximum wait time in milliseconds. Default: 30000 */
    timeout?: number;
    /** Bypass visibility and disabled checks. Default: false */
    force?: boolean;
    /** Wait for dropdown options to load after opening. Default: true */
    waitForOptions?: boolean;
    /** Maximum scroll attempts for virtualized dropdowns. Default: 10 */
    maxScrollAttempts?: number;
}
export interface EvaluateResult {
    result: any;
    exceptionDetails?: {
        text: string;
    };
}
export interface ScreenshotOptions {
    /** The path to save the screenshot to. Optional. */
    path?: string;
    /** Whether to capture the full scrollable page. Default: false */
    fullPage?: boolean;
    /** The image format. Default: 'png' */
    format?: 'png' | 'jpeg';
}
export interface CdpScreenshotOptions {
    /** The image format */
    format: 'png' | 'jpeg';
    /** Whether to capture beyond the viewport */
    captureBeyondViewport?: boolean;
}
export default class CdpPage extends EventEmitter {
    _rawClient: CDP.Client;
    client: CDP.Client;
    private loadedUrl;
    isReconnecting: boolean;
    private enabledDomains;
    private connectionMonitor?;
    private isClosed;
    private humanization;
    private lastMousePosition;
    constructor(client: CDP.Client);
    private _attachConnectionMonitor;
    static create(client: CDP.Client): Promise<CdpPage>;
    private initialize;
    /**
     * Lazily enable Page domain only when needed for script injection.
     * This avoids enabling Page upfront which is a CDP detection vector.
     * Once enabled, subsequent calls are no-ops.
     */
    ensurePageEnabled(): Promise<void>;
    /**
     * Lazily enable Network domain only when needed for request interception/monitoring.
     * This avoids enabling Network upfront which is a CDP detection vector.
     * Once enabled, subsequent calls are no-ops.
     */
    ensureNetworkEnabled(): Promise<void>;
    setHumanizationOptions(options?: {
        mouse?: boolean;
        keyboard?: boolean;
        scroll?: boolean;
    }): void;
    url(): Promise<string>;
    /**
     * Get current URL without activating the Runtime domain.
     * Uses Page.getNavigationHistory which only requires the Page domain.
     */
    private _getCurrentUrlWithoutRuntime;
    goto(url: string, options?: GotoOptions): Promise<void>;
    /**
     * Reloads the current page.
     * @param options - Options for waiting and timeout, similar to goto.
     */
    reload(options?: GotoOptions): Promise<void>;
    evaluate<T>(pageFunction: Function | string, ...args: any[]): Promise<T>;
    click(selector: string, options?: {
        timeout?: number;
        force?: boolean;
        delay?: number;
        button?: 'left' | 'right' | 'middle';
        clickCount?: number;
    }): Promise<void>;
    /**
     * Performs a human-like click with proper mouse events.
     * Note: screenX/screenY compensation is handled browser-side via fingerprint
     * overrides that set realistic window.screenX/screenY values, which Chrome
     * uses when constructing MouseEvent from CDP dispatch.
     */
    private _performClick;
    private _moveMouseTo;
    /**
     * Gets detailed information about an element
     */
    private _getElementInfo;
    /**
     * Enhanced visibility check that considers more factors
     */
    private _isElementVisible;
    /**
     * Enhanced clickable check that considers more factors
     */
    private _isElementClickable;
    /**
     * Enhanced scroll into view with better positioning
     */
    private _scrollElementIntoView;
    /**
     * Waits for an element's position to stabilize by polling its position over time.
     * This is useful for waiting for scroll animations or dynamic layout changes to complete.
     *
     * @param selector - The CSS selector for the element to monitor
     * @param timeout - Maximum time to wait in milliseconds (default: 2000)
     * @param checkInterval - How often to check position in milliseconds (default: 100)
     * @param stabilityThreshold - Number of consecutive stable checks required (default: 3)
     * @param tolerance - Maximum pixel difference to consider "stable" (default: 1)
     */
    private _waitForElementPositionToStabilize;
    waitForElementPositionToStabilize(selector: string, timeout?: number, checkInterval?: number, stabilityThreshold?: number, tolerance?: number): Promise<void>;
    /**
     * Check if element is within the viewport (with some tolerance)
     */
    private _isElementInViewport;
    type(selector: string, text: string, options?: {
        delay?: number;
    }): Promise<void>;
    /**
     * Deletes (clears) the value of an input field specified by selector.
     * @param selector - The CSS selector for the input element.
     */
    deleteInput(selector: string): Promise<void>;
    setViewport(viewport: Viewport): Promise<void>;
    setUserAgent(userAgent: string): Promise<void>;
    setExtraHTTPHeaders(headers: Record<string, string>): Promise<void>;
    waitForSelector(selector: string, options?: {
        timeout?: number;
    }): Promise<void>;
    waitForResponse(urlPart: string, statusCode?: number, timeout?: number): Promise<any>;
    screenshot(options?: ScreenshotOptions): Promise<Buffer>;
    content(): Promise<string>;
    toCheerio(): Promise<cheerio.CheerioAPI>;
    close(): Promise<void>;
    elementExists(selector: string): Promise<boolean>;
    getTextContent(selector: string): Promise<string>;
    getHref(selector: string): Promise<string>;
    scrollIntoView(selector: string): Promise<void>;
    setupFetchMetadataHeaders(): Promise<void>;
    blockRequests(urlPatterns: string[]): Promise<void>;
    private getNodeId;
    setCookies(cookies: Cookie[]): Promise<void>;
    /**
      * Retrieves all cookies associated with the given URLs or all cookies for the current page if no URLs are provided.
      *
      * @param {string[]} [urls] - An optional array of URLs for which to retrieve cookies.
      *                            If no URLs are provided, the method will return all cookies associated with the current page.
      *
      * @returns {Promise<Cookie[]>} - A promise that resolves to an array of cookies.
      *                                Each cookie contains information such as name, value, domain, path, expiration, and flags like httpOnly, secure, etc.
      *
      *
      */
    getCookies(urls?: string[]): Promise<Cookie[]>;
    /**
     * Evaluates a function across multiple elements matching the given selector.
     *
     * @param selector - The CSS selector to find elements.
     * @param pageFunction - The function to execute within the browser context.
     * @param args - Additional arguments to pass to the pageFunction.
     * @returns - The result of the evaluation.
     */
    $$eval<T>(selector: string, pageFunction: (elements: HTMLElement[], ...args: any[]) => T, ...args: any[]): Promise<T>;
    /**
     * Enables a CDP domain only if it hasn't been enabled yet
     * @private
     */
    private _enableDomain;
    reconnectSession(retries?: number): Promise<void>;
    /**
     * Selects one or more options from a select element or dropdown.
     *
     * Automatically handles both regular HTML select elements and custom dropdowns:
     * - For <select> elements: Directly selects options within the select
     * - For custom dropdowns: Automatically detects and clicks triggers to open dropdowns,
     *   then selects the specified options with intelligent scrolling for virtualized lists
     *
     * @param dropdownSelector - CSS selector for the select element or dropdown container
     * @param optionSelector - CSS selector(s) for the option(s) to select. Can be a single selector or array
     * @param options - Optional configuration for timeout, scrolling, visibility checks, etc.
     *
     * @example
     * // Regular HTML select
     * await page.selectOption('select#country', 'option[value="us"]');
     *
     * // Custom dropdown (automatically finds and clicks trigger)
     * await page.selectOption('#dropdown-menu', '[data-value="premium"]');
     *
     * // Multiple selection
     * await page.selectOption('select#languages', ['option[value="en"]', 'option[value="es"]']);
     */
    selectOption(dropdownSelector: string, optionSelector: string | string[], options?: SelectOptionOptions): Promise<void>;
    /**
     * Handles selection for regular HTML select elements
     */
    private _handleRegularSelect;
    /**
     * Handles selection for custom dropdown elements.
     * Automatically detects and clicks triggers using multiple strategies:
     * - Common trigger patterns ([aria-haspopup], .dropdown-trigger, etc.)
     * - Previous sibling elements
     * - ID pattern matching (menu → trigger)
     */
    private _handleCustomDropdown;
    /**
     * Selects a single option from a dropdown container.
     * Handles virtualized lists with intelligent scrolling to find options that may not be initially visible.
     */
    private _selectOptionFromDropdown;
    /**
     * Checks if the element specified by selector is visible (not display:none and not visibility:hidden).
     * The selector should be the root item which can be hidden, otherwise this function could return a false positive.
     * @param selector - The CSS selector for the element.
     * @returns true if the element is visible, false otherwise.
     */
    isVisible(selector: string): Promise<boolean>;
}
//# sourceMappingURL=page.d.ts.map