/**
 * Capture Agent — WebPlaywrightLocal RuntimeAdapter
 *
 * Thin adapter delegating to the existing Browser class from src/browser.ts.
 * This is the first (and for now only) RuntimeAdapter implementation.
 */
import type { Browser } from './browser.js';
import type { AKTree, OutscaleConfig, VideoPageSignals } from './types.js';
import type { RuntimeAdapter, ClickOptions, WaitCondition, RecordingOptions, RecordingResult, SemanticTarget, ProgressSnapshot, VisualStabilityResult } from './execution-types.js';
import { type ResolveOptions } from './semantic-resolver.js';
export declare function isRecognizedHintCookieKey(key: string, kind: 'locale' | 'theme'): boolean;
export declare class WebPlaywrightLocal implements RuntimeAdapter {
    private browser;
    private recordingDir?;
    private readonly sessionStartedAt;
    private recording;
    private clipCursor;
    /**
     * Flags / hooks that surface mid-recording navigations in CLI logs. When a
     * navigation (NAVIGATE opcode, SET_LOCALE storage reload) is initiated by
     * the runner, `expectedNavigationCount` is bumped before the call and
     * decremented when the framenavigated handler observes it — so any nav that
     * fires WITHOUT a pending count is logged as UNEXPECTED (likely page-side
     * `location.reload()`, session redirect, or HMR). `detach()` removes the
     * listeners when recording ends.
     */
    private recordingNavWatcher;
    constructor(browser: Browser, recordingDir?: string | undefined);
    navigate(url: string): Promise<void>;
    getCurrentUrl(): Promise<string>;
    getPageTitle(): Promise<string | null>;
    /** AUT-240 (Layer A): live text of the first match, for text_contains. */
    getTextContent(selector: string): Promise<string | null>;
    detectAppVersion(): Promise<string | null>;
    getAKTree(): Promise<AKTree>;
    getPageSignals(): Promise<VideoPageSignals>;
    click(selector: string, options?: ClickOptions): Promise<void>;
    /**
     * Click an element using semantic target resolution.
     * Tries CSS selector first, falls back to Playwright semantic locators.
     */
    clickByTarget(opts: ResolveOptions & {
        onClick?: (timestampMs: number) => void;
    }): Promise<void>;
    /**
     * Type into an element using semantic target resolution.
     */
    typeByTarget(opts: ResolveOptions, text: string, clearFirst?: boolean, typeOpts?: {
        onKeystroke?: (timestampMs: number) => void;
    }): Promise<void>;
    /**
     * Wait for an element using semantic target resolution.
     */
    waitForTarget(opts: ResolveOptions, timeoutMs?: number): Promise<boolean>;
    /**
     * Scroll an element into view using semantic target resolution.
     */
    scrollIntoViewByTarget(opts: ResolveOptions): Promise<void>;
    type(selector: string, text: string, clearFirst?: boolean, opts?: {
        onKeystroke?: (timestampMs: number) => void;
    }): Promise<void>;
    pressKey(key: string): Promise<void>;
    scroll(direction: 'up' | 'down' | 'left' | 'right', amount?: number): Promise<void>;
    scrollIntoView(selector: string): Promise<void>;
    waitFor(condition: WaitCondition): Promise<boolean>;
    /** AUT-240 (Layer C): cheap page-activity snapshot for the progress watchdog. */
    getProgressSnapshot(): Promise<ProgressSnapshot>;
    /** AUT-240 (Layer B): wait for the page to be visually stable before capture. */
    waitForVisuallyStable(options?: {
        maxWaitMs?: number;
    }): Promise<VisualStabilityResult>;
    dismissOverlays(): Promise<{
        dismissed: boolean;
        method: string | null;
    }>;
    takeScreenshot(): Promise<Buffer>;
    takeElementScreenshot(selector: string, outscale?: OutscaleConfig): Promise<Buffer>;
    takeCleanScreenshot(): Promise<Buffer>;
    beginRecording(options: RecordingOptions): Promise<void>;
    getElementBoundingBox(selector: string): Promise<{
        x: number;
        y: number;
        width: number;
        height: number;
    } | null>;
    endRecording(): Promise<RecordingResult>;
    setLocale(locale: string): Promise<void>;
    setColorScheme(scheme: 'light' | 'dark'): Promise<void>;
    reloadPage(): Promise<void>;
    writeStorageHint(params: {
        storage: 'localStorage' | 'sessionStorage' | 'cookie';
        key: string;
        value: string;
        kind: 'locale' | 'theme';
    }): Promise<boolean>;
    hover(selector: string): Promise<void>;
    hoverByTarget(opts: ResolveOptions): Promise<void>;
    selectOption(selector: string, option: {
        label?: string;
        value?: string;
        index?: number;
    }): Promise<void>;
    selectOptionByTarget(opts: ResolveOptions, option: {
        label?: string;
        value?: string;
        index?: number;
    }): Promise<void>;
    checkByTarget(opts: ResolveOptions, checked: boolean, actionOpts?: {
        onClick?: (timestampMs: number) => void;
    }): Promise<void>;
    doubleClickByTarget(opts: ResolveOptions, actionOpts?: {
        onClick?: (timestampMs: number) => void;
    }): Promise<void>;
    check(selector: string, checked: boolean, actionOpts?: {
        onClick?: (timestampMs: number) => void;
    }): Promise<void>;
    doubleClick(selector: string, actionOpts?: {
        onClick?: (timestampMs: number) => void;
    }): Promise<void>;
    drag(opts: {
        selector?: string;
        target?: SemanticTarget;
        selectorAlternates?: string[];
        toSelector?: string;
        toTarget?: SemanticTarget;
        toSelectorAlternates?: string[];
        offset?: {
            dx: number;
            dy: number;
        };
        locale?: string;
    }): Promise<void>;
    cloneElement(opts: {
        sourceSelector: string;
        containerSelector: string;
        count: number;
        removeSource?: boolean;
    }): Promise<{
        clonedCount: number;
    }>;
    setAttribute(opts: {
        selector: string;
        attribute: string;
        value: string;
    }): Promise<void>;
    setTextContent(opts: {
        selector: string;
        text: string;
    }): Promise<void>;
    removeElement(opts: {
        selector: string;
    }): Promise<{
        removedCount: number;
    }>;
    setInputValue(opts: {
        selector: string;
        value: string;
    }): Promise<void>;
    clickHidden(opts: {
        selector: string;
    }): Promise<void>;
    extractFavicon(): Promise<{
        buffer: Buffer;
        mimeType: string;
    } | null>;
    close(): Promise<void>;
    private typeIntoLocator;
    private seedClipCursor;
    private moveClipCursorToViewportCenter;
    /**
     * Animate the cursor to a point inside `locator` and return that point so
     * the caller can click at the SAME coordinates (via
     * `locator.click({ position })`). Returning the target avoids the "snap"
     * bug where Playwright's default click recentered the mouse after the
     * human-like Bezier landed somewhere off-center.
     *
     * Returns null when the cursor overlay is disabled, when the element has
     * no bounding box, or when the cursor is already inside the element (no
     * move needed, caller should let Playwright click at its default center).
     */
    private moveClipCursorToLocator;
    /**
     * Convert an absolute viewport point to a position relative to `locator`'s
     * bounding box, suitable for `locator.click({ position })`. Returns null
     * if the point is outside the box (defensive fallback — callers should
     * then let Playwright click at the default center).
     */
    private relativeClickPosition;
    private moveClipCursorToPoint;
    private emitClipClickPulse;
    /**
     * Drain the browser-side `__akClickAt` buffer for timestamps newer than
     * `sinceMs`, replay them through `onClick`, and reset the buffer so the
     * next click action starts fresh. This is what makes mouse SFX line up
     * exactly with the visual click in the recorded video — the mousedown
     * listener inside the cursor overlay timestamps each click at the same
     * instant the browser dispatches it, which is also the frame the CDP
     * screencast captures.
     *
     * Falls back to `sinceMs` (Node wall-clock at action dispatch) when the
     * buffer is empty (e.g. `useKeyboard` Enter-press path, or transient
     * page.evaluate failure).
     */
    private reportClickSfxTimestamps;
}
export declare function describeResolveOptions(opts: ResolveOptions): string;