/**
 * BrowserSession — Playwright wrapper managing a singleton browser + page.
 * Auto-closes after idle timeout (5 minutes).
 * Supports live view streaming (JPEG frames) and direct interaction.
 */
import type { Page } from 'playwright';
import { BrowserActionLog } from './browser-action-log';
import { DeviceEmulation } from './device-presets';
export { FOCUS_REPORTING_SCRIPT, SET_FOCUSED_INPUT_VALUE_SCRIPT } from './page-scripts';
/**
 * Payload passed to Playwright's `FileChooser.setFiles`.
 *  - `string[]`: absolute paths on the agent FS (workspace files chosen by the user).
 *  - `Array<{name,mimeType,buffer}>`: in-memory file content uploaded from the web client
 *    as base64. Playwright forwards the buffer directly to the browser via CDP, so no
 *    temp files are needed and there is no race between file deletion and browser read.
 */
export type FileChooserPayload = string[] | Array<{
    name: string;
    mimeType: string;
    buffer: Buffer;
}>;
/**
 * Payload emitted to the Web client when the focused input/textarea changes,
 * its value/selection changes, or focus leaves a reporting target.
 *
 * Mirrors the `browser_focus_changed` wire contract (rect and below). When
 * `focused` is false, the overlay is hidden and the remaining fields are
 * omitted. Coordinates in `rect` are getBoundingClientRect raw values
 * (CSS px, viewport-relative).
 */
