@ohos-ports/vibium 26.5.31-beta.0

package/dist/index.d.mts

@@ -0,0 +1,1397 @@
+import * as node_stream from 'node:stream';
+import { Writable, Readable } from 'stream';
+
+interface VibiumProcessOptions {
+    headless?: boolean;
+    executablePath?: string;
+    connectURL?: string;
+    connectHeaders?: Record<string, string>;
+}
+declare class VibiumProcess {
+    private _process;
+    private _stopped;
+    private _preReadyLines;
+    private constructor();
+    /** The child process stdin stream (for sending commands). */
+    get stdin(): node_stream.Writable;
+    /** The child process stdout stream (for receiving responses/events). */
+    get stdout(): node_stream.Readable;
+    /** Lines received before the vibium:lifecycle.ready signal (buffered events). */
+    get preReadyLines(): string[];
+    static start(options?: VibiumProcessOptions): Promise<VibiumProcess>;
+    private _cleanupListeners;
+    stop(): Promise<void>;
+}
+
+interface BiDiEvent {
+    method: string;
+    params: Record<string, unknown>;
+}
+
+type EventHandler = (event: BiDiEvent) => void;
+declare class BiDiClient {
+    private stdin;
+    private rl;
+    private nextId;
+    private pendingCommands;
+    private eventHandlers;
+    private _closed;
+    private constructor();
+    /**
+     * Create a BiDiClient from stdin/stdout streams.
+     * Optionally replay pre-ready lines (events received before the ready signal).
+     */
+    static fromStreams(stdin: Writable, stdout: Readable, preReadyLines?: string[]): BiDiClient;
+    private handleResponse;
+    private handleEvent;
+    onEvent(handler: EventHandler): void;
+    offEvent(handler: EventHandler): void;
+    send<T = unknown>(method: string, params?: Record<string, unknown>, timeout?: number): Promise<T>;
+    close(): Promise<void>;
+}
+
+declare const customInspect$5: unique symbol;
+interface BoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface ElementInfo {
+    tag: string;
+    text: string;
+    box: BoundingBox;
+}
+interface ActionOptions {
+    /** Timeout in milliseconds for actionability checks. Default: 30000 */
+    timeout?: number;
+}
+interface SelectorOptions {
+    role?: string;
+    text?: string;
+    label?: string;
+    placeholder?: string;
+    alt?: string;
+    title?: string;
+    testid?: string;
+    xpath?: string;
+    near?: string;
+    timeout?: number;
+}
+declare class Element {
+    private client;
+    private context;
+    private selector;
+    private _index?;
+    private _params;
+    readonly info: ElementInfo;
+    constructor(client: BiDiClient, context: string, selector: string, info: ElementInfo, index?: number, params?: Record<string, unknown>);
+    /** Build the common params sent to vibium: commands for element resolution. */
+    private commandParams;
+    /** Return params that can identify this element for use as a target (e.g. dragTo). */
+    toParams(): Record<string, unknown>;
+    /**
+     * Click the element.
+     * Waits for element to be visible, stable, receive events, and enabled.
+     */
+    click(options?: ActionOptions): Promise<void>;
+    /** Double-click the element. */
+    dblclick(options?: ActionOptions): Promise<void>;
+    /**
+     * Fill the element with text (clears existing content first).
+     * For inputs and textareas.
+     */
+    fill(value: string, options?: ActionOptions): Promise<void>;
+    /**
+     * Type text into the element (appends to existing content).
+     * Waits for element to be visible, stable, receive events, enabled, and editable.
+     */
+    type(text: string, options?: ActionOptions): Promise<void>;
+    /**
+     * Press a key while the element is focused.
+     * Supports key names ("Enter", "Tab") and combos ("Control+a").
+     */
+    press(key: string, options?: ActionOptions): Promise<void>;
+    /** Clear the element's content (select all + delete). */
+    clear(options?: ActionOptions): Promise<void>;
+    /** Check a checkbox (no-op if already checked). */
+    check(options?: ActionOptions): Promise<void>;
+    /** Uncheck a checkbox (no-op if already unchecked). */
+    uncheck(options?: ActionOptions): Promise<void>;
+    /** Select an option in a <select> element by value. */
+    selectOption(value: string, options?: ActionOptions): Promise<void>;
+    /** Hover over the element (move mouse to center, no click). */
+    hover(options?: ActionOptions): Promise<void>;
+    /** Focus the element. */
+    focus(options?: ActionOptions): Promise<void>;
+    /** Drag this element to a target element. */
+    dragTo(target: Element, options?: ActionOptions): Promise<void>;
+    /** Tap the element (touch action). */
+    tap(options?: ActionOptions): Promise<void>;
+    /** Scroll the element into view. */
+    scrollIntoView(options?: ActionOptions): Promise<void>;
+    /** Dispatch a DOM event on the element. */
+    dispatchEvent(eventType: string, eventInit?: Record<string, unknown>, options?: ActionOptions): Promise<void>;
+    /** Set files on an <input type="file"> element. */
+    setFiles(files: string[], options?: ActionOptions): Promise<void>;
+    /** Get the element's textContent (trimmed). */
+    text(): Promise<string>;
+    /** Get the element's innerText (rendered text only). */
+    innerText(): Promise<string>;
+    /** Get the element's innerHTML. */
+    html(): Promise<string>;
+    /** Get the element's value (for inputs, textareas, selects). */
+    value(): Promise<string>;
+    /** Get an attribute value. Short name for getAttribute. */
+    attr(name: string): Promise<string | null>;
+    /** Get an attribute value. Alias for attr(). */
+    getAttribute(name: string): Promise<string | null>;
+    /** Get the element's bounding box. Short name for boundingBox. */
+    bounds(): Promise<BoundingBox>;
+    /** Get the element's bounding box. Alias for bounds(). */
+    boundingBox(): Promise<BoundingBox>;
+    /** Check if the element is visible (has dimensions, not display:none/visibility:hidden/opacity:0). */
+    isVisible(): Promise<boolean>;
+    /** Check if the element is hidden (inverse of isVisible). */
+    isHidden(): Promise<boolean>;
+    /** Check if the element is enabled (not disabled). */
+    isEnabled(): Promise<boolean>;
+    /** Check if the element is checked (for checkboxes/radios). */
+    isChecked(): Promise<boolean>;
+    /** Check if the element is editable (not disabled and not readonly). */
+    isEditable(): Promise<boolean>;
+    /** Get the element's computed ARIA role. */
+    role(): Promise<string>;
+    /** Get the element's accessible name (label). */
+    label(): Promise<string>;
+    /** Take a screenshot of just this element. Returns a PNG buffer. */
+    screenshot(): Promise<Buffer>;
+    /** Wait until the element reaches a state: "visible", "hidden", "attached", or "detached". */
+    waitUntil(state?: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    /** Find a child element by CSS selector or semantic options. Scoped to this element. */
+    find(selector: string | SelectorOptions, options?: {
+        timeout?: number;
+    }): FluentElement;
+    /** Find all child elements by CSS selector or semantic options. Scoped to this element. */
+    findAll(selector: string | SelectorOptions, options?: {
+        timeout?: number;
+    }): Promise<Element[]>;
+    [customInspect$5](): string;
+    private getCenter;
+}
+/** A Promise<Element> that also exposes Element methods for chaining. */
+type FluentElement = Promise<Element> & {
+    click(options?: ActionOptions): Promise<void>;
+    dblclick(options?: ActionOptions): Promise<void>;
+    fill(value: string, options?: ActionOptions): Promise<void>;
+    type(text: string, options?: ActionOptions): Promise<void>;
+    press(key: string, options?: ActionOptions): Promise<void>;
+    clear(options?: ActionOptions): Promise<void>;
+    check(options?: ActionOptions): Promise<void>;
+    uncheck(options?: ActionOptions): Promise<void>;
+    selectOption(value: string, options?: ActionOptions): Promise<void>;
+    hover(options?: ActionOptions): Promise<void>;
+    focus(options?: ActionOptions): Promise<void>;
+    dragTo(target: Element, options?: ActionOptions): Promise<void>;
+    tap(options?: ActionOptions): Promise<void>;
+    scrollIntoView(options?: ActionOptions): Promise<void>;
+    dispatchEvent(eventType: string, eventInit?: Record<string, unknown>, options?: ActionOptions): Promise<void>;
+    setFiles(files: string[], options?: ActionOptions): Promise<void>;
+    text(): Promise<string>;
+    innerText(): Promise<string>;
+    html(): Promise<string>;
+    value(): Promise<string>;
+    attr(name: string): Promise<string | null>;
+    getAttribute(name: string): Promise<string | null>;
+    bounds(): Promise<BoundingBox>;
+    boundingBox(): Promise<BoundingBox>;
+    isVisible(): Promise<boolean>;
+    isHidden(): Promise<boolean>;
+    isEnabled(): Promise<boolean>;
+    isChecked(): Promise<boolean>;
+    isEditable(): Promise<boolean>;
+    role(): Promise<string>;
+    label(): Promise<string>;
+    screenshot(): Promise<Buffer>;
+    waitUntil(state?: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    find(selector: string | SelectorOptions, options?: {
+        timeout?: number;
+    }): FluentElement;
+    findAll(selector: string | SelectorOptions, options?: {
+        timeout?: number;
+    }): Promise<Element[]>;
+};
+declare function fluent(promise: Promise<Element>): FluentElement;
+
+interface RecordingStartOptions {
+    name?: string;
+    screenshots?: boolean;
+    snapshots?: boolean;
+    sources?: boolean;
+    title?: string;
+    bidi?: boolean;
+    /** Screenshot format: 'jpeg' (default, faster/smaller) or 'png' (lossless). */
+    format?: 'jpeg' | 'png';
+    /** JPEG quality 0.0-1.0 (default 0.5). Ignored for PNG. */
+    quality?: number;
+}
+interface RecordingStopOptions {
+    path?: string;
+}
+declare class Recording {
+    private client;
+    private userContextId;
+    constructor(client: BiDiClient, userContextId: string);
+    /** Start recording. */
+    start(options?: RecordingStartOptions): Promise<void>;
+    /** Stop recording and return the recording zip as a Buffer. */
+    stop(options?: RecordingStopOptions): Promise<Buffer>;
+    /** Start a new recording chunk (resets event buffer, keeps resources). */
+    startChunk(options?: {
+        name?: string;
+        title?: string;
+    }): Promise<void>;
+    /** Stop the current chunk and return the recording zip as a Buffer. */
+    stopChunk(options?: RecordingStopOptions): Promise<Buffer>;
+    /** Start a named group of actions in the recording. */
+    startGroup(name: string, options?: {
+        location?: {
+            file: string;
+            line?: number;
+            column?: number;
+        };
+    }): Promise<void>;
+    /** End the current group. */
+    stopGroup(): Promise<void>;
+}
+
+interface Cookie {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    size: number;
+    httpOnly: boolean;
+    secure: boolean;
+    sameSite: string;
+    expiry?: number;
+}
+interface SetCookieParam {
+    name: string;
+    value: string;
+    domain?: string;
+    url?: string;
+    path?: string;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: string;
+    expiry?: number;
+}
+interface OriginState {
+    origin: string;
+    localStorage: {
+        name: string;
+        value: string;
+    }[];
+    sessionStorage: {
+        name: string;
+        value: string;
+    }[];
+}
+interface StorageState {
+    cookies: Cookie[];
+    origins: OriginState[];
+}
+declare class BrowserContext {
+    private client;
+    private userContextId;
+    readonly recording: Recording;
+    constructor(client: BiDiClient, userContextId: string);
+    /** The user context ID for this browser context. */
+    get id(): string;
+    /** Create a new page (tab) in this context. */
+    newPage(): Promise<Page>;
+    /** Close this context and all its pages. */
+    close(): Promise<void>;
+    /** Get cookies for this context. Optionally filter by URLs. */
+    cookies(urls?: string[]): Promise<Cookie[]>;
+    /** Set cookies in this context. */
+    setCookies(cookies: SetCookieParam[]): Promise<void>;
+    /** Clear all cookies in this context. */
+    clearCookies(): Promise<void>;
+    /** Get the storage state (cookies + localStorage + sessionStorage). */
+    storage(): Promise<StorageState>;
+    /** Set the storage state (cookies + localStorage + sessionStorage). */
+    setStorage(state: StorageState): Promise<void>;
+    /** Clear all storage (cookies + localStorage + sessionStorage). */
+    clearStorage(): Promise<void>;
+    /** Add an init script that runs before page scripts in this context. */
+    addInitScript(script: string): Promise<string>;
+}
+
+/**
+ * Network request and response data classes.
+ * Wrap BiDi event data for onRequest/onResponse callbacks.
+ */
+
+/** Wraps a BiDi network.beforeRequestSent event. */
+declare class Request {
+    private data;
+    private client;
+    constructor(data: Record<string, unknown>, client?: BiDiClient);
+    /** The request URL. */
+    url(): string;
+    /** The HTTP method (GET, POST, etc.). */
+    method(): string;
+    /** Request headers as a simple key-value object. */
+    headers(): Record<string, string>;
+    /** The request ID (BiDi network request identifier). */
+    requestId(): string;
+    /** Request body / post data. Uses BiDi network.getData when a data collector is active. */
+    postData(): Promise<string | null>;
+}
+/** Wraps a BiDi network.responseCompleted event. */
+declare class Response {
+    private data;
+    private client;
+    constructor(data: Record<string, unknown>, client?: BiDiClient);
+    /** The response URL. */
+    url(): string;
+    /** The HTTP status code. */
+    status(): number;
+    /** Response headers as a simple key-value object. */
+    headers(): Record<string, string>;
+    /** The request ID associated with this response. */
+    requestId(): string;
+    /** Response body as a string. Requires a data collector (set up by onResponse/expect.response). */
+    body(): Promise<string | null>;
+    /** Response body parsed as JSON. Requires a data collector (set up by onResponse/expect.response). */
+    json(): Promise<unknown>;
+}
+
+/** Represents an intercepted network request that can be fulfilled, continued, or aborted. */
+declare class Route {
+    readonly request: Request;
+    private client;
+    private requestId;
+    constructor(client: BiDiClient, requestId: string, request: Request);
+    /** Fulfill the request with a custom response (mock response). */
+    fulfill(response?: {
+        status?: number;
+        headers?: Record<string, string>;
+        contentType?: string;
+        body?: string;
+    }): Promise<void>;
+    /** Continue the request with optional overrides. */
+    continue(overrides?: {
+        url?: string;
+        method?: string;
+        headers?: Record<string, string>;
+        postData?: string;
+    }): Promise<void>;
+    /** Abort the request. */
+    abort(): Promise<void>;
+}
+
+/** Represents a browser dialog (alert, confirm, prompt, beforeunload). */
+declare class Dialog {
+    private client;
+    private contextId;
+    private data;
+    constructor(client: BiDiClient, contextId: string, data: Record<string, unknown>);
+    /** The dialog message text. */
+    message(): string;
+    /** The dialog type: 'alert', 'confirm', 'prompt', or 'beforeunload'. */
+    type(): string;
+    /** The default value for prompt dialogs. */
+    defaultValue(): string;
+    /** Accept the dialog. For prompt dialogs, optionally provide text. */
+    accept(promptText?: string): Promise<void>;
+    /** Dismiss the dialog (cancel/close). */
+    dismiss(): Promise<void>;
+}
+
+/** Represents a single console message from the page (console.log, warn, error, etc.). */
+declare class ConsoleMessage {
+    private data;
+    constructor(data: Record<string, unknown>);
+    /** The console method: 'log', 'warn', 'error', 'debug', 'info', etc. */
+    type(): string;
+    /** The message text. */
+    text(): string;
+    /** The serialized arguments passed to the console call. */
+    args(): unknown[];
+    /** The source location of the console call, if available. */
+    location(): {
+        url: string;
+        lineNumber: number;
+        columnNumber: number;
+    } | null;
+}
+
+/** Represents a file download triggered by the page. */
+declare class Download {
+    private client;
+    private _url;
+    private _suggestedFilename;
+    private _resolve;
+    private _completionPromise;
+    constructor(client: BiDiClient, url: string, suggestedFilename: string);
+    /** The URL of the download. */
+    url(): string;
+    /** The filename suggested by the server (from Content-Disposition). */
+    suggestedFilename(): string;
+    /** Wait for the download completion promise with a timeout. */
+    private _waitForCompletion;
+    /** Wait for the download to complete, then save to the specified path. */
+    saveAs(path: string): Promise<void>;
+    /** Wait for the download to complete and return the temp file path, or null if failed. */
+    path(): Promise<string | null>;
+    /** Internal: called by Page when downloadCompleted fires. */
+    _complete(status: string, filepath: string | null): void;
+}
+
+type MessageHandler$1 = (data: string, info: {
+    direction: 'sent' | 'received';
+}) => void;
+type CloseHandler$1 = (code?: number, reason?: string) => void;
+declare class WebSocketInfo {
+    private _url;
+    private _isClosed;
+    private messageHandlers;
+    private closeHandlers;
+    constructor(url: string);
+    url(): string;
+    onMessage(fn: MessageHandler$1): void;
+    onClose(fn: CloseHandler$1): void;
+    isClosed(): boolean;
+    /** @internal */
+    _emitMessage(data: string, direction: 'sent' | 'received'): void;
+    /** @internal */
+    _emitClose(code?: number, reason?: string): void;
+}
+
+interface ClockInstallOptions$1 {
+    /** Initial time as epoch ms, ISO date string, or Date object. */
+    time?: number | string | Date;
+    /** IANA timezone ID to override (e.g. "America/New_York", "Europe/London"). */
+    timezone?: string;
+}
+/** Page-scoped clock control for faking timers and Date. */
+declare class Clock {
+    private client;
+    private contextId;
+    constructor(client: BiDiClient, contextId: string);
+    /** Install fake clock, overriding Date, setTimeout, setInterval, etc. */
+    install(options?: ClockInstallOptions$1): Promise<void>;
+    /** Jump forward by ticks ms, fire each due timer at most once. */
+    fastForward(ticks: number): Promise<void>;
+    /** Advance ticks ms, firing all callbacks systematically (including interval reschedules). */
+    runFor(ticks: number): Promise<void>;
+    /** Jump to a specific time and pause — no timers fire until resumed/advanced. */
+    pauseAt(time: number | string | Date): Promise<void>;
+    /** Resume real-time progression from current fake time. */
+    resume(): Promise<void>;
+    /** Freeze Date.now() at a value permanently. Timers still run. */
+    setFixedTime(time: number | string | Date): Promise<void>;
+    /** Set Date.now() without triggering timers. */
+    setSystemTime(time: number | string | Date): Promise<void>;
+    /** Override the browser timezone. Pass an IANA timezone ID, or empty string to reset to system default. */
+    setTimezone(timezone: string): Promise<void>;
+}
+
+interface FindOptions {
+    /** Timeout in milliseconds to wait for element. Default: 30000 */
+    timeout?: number;
+}
+interface ScreenshotOptions {
+    /** Capture full scrollable page instead of just the viewport. */
+    fullPage?: boolean;
+    /** Capture a specific region of the page. */
+    clip?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+declare const customInspect$4: unique symbol;
+/** Page-level keyboard input. */
+declare class Keyboard {
+    private client;
+    private contextId;
+    constructor(client: BiDiClient, contextId: string);
+    /** Press and release a key. Supports combos like "Control+a". */
+    press(key: string): Promise<void>;
+    /** Press a key down (without releasing). */
+    down(key: string): Promise<void>;
+    /** Release a key. */
+    up(key: string): Promise<void>;
+    /** Type a string of text character by character. */
+    type(text: string): Promise<void>;
+}
+/** Page-level mouse input. */
+declare class Mouse {
+    private client;
+    private contextId;
+    constructor(client: BiDiClient, contextId: string);
+    /** Click at (x, y) coordinates. */
+    click(x: number, y: number): Promise<void>;
+    /** Move mouse to (x, y) coordinates. */
+    move(x: number, y: number): Promise<void>;
+    /** Press mouse button down. */
+    down(): Promise<void>;
+    /** Release mouse button. */
+    up(): Promise<void>;
+    /** Scroll the mouse wheel. */
+    wheel(deltaX: number, deltaY: number): Promise<void>;
+}
+/** Page-level touch input. */
+declare class Touch {
+    private client;
+    private contextId;
+    constructor(client: BiDiClient, contextId: string);
+    /** Tap at (x, y) coordinates. */
+    tap(x: number, y: number): Promise<void>;
+}
+interface A11yNode {
+    role: string;
+    name?: string;
+    value?: string | number;
+    description?: string;
+    disabled?: boolean;
+    expanded?: boolean;
+    focused?: boolean;
+    checked?: boolean | 'mixed';
+    pressed?: boolean | 'mixed';
+    selected?: boolean;
+    required?: boolean;
+    readonly?: boolean;
+    level?: number;
+    valuemin?: number;
+    valuemax?: number;
+    children?: A11yNode[];
+}
+declare class Page {
+    private client;
+    private contextId;
+    private _context;
+    /** Page-level keyboard input. */
+    readonly keyboard: Keyboard;
+    /** Page-level mouse input. */
+    readonly mouse: Mouse;
+    /** Page-level touch input. */
+    readonly touch: Touch;
+    /** Page-level clock control for faking timers and Date. */
+    readonly clock: Clock;
+    private routes;
+    private requestCallbacks;
+    private responseCallbacks;
+    private dialogCallbacks;
+    private consoleCallbacks;
+    private errorCallbacks;
+    private downloadCallbacks;
+    private navigationCallbacks;
+    private pendingDownloads;
+    private wsCallbacks;
+    private wsConnections;
+    private eventHandler;
+    private interceptId;
+    private dataCollectorId;
+    private _consoleBuffer;
+    private _errorBuffer;
+    constructor(client: BiDiClient, contextId: string, userContextId?: string);
+    /** The browsing context ID for this page. */
+    get id(): string;
+    [customInspect$4](): string;
+    /** The parent BrowserContext that owns this page. */
+    get context(): BrowserContext;
+    /** Navigate to a URL. */
+    go(url: string): Promise<void>;
+    /** Navigate back in history. */
+    back(): Promise<void>;
+    /** Navigate forward in history. */
+    forward(): Promise<void>;
+    /** Reload the page. */
+    reload(): Promise<void>;
+    /** Get the current page URL. */
+    url(): Promise<string>;
+    /** Get the current page title. */
+    title(): Promise<string>;
+    /** Get the full HTML content of the page. */
+    content(): Promise<string>;
+    /** @internal Wait until the page URL matches a pattern. */
+    _waitForURL(pattern: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    /** @internal Wait until the page reaches a load state. */
+    _waitForLoad(state?: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    /** Get all child frames of this page (recursive, flattened). */
+    frames(): Promise<Page[]>;
+    /** Find a frame by name attribute or URL substring. Returns null if not found. */
+    frame(nameOrUrl: string): Promise<Page | null>;
+    /** Returns this page — the page IS its own main frame. */
+    mainFrame(): Page;
+    /** Set the viewport size. */
+    setViewport(size: {
+        width: number;
+        height: number;
+    }): Promise<void>;
+    /** Get the current viewport size. */
+    viewport(): Promise<{
+        width: number;
+        height: number;
+    }>;
+    /** Override CSS media features (colorScheme, reducedMotion, forcedColors, contrast, media type). */
+    emulateMedia(opts: {
+        media?: 'screen' | 'print' | null;
+        colorScheme?: 'light' | 'dark' | 'no-preference' | null;
+        reducedMotion?: 'reduce' | 'no-preference' | null;
+        forcedColors?: 'active' | 'none' | null;
+        contrast?: 'more' | 'no-preference' | null;
+    }): Promise<void>;
+    /** Replace the page HTML content. */
+    setContent(html: string): Promise<void>;
+    /** Override the browser's geolocation. */
+    setGeolocation(coords: {
+        latitude: number;
+        longitude: number;
+        accuracy?: number;
+    }): Promise<void>;
+    /** Set the OS browser window size, position, or state. */
+    setWindow(options: {
+        width?: number;
+        height?: number;
+        x?: number;
+        y?: number;
+        state?: 'normal' | 'maximized' | 'minimized' | 'fullscreen';
+    }): Promise<void>;
+    /** Get the current OS browser window state and dimensions. */
+    window(): Promise<{
+        state: string;
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    }>;
+    /** Get the accessibility tree for the page. */
+    a11yTree(options?: {
+        everything?: boolean;
+        root?: string;
+    }): Promise<A11yNode>;
+    /** Bring this page/tab to the foreground. */
+    bringToFront(): Promise<void>;
+    /** Close this page/tab. */
+    close(): Promise<void>;
+    /** Scroll the page in a direction. */
+    scroll(direction?: string, amount?: number, selector?: string): Promise<void>;
+    /** Take a screenshot of the page. Returns a PNG buffer. */
+    screenshot(options?: ScreenshotOptions): Promise<Buffer>;
+    /** Print the page to PDF. Returns a PDF buffer. Only works in headless mode. */
+    pdf(): Promise<Buffer>;
+    /** Evaluate a JS expression and return the deserialized value. */
+    evaluate<T = unknown>(expression: string): Promise<T>;
+    /** Inject a script into the page. Pass a URL or inline JavaScript. */
+    addScript(source: string): Promise<void>;
+    /** Inject a stylesheet into the page. Pass a URL or inline CSS. */
+    addStyle(source: string): Promise<void>;
+    /** Expose a function on window. The function body is injected as a string. */
+    expose(name: string, fn: string): Promise<void>;
+    /** Capture namespace — set up a listener before performing an action. */
+    readonly capture: {
+        /** Capture a response matching a URL pattern. Optionally pass fn to trigger the action. */
+        response(pattern: string, fn?: () => Promise<void>, options?: {
+            timeout?: number;
+        }): Promise<Response>;
+        /** Capture a request matching a URL pattern. Optionally pass fn to trigger the action. */
+        request(pattern: string, fn?: () => Promise<void>, options?: {
+            timeout?: number;
+        }): Promise<Request>;
+        /** Capture a navigation event. Optionally pass fn to trigger the action. Resolves with URL. */
+        navigation(fn?: () => Promise<void>, options?: {
+            timeout?: number;
+        }): Promise<string>;
+        /** Capture a download. Optionally pass fn to trigger the action. */
+        download(fn?: () => Promise<void>, options?: {
+            timeout?: number;
+        }): Promise<Download>;
+        /** Capture a dialog. Optionally pass fn to trigger the action. */
+        dialog(fn?: () => Promise<void>, options?: {
+            timeout?: number;
+        }): Promise<Dialog>;
+        /** Capture a named event. Optionally pass fn to trigger the action. */
+        event(name: string, fn?: () => Promise<void>, options?: {
+            timeout?: number;
+        }): Promise<unknown>;
+    };
+    /** Wait until a condition is met. Callable with a function, or use .url() / .loaded() sub-methods. */
+    readonly waitUntil: ((fn: string, options?: {
+        timeout?: number;
+    }) => Promise<unknown>) & {
+        /** Wait until the page URL matches a pattern. */
+        url(pattern: string, options?: {
+            timeout?: number;
+        }): Promise<void>;
+        /** Wait until the page reaches a load state. */
+        loaded(state?: string, options?: {
+            timeout?: number;
+        }): Promise<void>;
+    };
+    /** Wait for a fixed amount of time (milliseconds). Discouraged but useful for debugging. */
+    wait(ms: number): Promise<void>;
+    /** @internal Wait until a function returns a truthy value. */
+    _waitForFunction<T = unknown>(fn: string, options?: {
+        timeout?: number;
+    }): Promise<T>;
+    /** Find an element by CSS selector or semantic options. Waits for element to exist. */
+    find(selector: string | SelectorOptions, options?: FindOptions): FluentElement;
+    /** Find all elements matching a CSS selector or semantic options. Waits for at least one. */
+    findAll(selector: string | SelectorOptions, options?: FindOptions): Promise<Element[]>;
+    /**
+     * Intercept network requests matching a URL pattern.
+     * The handler receives a Route object that can fulfill, continue, or abort the request.
+     */
+    route(pattern: string, handler: (route: Route) => void): Promise<void>;
+    /** Remove a previously registered route. If no handler given, removes all routes for the pattern. */
+    unroute(pattern: string): Promise<void>;
+    /** Register a callback for every outgoing request. */
+    onRequest(fn: (request: Request) => void): void;
+    /** Register a callback for every completed response. */
+    onResponse(fn: (response: Response) => void): void;
+    /**
+     * Remove all listeners for a given event, or all events if no event specified.
+     * Supported events: 'request', 'response', 'dialog', 'console', 'error', 'download', 'websocket'.
+     */
+    removeAllListeners(event?: 'request' | 'response' | 'dialog' | 'console' | 'error' | 'download' | 'navigation' | 'websocket'): void;
+    /** @internal Capture a request matching a URL pattern. */
+    _captureRequest(pattern: string, options?: {
+        timeout?: number;
+    }): Promise<Request>;
+    /** @internal Capture a response matching a URL pattern. */
+    _captureResponse(pattern: string, options?: {
+        timeout?: number;
+    }): Promise<Response>;
+    /** @internal Capture a navigation event. Resolves with the URL. */
+    _captureNavigation(options?: {
+        timeout?: number;
+    }): Promise<string>;
+    /** @internal Capture a download event. */
+    _captureDownload(options?: {
+        timeout?: number;
+    }): Promise<Download>;
+    /** @internal Capture a dialog event. The registered callback prevents auto-dismiss. */
+    _captureDialog(options?: {
+        timeout?: number;
+    }): Promise<Dialog>;
+    /** @internal Capture a named event. Maps event name to the appropriate callback array. */
+    _captureEvent(name: string, options?: {
+        timeout?: number;
+    }): Promise<unknown>;
+    /** Set extra HTTP headers for all requests in this page. */
+    setHeaders(headers: Record<string, string>): Promise<void>;
+    /** Intercept WebSocket connections. Not supported by BiDi. */
+    routeWebSocket(_pattern: string, _handler: unknown): never;
+    /** Listen for WebSocket connections opened by the page. */
+    onWebSocket(fn: (ws: WebSocketInfo) => void): void;
+    /**
+     * Register a handler for browser dialogs (alert, confirm, prompt).
+     * If no handler is registered, dialogs are automatically dismissed.
+     */
+    onDialog(handler: (dialog: Dialog) => void): void;
+    /** Register a handler for console messages, or pass 'collect' to buffer them for consoleMessages(). */
+    onConsole(handler: ((message: ConsoleMessage) => void) | 'collect'): void;
+    /** Return collected console messages and clear the buffer. Returns [] if not collecting. */
+    consoleMessages(): {
+        type: string;
+        text: string;
+    }[];
+    /** Register a handler for uncaught page errors, or pass 'collect' to buffer them for errors(). */
+    onError(handler: ((error: Error) => void) | 'collect'): void;
+    /** Return collected errors and clear the buffer. Returns [] if not collecting. */
+    errors(): {
+        message: string;
+    }[];
+    /** Register a handler for file downloads. */
+    onDownload(handler: (download: Download) => void): void;
+    private ensureDataCollector;
+    private teardownDataCollector;
+    private handleBeforeRequestSent;
+    private handleResponseCompleted;
+    private handleUserPromptOpened;
+    private handleLogEntryAdded;
+    private handleDownloadWillBegin;
+    private handleDownloadCompleted;
+    private handleWsCreated;
+    private handleWsMessage;
+    private handleWsClosed;
+}
+
+declare const customInspect$3: unique symbol;
+interface StartOptions {
+    headless?: boolean;
+    headers?: Record<string, string>;
+    executablePath?: string;
+}
+declare class Browser {
+    private client;
+    private process;
+    private pageCallbacks;
+    private popupCallbacks;
+    constructor(client: BiDiClient, process: VibiumProcess | null);
+    [customInspect$3](): string;
+    /** Get the default page (first browsing context). */
+    page(): Promise<Page>;
+    /** Create a new page (tab) in the default context. */
+    newPage(): Promise<Page>;
+    /** Create a new browser context (isolated, incognito-like). */
+    newContext(): Promise<BrowserContext>;
+    /** Get all open pages. */
+    pages(): Promise<Page[]>;
+    /** Register a callback for when a new page is created (e.g. new tab). */
+    onPage(callback: (page: Page) => void): void;
+    /** Register a callback for when a popup is opened (window.open or target=_blank). */
+    onPopup(callback: (page: Page) => void): void;
+    /**
+     * Remove all listeners for a given event, or all events if no event specified.
+     * Supported events: 'page', 'popup'.
+     */
+    removeAllListeners(event?: 'page' | 'popup'): void;
+    /** Stop the browser and clean up. */
+    stop(): Promise<void>;
+}
+declare const browser: {
+    start(urlOrOptions?: string | StartOptions, options?: StartOptions): Promise<Browser>;
+};
+
+/**
+ * Signal protocol (2-slot SharedArrayBuffer):
+ *   signal[0]: worker → main  (0=idle, 1=result ready, 2=callback needed)
+ *   signal[1]: main → worker  (0=idle, 1=callback response ready)
+ */
+declare class SyncBridge {
+    private worker;
+    private signal;
+    private commandId;
+    private terminated;
+    private callbackPortMain;
+    private callbackPortWorker;
+    private handlers;
+    private constructor();
+    static create(): SyncBridge;
+    /** Register a callback handler that can be invoked from the worker thread. */
+    registerHandler(id: string, handler: Function): void;
+    /** Remove a previously registered callback handler. */
+    unregisterHandler(id: string): void;
+    /** Process any pending callbacks that fired between bridge calls. */
+    private processPendingCallbacks;
+    /** Handle a single callback request from the worker. */
+    private handleCallback;
+    call<T = unknown>(method: string, args?: unknown[]): T;
+    tryQuit(): void;
+    terminate(): void;
+}
+
+declare const customInspect$2: unique symbol;
+declare class ElementSync {
+    private bridge;
+    private elementId;
+    readonly info: ElementInfo;
+    constructor(bridge: SyncBridge, elementId: number, info: ElementInfo);
+    [customInspect$2](): string;
+    /**
+     * Click the element.
+     * Waits for element to be visible, stable, receive events, and enabled.
+     */
+    click(options?: ActionOptions): void;
+    /** Double-click the element. */
+    dblclick(options?: ActionOptions): void;
+    /**
+     * Fill the element with text (clears existing content first).
+     * For inputs and textareas.
+     */
+    fill(value: string, options?: ActionOptions): void;
+    /**
+     * Type text into the element.
+     * Waits for element to be visible, stable, receive events, enabled, and editable.
+     */
+    type(text: string, options?: ActionOptions): void;
+    /**
+     * Press a key while the element is focused.
+     * Supports key names ("Enter", "Tab") and combos ("Control+a").
+     */
+    press(key: string, options?: ActionOptions): void;
+    /** Clear the element's content (select all + delete). */
+    clear(options?: ActionOptions): void;
+    /** Check a checkbox (no-op if already checked). */
+    check(options?: ActionOptions): void;
+    /** Uncheck a checkbox (no-op if already unchecked). */
+    uncheck(options?: ActionOptions): void;
+    /** Select an option in a <select> element by value. */
+    selectOption(value: string, options?: ActionOptions): void;
+    /** Hover over the element (move mouse to center, no click). */
+    hover(options?: ActionOptions): void;
+    /** Focus the element. */
+    focus(options?: ActionOptions): void;
+    /** Drag this element to a target element. */
+    dragTo(target: ElementSync, options?: ActionOptions): void;
+    /** Tap the element (touch action). */
+    tap(options?: ActionOptions): void;
+    /** Scroll the element into view. */
+    scrollIntoView(options?: ActionOptions): void;
+    /** Dispatch a DOM event on the element. */
+    dispatchEvent(eventType: string, eventInit?: Record<string, unknown>, options?: ActionOptions): void;
+    text(): string;
+    innerText(): string;
+    html(): string;
+    value(): string;
+    attr(name: string): string | null;
+    getAttribute(name: string): string | null;
+    bounds(): BoundingBox;
+    boundingBox(): BoundingBox;
+    isVisible(): boolean;
+    isHidden(): boolean;
+    isEnabled(): boolean;
+    isChecked(): boolean;
+    isEditable(): boolean;
+    screenshot(): Buffer;
+    waitUntil(state?: string, options?: {
+        timeout?: number;
+    }): void;
+    setFiles(files: string[], options?: ActionOptions): void;
+    role(): string;
+    label(): string;
+    find(selector: string | SelectorOptions, options?: {
+        timeout?: number;
+    }): ElementSync;
+    findAll(selector: string | SelectorOptions, options?: {
+        timeout?: number;
+    }): ElementSync[];
+}
+
+declare class KeyboardSync {
+    private bridge;
+    private pageId;
+    constructor(bridge: SyncBridge, pageId: number);
+    press(key: string): void;
+    down(key: string): void;
+    up(key: string): void;
+    type(text: string): void;
+}
+declare class MouseSync {
+    private bridge;
+    private pageId;
+    constructor(bridge: SyncBridge, pageId: number);
+    click(x: number, y: number): void;
+    move(x: number, y: number): void;
+    down(): void;
+    up(): void;
+    wheel(deltaX: number, deltaY: number): void;
+}
+declare class TouchSync {
+    private bridge;
+    private pageId;
+    constructor(bridge: SyncBridge, pageId: number);
+    tap(x: number, y: number): void;
+}
+
+interface ClockInstallOptions {
+    time?: number | string | Date;
+    timezone?: string;
+}
+declare class ClockSync {
+    private bridge;
+    private pageId;
+    constructor(bridge: SyncBridge, pageId: number);
+    install(options?: ClockInstallOptions): void;
+    fastForward(ticks: number): void;
+    runFor(ticks: number): void;
+    pauseAt(time: number | string | Date): void;
+    resume(): void;
+    setFixedTime(time: number | string | Date): void;
+    setSystemTime(time: number | string | Date): void;
+    setTimezone(timezone: string): void;
+}
+
+declare class RecordingSync {
+    private bridge;
+    private contextId;
+    constructor(bridge: SyncBridge, contextId: number);
+    start(options?: RecordingStartOptions): void;
+    stop(options?: RecordingStopOptions): Buffer;
+    startChunk(options?: {
+        name?: string;
+        title?: string;
+    }): void;
+    stopChunk(options?: RecordingStopOptions): Buffer;
+    startGroup(name: string, options?: {
+        location?: {
+            file: string;
+            line?: number;
+            column?: number;
+        };
+    }): void;
+    stopGroup(): void;
+}
+
+declare class BrowserContextSync {
+    private bridge;
+    private contextId;
+    readonly recording: RecordingSync;
+    constructor(bridge: SyncBridge, contextId: number);
+    newPage(): PageSync;
+    close(): void;
+    cookies(urls?: string[]): Cookie[];
+    setCookies(cookies: SetCookieParam[]): void;
+    clearCookies(): void;
+    storage(): StorageState;
+    setStorage(state: StorageState): void;
+    clearStorage(): void;
+    addInitScript(script: string): string;
+}
+
+/** Sync route handler data — plain object representing the intercepted request. */
+interface RouteRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    postData: string | null;
+}
+/** Decision returned by a sync route handler. */
+interface RouteDecision {
+    action: 'fulfill' | 'continue' | 'abort';
+    status?: number;
+    headers?: Record<string, string>;
+    contentType?: string;
+    body?: string;
+    url?: string;
+    method?: string;
+    postData?: string;
+}
+/**
+ * Sync wrapper for an intercepted network request.
+ * The user's handler calls fulfill(), continue(), or abort() to set the decision.
+ * If none is called, the default is 'continue'.
+ */
+declare class RouteSync {
+    readonly request: RouteRequest;
+    /** @internal */
+    _decision: RouteDecision;
+    constructor(request: RouteRequest);
+    /** Fulfill the request with a custom response. */
+    fulfill(response?: {
+        status?: number;
+        headers?: Record<string, string>;
+        contentType?: string;
+        body?: string;
+    }): void;
+    /** Continue the request, optionally with overrides. */
+    continue(overrides?: {
+        url?: string;
+        method?: string;
+        headers?: Record<string, string>;
+        postData?: string;
+    }): void;
+    /** Abort the request. */
+    abort(): void;
+}
+
+/** Serialized dialog data sent from worker to main thread. */
+interface DialogData {
+    type: string;
+    message: string;
+    defaultValue: string;
+}
+/** Decision returned by a sync dialog handler. */
+interface DialogDecision {
+    action: 'accept' | 'dismiss';
+    promptText?: string;
+}
+/**
+ * Sync wrapper for a browser dialog (alert, confirm, prompt, beforeunload).
+ * The user's handler calls accept() or dismiss() to set the decision.
+ * If none is called, the default is 'dismiss'.
+ */
+declare class DialogSync {
+    private data;
+    /** @internal */
+    _decision: DialogDecision;
+    constructor(data: DialogData);
+    /** The dialog type: 'alert', 'confirm', 'prompt', or 'beforeunload'. */
+    type(): string;
+    /** The dialog message text. */
+    message(): string;
+    /** The default value for prompt dialogs. */
+    defaultValue(): string;
+    /** Accept the dialog. For prompt dialogs, optionally provide text. */
+    accept(promptText?: string): void;
+    /** Dismiss the dialog (cancel/close). */
+    dismiss(): void;
+}
+
+declare const customInspect$1: unique symbol;
+interface RequestData {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    postData: string | null;
+}
+interface ResponseData {
+    url: string;
+    status: number;
+    headers: Record<string, string>;
+    body: string | null;
+}
+declare class DownloadData {
+    readonly url: string;
+    readonly suggestedFilename: string;
+    readonly path: string | null;
+    constructor(data: {
+        url: string;
+        suggestedFilename: string;
+        path: string | null;
+    });
+    /** Save the downloaded file to a destination path. */
+    saveAs(destPath: string): void;
+}
+type MessageHandler = (data: string, info: {
+    direction: 'sent' | 'received';
+}) => void;
+type CloseHandler = (code?: number, reason?: string) => void;
+declare class WebSocketInfoSync {
+    private _url;
+    private _isClosed;
+    private _messageHandlers;
+    private _closeHandlers;
+    constructor(url: string);
+    url(): string;
+    onMessage(fn: MessageHandler): void;
+    onClose(fn: CloseHandler): void;
+    isClosed(): boolean;
+    /** @internal */
+    _emitMessage(data: string, direction: 'sent' | 'received'): void;
+    /** @internal */
+    _emitClose(code?: number, reason?: string): void;
+}
+declare class PageSync {
+    /** @internal */
+    readonly _bridge: SyncBridge;
+    /** @internal */
+    readonly _pageId: number;
+    readonly keyboard: KeyboardSync;
+    readonly mouse: MouseSync;
+    readonly touch: TouchSync;
+    readonly clock: ClockSync;
+    private _nextHandlerId;
+    private _routeHandlerIds;
+    private _dialogHandlerId;
+    private _requestHandlerId;
+    private _responseHandlerId;
+    private _downloadHandlerId;
+    private _wsHandlerId;
+    private _wsInstances;
+    private _cachedContext;
+    constructor(bridge: SyncBridge, pageId: number);
+    [customInspect$1](): string;
+    /** The parent BrowserContext that owns this page. */
+    get context(): BrowserContextSync;
+    go(url: string): void;
+    back(): void;
+    forward(): void;
+    reload(): void;
+    url(): string;
+    title(): string;
+    content(): string;
+    find(selector: string | SelectorOptions, options?: FindOptions): ElementSync;
+    findAll(selector: string | SelectorOptions, options?: FindOptions): ElementSync[];
+    /** Capture namespace — set up a listener before performing an action. */
+    get capture(): {
+        response(pattern: string, fn?: () => void, options?: {
+            timeout?: number;
+        }): {
+            url: string;
+            status: number;
+            headers: Record<string, string>;
+            body: string | null;
+        };
+        request(pattern: string, fn?: () => void, options?: {
+            timeout?: number;
+        }): {
+            url: string;
+            method: string;
+            headers: Record<string, string>;
+            postData: string | null;
+        };
+        navigation(fn?: () => void, options?: {
+            timeout?: number;
+        }): {
+            url: string;
+        };
+        download(fn?: () => void, options?: {
+            timeout?: number;
+        }): DownloadData;
+        dialog(fn?: () => void, options?: {
+            timeout?: number;
+        }): {
+            type: string;
+            message: string;
+            defaultValue: string;
+        };
+        event(name: string, fn?: () => void, options?: {
+            timeout?: number;
+        }): unknown;
+    };
+    /** Wait until a condition is met. Callable with a function, or use .url() / .loaded() sub-methods. */
+    readonly waitUntil: ((fn: string, options?: {
+        timeout?: number;
+    }) => unknown) & {
+        url(pattern: string, options?: {
+            timeout?: number;
+        }): void;
+        loaded(state?: string, options?: {
+            timeout?: number;
+        }): void;
+    };
+    wait(ms: number): void;
+    screenshot(options?: ScreenshotOptions): Buffer;
+    pdf(): Buffer;
+    evaluate<T = unknown>(expression: string): T;
+    addScript(source: string): void;
+    addStyle(source: string): void;
+    expose(name: string, fn: string): void;
+    bringToFront(): void;
+    close(): void;
+    scroll(direction?: string, amount?: number, selector?: string): void;
+    setViewport(size: {
+        width: number;
+        height: number;
+    }): void;
+    viewport(): {
+        width: number;
+        height: number;
+    };
+    emulateMedia(opts: {
+        media?: 'screen' | 'print' | null;
+        colorScheme?: 'light' | 'dark' | 'no-preference' | null;
+        reducedMotion?: 'reduce' | 'no-preference' | null;
+        forcedColors?: 'active' | 'none' | null;
+        contrast?: 'more' | 'no-preference' | null;
+    }): void;
+    setContent(html: string): void;
+    setGeolocation(coords: {
+        latitude: number;
+        longitude: number;
+        accuracy?: number;
+    }): void;
+    setWindow(options: {
+        width?: number;
+        height?: number;
+        x?: number;
+        y?: number;
+        state?: 'normal' | 'maximized' | 'minimized' | 'fullscreen';
+    }): void;
+    window(): {
+        state: string;
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    };
+    frames(): PageSync[];
+    frame(nameOrUrl: string): PageSync | null;
+    mainFrame(): PageSync;
+    a11yTree(options?: {
+        everything?: boolean;
+        root?: string;
+    }): A11yNode;
+    route(pattern: string, action: 'continue' | 'abort' | {
+        status?: number;
+        body?: string;
+        headers?: Record<string, string>;
+    } | ((route: RouteSync) => void)): void;
+    unroute(pattern: string): void;
+    setHeaders(headers: Record<string, string>): void;
+    onDialog(action: 'accept' | 'dismiss' | ((dialog: DialogSync) => void)): void;
+    onConsole(mode: 'collect'): void;
+    consoleMessages(): {
+        type: string;
+        text: string;
+    }[];
+    onError(mode: 'collect'): void;
+    errors(): {
+        message: string;
+    }[];
+    onRequest(fn: (req: RequestData) => void): void;
+    onResponse(fn: (resp: ResponseData) => void): void;
+    onDownload(fn: (dl: DownloadData) => void): void;
+    onWebSocket(fn: (ws: WebSocketInfoSync) => void): void;
+    removeAllListeners(event?: 'request' | 'response' | 'dialog' | 'console' | 'error' | 'download' | 'websocket'): void;
+}
+
+declare const customInspect: unique symbol;
+declare class BrowserSync {
+    /** @internal */
+    readonly _bridge: SyncBridge;
+    private _nextHandlerId;
+    private _pageHandlerId?;
+    private _popupHandlerId?;
+    constructor(bridge: SyncBridge);
+    [customInspect](): string;
+    page(): PageSync;
+    newPage(): PageSync;
+    pages(): PageSync[];
+    newContext(): BrowserContextSync;
+    waitForPage(options?: {
+        timeout?: number;
+    }): PageSync;
+    waitForPopup(options?: {
+        timeout?: number;
+    }): PageSync;
+    onPage(callback: (page: PageSync) => void): void;
+    onPopup(callback: (page: PageSync) => void): void;
+    removeAllListeners(event?: 'page' | 'popup'): void;
+    stop(): void;
+}
+
+/**
+ * Custom error types for the Vibium client library.
+ */
+/**
+ * ConnectionError is thrown when connecting to the browser fails.
+ */
+declare class ConnectionError extends Error {
+    url: string;
+    cause?: Error | undefined;
+    constructor(url: string, cause?: Error | undefined);
+}
+/**
+ * TimeoutError is thrown when a wait operation times out.
+ */
+declare class TimeoutError extends Error {
+    selector: string;
+    timeout: number;
+    reason?: string | undefined;
+    constructor(selector: string, timeout: number, reason?: string | undefined);
+}
+/**
+ * ElementNotFoundError is thrown when a selector matches no elements.
+ */
+declare class ElementNotFoundError extends Error {
+    selector: string;
+    constructor(selector: string);
+}
+/**
+ * BrowserCrashedError is thrown when the browser process dies unexpectedly.
+ */
+declare class BrowserCrashedError extends Error {
+    exitCode: number;
+    output?: string | undefined;
+    constructor(exitCode: number, output?: string | undefined);
+}
+
+export { type A11yNode, type ActionOptions, type BoundingBox, Browser, BrowserContext, BrowserContextSync, BrowserCrashedError, BrowserSync, Clock, type ClockInstallOptions$1 as ClockInstallOptions, ClockSync, ConnectionError, ConsoleMessage, type Cookie, Dialog, Download, Element, type ElementInfo, ElementNotFoundError, ElementSync, type FindOptions, type FluentElement, Keyboard, KeyboardSync, Mouse, MouseSync, type OriginState, Page, PageSync, Recording, type RecordingStartOptions, type RecordingStopOptions, RecordingSync, Request, Response, Route, type ScreenshotOptions, type SelectorOptions, type SetCookieParam, type StartOptions, type StorageState, TimeoutError, Touch, TouchSync, WebSocketInfo, browser, fluent };