/**
 * BasePage — shared IPage method implementations for DOM helpers.
 *
 * Both Page (daemon-backed) and CDPPage (direct CDP) execute JS the same way
 * for DOM operations. This base class deduplicates ~200 lines of identical
 * click/type/scroll/wait/snapshot/interceptor methods.
 *
 * Subclasses implement the transport-specific methods: goto, evaluate,
 * getCookies, screenshot, tabs, etc.
 */
import type { BrowserCookie, BrowserEvaluateFunction, FetchJsonOptions, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
import { type ResolveOptions, type TargetMatchLevel } from './target-resolver.js';
export interface ResolveSuccess {
    matches_n: number;
    /**
     * Cascading stale-ref tier the resolver traversed. Callers surface this to
     * agents so `stable` / `reidentified` hits are visibly distinct from a
     * clean `exact` match — the page changed, the action still succeeded.
     */
    match_level: TargetMatchLevel;
}
export interface FillTextResult extends ResolveSuccess {
    filled: boolean;
    verified: boolean;
    expected: string;
    actual: string;
    length: number;
    mode?: 'input' | 'textarea' | 'contenteditable';
}
export interface SetCheckedResult extends ResolveSuccess {
    checked: boolean;
    changed: boolean;
    kind?: string;
}
export interface UploadFilesResult extends ResolveSuccess {
    uploaded: boolean;
    files: number;
    file_names: string[];
    target: string;
    multiple?: boolean;
    accept?: string;
}
export interface DragResult {
    dragged: boolean;
    source: string;
    target: string;
    source_matches_n: number;
    target_matches_n: number;
    source_match_level: TargetMatchLevel;
    target_match_level: TargetMatchLevel;
}
export declare abstract class BasePage implements IPage {
    protected _lastUrl: string | null;
    /** Cached previous snapshot hashes for incremental diff marking */
    private _prevSnapshotHashes;
    private _cdpTargetMarkerSeq;
    private _axRefs;
    abstract goto(url: string, options?: {
        waitUntil?: 'load' | 'none';
        settleMs?: number;
        allowBoundNavigation?: boolean;
    }): Promise<void>;
    abstract evaluate<T = unknown>(js: string): Promise<T>;
    abstract evaluate<Args extends unknown[], T>(fn: BrowserEvaluateFunction<Args, T>, ...args: Args): Promise<Awaited<T>>;
    /**
     * Safely evaluate JS with pre-serialized arguments.
     * Each key in `args` becomes a `const` declaration with JSON-serialized value,
     * prepended to the JS code. Prevents injection by design.
     *
     * Usage:
     *   page.evaluateWithArgs(`(async () => { return sym; })()`, { sym: userInput })
     */
    evaluateWithArgs(js: string, args: Record<string, unknown>): Promise<unknown>;
    fetchJson(url: string, opts?: FetchJsonOptions): Promise<unknown>;
    abstract getCookies(opts?: {
        domain?: string;
        url?: string;
    }): Promise<BrowserCookie[]>;
    abstract screenshot(options?: ScreenshotOptions): Promise<string>;
    annotatedScreenshot(options?: ScreenshotOptions): Promise<string>;
    abstract tabs(): Promise<unknown[]>;
    abstract selectTab(target: number | string): Promise<void>;
    click(ref: string, opts?: ResolveOptions): Promise<ResolveSuccess>;
    /** Uses native CDP click support when the concrete page exposes it. */
    protected tryNativeClick(x: number, y: number): Promise<boolean>;
    protected tryNativeMouseMove(x: number, y: number): Promise<boolean>;
    protected tryNativeDoubleClick(x: number, y: number): Promise<boolean>;
    protected tryNativeDrag(from: {
        x: number;
        y: number;
    }, to: {
        x: number;
        y: number;
    }): Promise<boolean>;
    protected tryClickAxRef(ref: string): Promise<ResolveSuccess | null>;
    private resolveAxRefPoint;
    private axBoxCenter;
    /** Uses native CDP text insertion when the concrete page exposes it. */
    protected tryNativeType(text: string): Promise<boolean>;
    /** Uses native CDP key events when the concrete page exposes them. */
    protected tryNativeKeyPress(key: string, modifiers: string[]): Promise<boolean>;
    protected isResolvedFocused(): Promise<boolean>;
    /**
     * Run a DOM-domain CDP command against `window.__resolved`.
     *
     * CDP DOM.focus / DOM.scrollIntoViewIfNeeded need a nodeId, while our
     * resolver stores the live Element in page JS. Bridge the two worlds with a
     * short-lived marker attribute, then query it through CDP.
     */
    protected tryCdpOnResolvedElement(method: 'DOM.focus' | 'DOM.scrollIntoViewIfNeeded'): Promise<boolean>;
    typeText(ref: string, text: string, opts?: ResolveOptions): Promise<ResolveSuccess>;
    hover(ref: string, opts?: ResolveOptions): Promise<ResolveSuccess>;
    focus(ref: string, opts?: ResolveOptions): Promise<ResolveSuccess & {
        focused: boolean;
    }>;
    dblClick(ref: string, opts?: ResolveOptions): Promise<ResolveSuccess>;
    private readCheckableState;
    setChecked(ref: string, checked: boolean, opts?: ResolveOptions): Promise<SetCheckedResult>;
    private setFileInputBySelector;
    uploadFiles(ref: string, files: string[], opts?: ResolveOptions): Promise<UploadFilesResult>;
    drag(source: string, target: string, opts?: {
        from?: ResolveOptions;
        to?: ResolveOptions;
    }): Promise<DragResult>;
    fillText(ref: string, text: string, opts?: ResolveOptions): Promise<FillTextResult>;
    pressKey(key: string): Promise<void>;
    scrollTo(ref: string, opts?: ResolveOptions): Promise<unknown>;
    getFormState(): Promise<Record<string, unknown>>;
    scroll(direction?: string, amount?: number): Promise<void>;
    autoScroll(options?: {
        times?: number;
        delayMs?: number;
    }): Promise<void>;
    networkRequests(includeStatic?: boolean): Promise<unknown[]>;
    consoleMessages(_level?: string): Promise<unknown[]>;
    wait(options: number | WaitOptions): Promise<void>;
    snapshot(opts?: SnapshotOptions): Promise<unknown>;
    private collectAxSnapshotTrees;
    getCurrentUrl(): Promise<string | null>;
    installInterceptor(pattern: string): Promise<void>;
    getInterceptedRequests(): Promise<unknown[]>;
    waitForCapture(timeout?: number): Promise<void>;
    /** Fallback basic snapshot */
    protected _basicSnapshot(opts?: Pick<SnapshotOptions, 'interactive' | 'compact' | 'maxDepth' | 'raw'>): Promise<unknown>;
}