export interface FocusChangePayload {
    /** Whether a reporting-target input/textarea is focused. false hides overlay. */
    focused: boolean;
    /** getBoundingClientRect of the focused element (CSS px, viewport-relative). */
    rect?: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    /** Current value of the element. */
    value?: string;
    selectionStart?: number;
    selectionEnd?: number;
    /** True when the element is a <textarea>. */
    multiline?: boolean;
    /** input `type` attribute ('text'|'password'|... / 'textarea' for textarea). */
    inputType?: string;
    /** maxLength attribute (omitted when -1/unset). */
    maxLength?: number;
    /** Computed font-size in px. */
    fontSize?: number;
    /** Computed line-height in px (omitted when 'normal'/non-numeric). */
    lineHeight?: number;
    /** Computed text-align. */
    textAlign?: string;
    /** Computed padding-top in px. */
    paddingTop?: number;
    /** Computed padding-left in px. */
    paddingLeft?: number;
    /** Resolved caret color (caret-color, falling back to text color when 'auto'). */
    caretColor?: string;
}
export declare class BrowserSession {
    private browser;
    private context;
    private page;
    private idleTimer;
    private readonly idleTimeoutMs;
    private liveViewInterval;
    private _debouncedCapture;
    private _debounceTimer;
    private _liveViewOnFrame;
    private _lastFrameData;
    private _currentDeviceId;
    private closed;
    private readonly onClosed?;
    private pendingFileChooser;
    /**
     * ファイルチューザーが開いたときに呼ばれるコールバック。
     * accept(files) でファイル内容を設定する。accept は `setFiles` の結果を
     * 反映した Promise を返すため、呼び出し側で失敗を検知できる。
     */
    onFileChooser: ((accept: (files: FileChooserPayload) => Promise<void>) => void) | null;
    /**
     * フォーカスされた報告対象 input/textarea の変化を Web 側へ通知するコールバック。
     * `enableFocusReporting` が exposeBinding 経由でブラウザからのイベントを受けてこれを呼ぶ。
     */
    onFocusChange: ((payload: FocusChangePayload) => void) | null;
    /**
     * `page.exposeBinding('__onBrowserFocus', ...)` を一度だけ呼ぶためのガード。
     * 同じ名前の binding を二重登録すると Playwright が例外を投げるため。
     */
    private focusReportingExposed;
    /**
     * One-shot guard so a failing `__onBrowserFocus` binding callback is logged to
     * the Node logger at most once. The browser-side script already rate-limits
     * its own console.warn, but nothing subscribes to page console, so without
     * this the caret overlay could die with zero server-side trace.
     */
    private focusBindingErrorLogged;
    /**
     * Get the currently active device emulation ID, or null if none.
     */
    get currentDeviceId(): string | null;
    /** Session-scoped temporary variables */
    readonly variables: Map<string, string>;
    /** Action log for recording browser operations */
    readonly actionLog: BrowserActionLog;
    constructor(idleTimeoutMs?: number, onClosed?: () => void);
    /**
     * Get the current page, launching browser if needed.
     */
    getPage(): Promise<Page>;
    /**
     * Enable focus emulation so the page renders as if always focused.
     * This keeps the text caret (cursor) visible in input fields even though
     * the headless browser window itself never has OS-level focus.
     * Safe no-op on non-Chromium engines (CDP unavailable).
     */
    private enableFocusEmulation;
    /**
     * Install focus/value/selection reporting for simple input/textarea elements.
     *
     * Exposes the `__onBrowserFocus` binding once per session (guarded by
     * `focusReportingExposed`; re-exposing the same name throws in Playwright),
     * then injects FOCUS_REPORTING_SCRIPT both as an init script (for future
     * navigations) and into the current document (for the already-loaded page).
     * The script is idempotent via `window.__browserFocusReportingInstalled`.
     *
     * Binding exposure and script injection are wrapped in SEPARATE try/catch
     * blocks so a partial failure stays isolated: a failed binding expose must
     * not prevent the script from being injected, and a failed script injection
     * must not flip `focusReportingExposed` back (which would later trigger a
     * duplicate-name re-expose that throws). The `focusReportingExposed` guard is
     * only set true after the expose actually succeeds, and only the expose path
     * is gated by it — script injection is attempted on every page so it is not
     * coupled to whether the binding was (re-)exposed this call.
     *
     * Mirrors enableFocusEmulation's policy: failures are logged via warn and
     * never propagated — focus reporting is best-effort and not critical.
     */
    private enableFocusReporting;
    /**
     * Re-evaluate FOCUS_REPORTING_SCRIPT against the CURRENT document to force an
     * immediate focus report.
     *
     * Needed after a navigation/goto: the document is replaced, so an element that
     * the page autofocuses (e.g. a login field) is already focused by the time the
     * agent regains control. `focusin` only fires on focus CHANGES, so without an
     * explicit re-evaluation that element would never be reported and the overlay
     * caret would never appear. The script's listener registration is idempotent
     * (guarded), so this only triggers the initial report; the `__onBrowserFocus`
     * binding is intentionally NOT re-exposed here (it is session-scoped and would
     * throw on a duplicate name). No-op when no page is active; failures are warned
     * and swallowed, mirroring enableFocusReporting's best-effort policy.
     */
    reportFocusNow(): Promise<void>;
    /**
     * Reflect a value into the currently-focused reporting-target input/textarea.
     *
     * Uses the native value setter + InputEvent('input') dispatch so controlled
     * React components do not roll the value back, and applies the selection range
     * when both bounds are provided. No-op when the active element is not a
     * reporting target. Throws when no page is active.
     */
    setFocusedInputValue(value: string, selectionStart?: number, selectionEnd?: number): Promise<void>;
    /**
     * Check if a browser session is currently active.
     */
    isActive(): boolean;
    /**
     * Close the browser and clean up resources.
     */
    close(): Promise<void>;
    /**
     * Attach context-level listeners. Registers a 'page' handler so file inputs
     * that open in a popup / new tab still surface the filechooser event.
     * Called both when the initial context is created and whenever the context is
     * recreated (e.g. by setDeviceEmulation), to avoid losing the listener.
     */
    private attachContextListeners;
    private attachPageListeners;
    /**
     * Set device emulation by recreating the browser context with the new userAgent.
     * This ensures the server receives the correct User-Agent on every request.
     * Pass null to clear emulation (reset to default UA).
     */
    setDeviceEmulation(emulation: DeviceEmulation | null): Promise<void>;
    /**
     * Set the viewport size for the current page.
     * If deviceId is a non-empty string, apply corresponding device emulation.
     * If deviceId is empty string, clear device emulation.
     * If deviceId is undefined, don't change emulation (backward compat).
     */
    setViewport(width: number, height: number, deviceId?: string): Promise<void>;
    /**
     * Take a screenshot of the current page.
     */
    screenshot(fullPage?: boolean): Promise<Buffer>;
    /**
     * Start live view streaming. Takes JPEG screenshots at the specified interval
     * and calls the onFrame callback with the base64-encoded data.
     * While live view is active, the idle timeout is disabled.
     */
    startLiveView(intervalMs: number, onFrame: (base64: string) => void): void;
    /**
     * Take a single live-view JPEG screenshot and forward it to the callback
     * returned by `getOnFrame()`, skipping the call when the frame is
     * byte-identical to the last one sent or when `getOnFrame()` resolves to
     * null (e.g. live view was stopped while the screenshot was in flight).
     *
     * `getOnFrame` is a thunk rather than a plain callback because the
     * debounced call site needs it: it passes `() => this._liveViewOnFrame`
     * so the mutable field is re-read AFTER this method's `await`, letting a
     * `stopLiveView()` that races the in-flight screenshot correctly suppress
     * a stale delivery. The interval call site has no such race (it closes
     * over the fixed `onFrame` parameter, which never changes for the life of
     * the interval) and passes `() => onFrame` purely to share this method's
     * signature — see the two call sites in `startLiveView`. Shared by the
     * interval-driven and debounced (event-triggered) capture paths. Errors
     * are logged (never thrown) — a failed capture just means this tick's
     * frame is skipped.
     */
    private captureLiveViewFrame;
    /**
     * Stop live view streaming and re-enable idle timeout.
     */
    stopLiveView(): void;
    /**
     * Check if live view is currently active.
     */
    isLiveViewActive(): boolean;
    /**
     * Click at the specified coordinates.
     */
    executeMouseClick(x: number, y: number, button?: string, clickCount?: number): Promise<void>;
    /**
     * Scroll the page.
     */
    executeMouseWheel(deltaX: number, deltaY: number): Promise<void>;
    /**
     * Move the mouse to the given coordinates without pressing any button.
     * Used for drag-to-select text on the live view canvas.
     */
    executeMouseMove(x: number, y: number): Promise<void>;
    /**
     * Read the CSS `cursor` value of the element at the given coordinates.
     * Used by the live view to mirror the page's cursor shape on the web canvas.
     * Throws when no page is active; propagates page.evaluate errors so the
     * caller can skip the update for that frame.
     */
    getCursorAt(x: number, y: number): Promise<string>;
    /**
     * Move to (x, y) and press a mouse button without releasing it.
     * Pair with executeMouseMove / executeMouseUp to perform drag-selection.
     */
    executeMouseDown(x: number, y: number, button?: string): Promise<void>;
    /**
     * Move to (x, y) and release a mouse button.
     * Completes a drag-selection started by executeMouseDown.
     */
    executeMouseUp(x: number, y: number, button?: string): Promise<void>;
    /**
     * Type text into the focused element.
     */
    executeKeyboardType(text: string): Promise<void>;
    /**
     * Press a key combination.
     */
    executeKeyboardPress(key: string, modifiers?: string[]): Promise<void>;
    /**
     * Get the currently selected text on the page.
     * Reads the selection from a focused input/textarea, falling back to the
     * document selection for normal page content. Returns an empty string when
     * nothing is selected.
     */
    getSelectedText(): Promise<string>;
    /**
     * Navigate back.
     */
    goBack(): Promise<void>;
    /**
     * Navigate forward.
     */
    goForward(): Promise<void>;
    /**
     * Reload the page.
     */
    reload(): Promise<void>;
    /**
     * Get current page URL.
     */
    getCurrentUrl(): string;
    /**
     * Whether this session is still usable (not closed). Used by the resume path
     * to decide between reusing an existing live session and replying
     * `resume_failed` so the Web client can fall back to a fresh open.
     */
    get isAlive(): boolean;
    /**
     * Get current page title.
     */
    getPageTitle(): Promise<string>;
    private resetIdleTimer;
    private clearIdleTimer;
    private assertPageActive;
}
//# sourceMappingURL=browser-session.d.ts.map