browserclaw 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,728 @@
+interface FrameEvalResult {
+    frameUrl: string;
+    frameName: string;
+    result: unknown;
+}
+
+/** Supported browser types that can be detected and launched. */
+type ChromeKind = 'chrome' | 'brave' | 'edge' | 'chromium' | 'canary' | 'custom';
+/** A detected browser executable on the system. */
+interface ChromeExecutable {
+    /** The type of browser (chrome, brave, edge, etc.) */
+    kind: ChromeKind;
+    /** Absolute path to the browser executable */
+    path: string;
+}
+/** Options for launching a new browser instance. */
+interface LaunchOptions {
+    /** Run in headless mode (no visible window). Default: `false` */
+    headless?: boolean;
+    /** Path to a specific browser executable. Auto-detected if omitted. */
+    executablePath?: string;
+    /** CDP port to use. Default: `9222` */
+    cdpPort?: number;
+    /** Disable Chrome's sandbox (needed in some Docker/CI environments). Default: `false` */
+    noSandbox?: boolean;
+    /** Custom user data directory. Auto-generated if omitted. */
+    userDataDir?: string;
+    /** Profile name shown in the Chrome title bar. Default: `'browserclaw'` */
+    profileName?: string;
+    /** Profile accent color as a hex string (e.g. `'#FF4500'`). Default: `'#FF4500'` */
+    profileColor?: string;
+    /** Additional Chrome command-line arguments (e.g. `['--start-maximized']`). */
+    chromeArgs?: string[];
+}
+/** Options for connecting to an existing browser instance. */
+interface ConnectOptions {
+    /** CDP endpoint URL (e.g. `'http://localhost:9222'`) */
+    cdpUrl: string;
+}
+/**
+ * Describes a single interactive element found during a snapshot.
+ * Used to resolve refs (e.g. `e1`) back to Playwright locators.
+ */
+interface RoleRefInfo {
+    /** ARIA role of the element (e.g. `'button'`, `'textbox'`, `'link'`) */
+    role: string;
+    /** Accessible name of the element */
+    name?: string;
+    /** Disambiguation index when multiple elements share the same role + name */
+    nth?: number;
+}
+/** Map of ref IDs (e.g. `'e1'`, `'e2'`) to their element information. */
+type RoleRefs = Record<string, RoleRefInfo>;
+/** Result of taking a page snapshot. */
+interface SnapshotResult {
+    /** AI-readable text representation of the page with numbered refs */
+    snapshot: string;
+    /** Map of ref IDs to element information for targeting actions */
+    refs: RoleRefs;
+    /** Statistics about the snapshot */
+    stats?: SnapshotStats;
+}
+/** Statistics about a snapshot's content. */
+interface SnapshotStats {
+    /** Number of lines in the snapshot text */
+    lines: number;
+    /** Number of characters in the snapshot text */
+    chars: number;
+    /** Total number of refs assigned */
+    refs: number;
+    /** Number of interactive element refs (buttons, links, inputs, etc.) */
+    interactive: number;
+}
+/** Options for controlling snapshot output. */
+interface SnapshotOptions {
+    /** Only include interactive elements (buttons, links, inputs, etc.) */
+    interactive?: boolean;
+    /** Remove structural containers that don't contain interactive elements */
+    compact?: boolean;
+    /** Maximum tree depth to include */
+    maxDepth?: number;
+    /** Maximum character count before truncation (aria mode only) */
+    maxChars?: number;
+    /** CSS selector to scope the snapshot to a specific element */
+    selector?: string;
+    /** Frame selector for snapshotting inside iframes (role mode only) */
+    frameSelector?: string;
+    /**
+     * Snapshot strategy:
+     * - `'aria'` (default) — uses Playwright's `_snapshotForAI()`, produces refs like `e1`
+     * - `'role'` — uses Playwright's `ariaSnapshot()` + `getByRole()` resolution
+     */
+    mode?: 'role' | 'aria';
+}
+/** A node in the raw ARIA accessibility tree. */
+interface AriaNode {
+    /** Ref ID for this node (e.g. `'ax1'`) */
+    ref: string;
+    /** ARIA role (e.g. `'button'`, `'heading'`, `'generic'`) */
+    role: string;
+    /** Accessible name */
+    name: string;
+    /** Current value (for inputs, sliders, etc.) */
+    value?: string;
+    /** Accessible description */
+    description?: string;
+    /** Backend DOM node ID (for CDP operations) */
+    backendDOMNodeId?: number;
+    /** Depth in the accessibility tree (0 = root) */
+    depth: number;
+}
+/** Result of a raw ARIA tree snapshot. */
+interface AriaSnapshotResult {
+    /** Flat list of accessibility tree nodes */
+    nodes: AriaNode[];
+}
+/** A form field to fill as part of a batch `fill()` operation. */
+interface FormField {
+    /** Ref ID of the form field (e.g. `'e3'`) */
+    ref: string;
+    /** Field type: `'text'`, `'checkbox'`, `'radio'`, etc. */
+    type: string;
+    /** Value to set. Booleans for checkboxes, strings for text fields. */
+    value?: string | number | boolean;
+}
+/** Options for click actions. */
+interface ClickOptions {
+    /** Double-click instead of single click */
+    doubleClick?: boolean;
+    /** Mouse button to use */
+    button?: 'left' | 'right' | 'middle';
+    /** Modifier keys to hold during click */
+    modifiers?: ('Alt' | 'Control' | 'Meta' | 'Shift')[];
+    /** Timeout in milliseconds. Default: `8000` */
+    timeoutMs?: number;
+}
+/** Options for type actions. */
+interface TypeOptions {
+    /** Press Enter after typing */
+    submit?: boolean;
+    /** Type character-by-character with delay (75ms per key) instead of instant fill */
+    slowly?: boolean;
+    /** Timeout in milliseconds. Default: `8000` */
+    timeoutMs?: number;
+}
+/**
+ * Options for waiting on various conditions.
+ * Multiple conditions can be combined — they are checked in order.
+ */
+interface WaitOptions {
+    /** Wait for a fixed duration (milliseconds) */
+    timeMs?: number;
+    /** Wait until text appears on the page */
+    text?: string;
+    /** Wait until text disappears from the page */
+    textGone?: string;
+    /** Wait until a CSS selector matches a visible element */
+    selector?: string;
+    /** Wait until the URL matches a pattern (supports `**` wildcards) */
+    url?: string;
+    /** Wait for a specific page load state */
+    loadState?: 'load' | 'domcontentloaded' | 'networkidle';
+    /** Wait until a JavaScript function returns truthy (evaluated in browser context) */
+    fn?: string;
+    /** Timeout for each condition in milliseconds. Default: `20000` */
+    timeoutMs?: number;
+}
+/** Options for screenshot capture. */
+interface ScreenshotOptions {
+    /** Capture the full scrollable page instead of just the viewport */
+    fullPage?: boolean;
+    /** Capture a specific element by ref ID */
+    ref?: string;
+    /** Capture a specific element by CSS selector */
+    element?: string;
+    /** Image format. Default: `'png'` */
+    type?: 'png' | 'jpeg';
+}
+/** A console message captured from the browser page. */
+interface ConsoleMessage {
+    /** Message type: `'log'`, `'info'`, `'warning'`, `'error'`, `'debug'` */
+    type: string;
+    /** The message text */
+    text: string;
+    /** ISO 8601 timestamp */
+    timestamp: string;
+    /** Source location where the message was logged */
+    location?: {
+        url?: string;
+        lineNumber?: number;
+        columnNumber?: number;
+    };
+}
+/** An uncaught error from the browser page. */
+interface PageError {
+    /** Error message */
+    message: string;
+    /** Error name (e.g. `'TypeError'`) */
+    name?: string;
+    /** Stack trace */
+    stack?: string;
+    /** ISO 8601 timestamp */
+    timestamp: string;
+}
+/** A network request captured from the browser page. */
+interface NetworkRequest {
+    /** Internal request ID (e.g. `'r1'`, `'r2'`) */
+    id: string;
+    /** ISO 8601 timestamp */
+    timestamp: string;
+    /** HTTP method (e.g. `'GET'`, `'POST'`) */
+    method: string;
+    /** Request URL */
+    url: string;
+    /** Resource type (e.g. `'document'`, `'xhr'`, `'fetch'`, `'image'`) */
+    resourceType: string;
+    /** HTTP status code (set when response is received) */
+    status?: number;
+    /** Whether the response status was 2xx */
+    ok?: boolean;
+    /** Error text if the request failed */
+    failureText?: string;
+}
+/** Web storage type. */
+type StorageKind = 'local' | 'session';
+/** Cookie data for setting a browser cookie. */
+interface CookieData {
+    /** Cookie name */
+    name: string;
+    /** Cookie value */
+    value: string;
+    /** URL to associate the cookie with (alternative to domain+path) */
+    url?: string;
+    /** Cookie domain */
+    domain?: string;
+    /** Cookie path */
+    path?: string;
+    /** Expiration as Unix timestamp in seconds */
+    expires?: number;
+    /** HTTP-only flag */
+    httpOnly?: boolean;
+    /** Secure flag */
+    secure?: boolean;
+    /** SameSite attribute */
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+/** Information about an open browser tab. */
+interface BrowserTab {
+    /** CDP target ID (used to identify this tab in API calls) */
+    targetId: string;
+    /** Page title */
+    title: string;
+    /** Current URL */
+    url: string;
+    /** Target type (usually `'page'`) */
+    type: string;
+}
+
+/**
+ * Represents a single browser page/tab with ref-based automation.
+ *
+ * The workflow is: **snapshot → read refs → act on refs**.
+ *
+ * @example
+ * ```ts
+ * const page = await browser.open('https://example.com');
+ *
+ * // 1. Take a snapshot to get refs
+ * const { snapshot, refs } = await page.snapshot();
+ * // snapshot: AI-readable text tree
+ * // refs: { "e1": { role: "link", name: "More info" }, ... }
+ *
+ * // 2. Act on refs
+ * await page.click('e1');
+ * await page.type('e3', 'hello');
+ * ```
+ */
+declare class CrawlPage {
+    private readonly cdpUrl;
+    private readonly targetId;
+    /** @internal */
+    constructor(cdpUrl: string, targetId: string);
+    /** The CDP target ID for this page. Use this to identify the page in multi-tab scenarios. */
+    get id(): string;
+    /**
+     * Take an AI-readable snapshot of the page.
+     *
+     * Returns a text tree with numbered refs (`e1`, `e2`, ...) that map to
+     * interactive elements. Use these refs with actions like `click()` and `type()`.
+     *
+     * @param opts - Snapshot options (mode, filtering, depth limits)
+     * @returns Snapshot text, ref map, and statistics
+     *
+     * @example
+     * ```ts
+     * // Default snapshot (aria mode)
+     * const { snapshot, refs } = await page.snapshot();
+     *
+     * // Interactive elements only, compact
+     * const result = await page.snapshot({ interactive: true, compact: true });
+     *
+     * // Role-based mode (uses getByRole resolution)
+     * const result = await page.snapshot({ mode: 'role' });
+     * ```
+     */
+    snapshot(opts?: SnapshotOptions): Promise<SnapshotResult>;
+    /**
+     * Take a raw ARIA accessibility tree snapshot via CDP.
+     *
+     * Unlike `snapshot()`, this returns structured node data rather than
+     * an AI-readable text tree. Useful for programmatic accessibility analysis.
+     *
+     * @param opts - Options (limit: max nodes to return, default 500)
+     * @returns Array of accessibility tree nodes
+     */
+    ariaSnapshot(opts?: {
+        limit?: number;
+    }): Promise<AriaSnapshotResult>;
+    /**
+     * Click an element by ref.
+     *
+     * @param ref - Ref ID from a snapshot (e.g. `'e1'`)
+     * @param opts - Click options (double-click, button, modifiers)
+     *
+     * @example
+     * ```ts
+     * await page.click('e1');
+     * await page.click('e2', { doubleClick: true });
+     * await page.click('e3', { button: 'right' });
+     * await page.click('e4', { modifiers: ['Control'] });
+     * ```
+     */
+    click(ref: string, opts?: ClickOptions): Promise<void>;
+    /**
+     * Type text into an input element by ref.
+     *
+     * By default, uses Playwright's `fill()` for instant input. Use `slowly: true`
+     * to simulate real keystroke typing with a 75ms delay per character.
+     *
+     * @param ref - Ref ID of the input element (e.g. `'e3'`)
+     * @param text - Text to type
+     * @param opts - Type options (submit, slowly)
+     *
+     * @example
+     * ```ts
+     * await page.type('e3', 'hello world');
+     * await page.type('e3', 'slow typing', { slowly: true });
+     * await page.type('e3', 'search query', { submit: true }); // press Enter after
+     * ```
+     */
+    type(ref: string, text: string, opts?: TypeOptions): Promise<void>;
+    /**
+     * Hover over an element by ref.
+     *
+     * @param ref - Ref ID from a snapshot
+     * @param opts - Timeout options
+     */
+    hover(ref: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    /**
+     * Select option(s) in a `<select>` dropdown by ref.
+     *
+     * @param ref - Ref ID of the select element
+     * @param values - One or more option labels/values to select
+     *
+     * @example
+     * ```ts
+     * await page.select('e5', 'Option A');
+     * await page.select('e5', 'Option A', 'Option B'); // multi-select
+     * ```
+     */
+    select(ref: string, ...values: string[]): Promise<void>;
+    /**
+     * Drag one element to another.
+     *
+     * @param startRef - Ref ID of the element to drag
+     * @param endRef - Ref ID of the drop target
+     * @param opts - Timeout options
+     */
+    drag(startRef: string, endRef: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    /**
+     * Fill multiple form fields at once.
+     *
+     * Supports text inputs, checkboxes, and radio buttons.
+     *
+     * @param fields - Array of form fields to fill
+     *
+     * @example
+     * ```ts
+     * await page.fill([
+     *   { ref: 'e2', type: 'text', value: 'Jane Doe' },
+     *   { ref: 'e4', type: 'text', value: 'jane@example.com' },
+     *   { ref: 'e6', type: 'checkbox', value: true },
+     * ]);
+     * ```
+     */
+    fill(fields: FormField[]): Promise<void>;
+    /**
+     * Scroll an element into the visible viewport.
+     *
+     * @param ref - Ref ID of the element to scroll to
+     * @param opts - Timeout options
+     */
+    scrollIntoView(ref: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    /**
+     * Press a keyboard key or key combination.
+     *
+     * Uses Playwright's key names. Supports combinations with `+`.
+     *
+     * @param key - Key to press (e.g. `'Enter'`, `'Tab'`, `'Control+a'`, `'Meta+c'`)
+     * @param opts - Options (delayMs: hold time between keydown and keyup)
+     *
+     * @example
+     * ```ts
+     * await page.press('Enter');
+     * await page.press('Control+a');
+     * await page.press('Meta+Shift+p');
+     * ```
+     */
+    press(key: string, opts?: {
+        delayMs?: number;
+    }): Promise<void>;
+    /**
+     * Navigate to a URL.
+     *
+     * @param url - The URL to navigate to
+     * @param opts - Timeout options
+     * @returns The final URL after navigation (may differ due to redirects)
+     */
+    goto(url: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<{
+        url: string;
+    }>;
+    /**
+     * Wait for various conditions on the page.
+     *
+     * Multiple conditions can be specified — they are checked in order.
+     *
+     * @param opts - Wait conditions (text, URL, load state, selector, etc.)
+     *
+     * @example
+     * ```ts
+     * await page.waitFor({ loadState: 'networkidle' });
+     * await page.waitFor({ text: 'Welcome back' });
+     * await page.waitFor({ url: '**\/dashboard' });
+     * await page.waitFor({ timeMs: 1000 }); // sleep
+     * ```
+     */
+    waitFor(opts: WaitOptions): Promise<void>;
+    /**
+     * Run JavaScript in the browser page context.
+     *
+     * The function string is evaluated in the browser's sandbox, not in Node.js.
+     * Pass a `ref` to receive the element as the first argument.
+     *
+     * @param fn - JavaScript function body as a string
+     * @param opts - Options (ref: scope evaluation to a specific element)
+     * @returns The return value of the evaluated function
+     *
+     * @example
+     * ```ts
+     * const title = await page.evaluate('() => document.title');
+     * const text = await page.evaluate('(el) => el.textContent', { ref: 'e1' });
+     * const count = await page.evaluate('() => document.querySelectorAll("img").length');
+     * ```
+     */
+    evaluate(fn: string, opts?: {
+        ref?: string;
+    }): Promise<unknown>;
+    /**
+     * Run JavaScript in ALL frames on the page (including cross-origin iframes).
+     *
+     * Playwright can access cross-origin frames via CDP, bypassing the same-origin policy.
+     * This is essential for filling payment iframes (Stripe, etc.).
+     *
+     * @param fn - JavaScript function body as a string
+     * @returns Array of results from each frame where evaluation succeeded
+     *
+     * @example
+     * ```ts
+     * const results = await page.evaluateInAllFrames(`() => {
+     *   const el = document.querySelector('input[name="cardnumber"]');
+     *   return el ? 'found' : null;
+     * }`);
+     * ```
+     */
+    evaluateInAllFrames(fn: string): Promise<FrameEvalResult[]>;
+    /**
+     * Take a screenshot of the page or a specific element.
+     *
+     * @param opts - Screenshot options (fullPage, ref, element, type)
+     * @returns PNG or JPEG image as a Buffer
+     *
+     * @example
+     * ```ts
+     * const screenshot = await page.screenshot();
+     * const fullPage = await page.screenshot({ fullPage: true });
+     * const element = await page.screenshot({ ref: 'e1' });
+     * ```
+     */
+    screenshot(opts?: ScreenshotOptions): Promise<Buffer>;
+    /**
+     * Export the page as a PDF.
+     *
+     * Only works in headless mode.
+     *
+     * @returns PDF document as a Buffer
+     */
+    pdf(): Promise<Buffer>;
+    /**
+     * Get console messages captured from the page.
+     *
+     * Messages are buffered automatically. Use `level` to filter by minimum severity.
+     *
+     * @param opts - Filter options (level: `'debug'` | `'log'` | `'info'` | `'warning'` | `'error'`)
+     * @returns Array of captured console messages
+     */
+    consoleLogs(opts?: {
+        level?: string;
+    }): Promise<ConsoleMessage[]>;
+    /**
+     * Get uncaught errors from the page.
+     *
+     * @param opts - Options (clear: reset the error buffer after reading)
+     * @returns Array of captured page errors
+     */
+    pageErrors(opts?: {
+        clear?: boolean;
+    }): Promise<PageError[]>;
+    /**
+     * Get network requests captured from the page.
+     *
+     * @param opts - Options (filter: URL substring match, clear: reset the buffer)
+     * @returns Array of captured network requests
+     *
+     * @example
+     * ```ts
+     * const all = await page.networkRequests();
+     * const apiCalls = await page.networkRequests({ filter: '/api/' });
+     * const fresh = await page.networkRequests({ clear: true }); // read and clear
+     * ```
+     */
+    networkRequests(opts?: {
+        filter?: string;
+        clear?: boolean;
+    }): Promise<NetworkRequest[]>;
+    /**
+     * Resize the browser viewport.
+     *
+     * @param width - Viewport width in pixels
+     * @param height - Viewport height in pixels
+     */
+    resize(width: number, height: number): Promise<void>;
+    /**
+     * Get all cookies for the current browser context.
+     *
+     * @returns Array of cookie objects
+     */
+    cookies(): Promise<any[]>;
+    /**
+     * Set a cookie in the browser context.
+     *
+     * @param cookie - Cookie data (must include `name`, `value`, and either `url` or `domain`+`path`)
+     *
+     * @example
+     * ```ts
+     * await page.setCookie({
+     *   name: 'token',
+     *   value: 'abc123',
+     *   url: 'https://example.com',
+     * });
+     * ```
+     */
+    setCookie(cookie: CookieData): Promise<void>;
+    /** Clear all cookies in the browser context. */
+    clearCookies(): Promise<void>;
+    /**
+     * Get values from localStorage or sessionStorage.
+     *
+     * @param kind - `'local'` for localStorage, `'session'` for sessionStorage
+     * @param key - Optional specific key to retrieve (returns all if omitted)
+     * @returns Key-value map of storage entries
+     */
+    storageGet(kind: StorageKind, key?: string): Promise<Record<string, string>>;
+    /**
+     * Set a value in localStorage or sessionStorage.
+     *
+     * @param kind - `'local'` for localStorage, `'session'` for sessionStorage
+     * @param key - Storage key
+     * @param value - Storage value
+     */
+    storageSet(kind: StorageKind, key: string, value: string): Promise<void>;
+    /**
+     * Clear all entries in localStorage or sessionStorage.
+     *
+     * @param kind - `'local'` for localStorage, `'session'` for sessionStorage
+     */
+    storageClear(kind: StorageKind): Promise<void>;
+}
+/**
+ * Main entry point for browserclaw.
+ *
+ * Launch or connect to a browser, then open pages and automate them
+ * using the snapshot + ref pattern.
+ *
+ * @example
+ * ```ts
+ * import { BrowserClaw } from 'browserclaw';
+ *
+ * const browser = await BrowserClaw.launch({ headless: false });
+ * const page = await browser.open('https://example.com');
+ *
+ * const { snapshot, refs } = await page.snapshot();
+ * console.log(snapshot); // AI-readable page tree
+ * console.log(refs);     // { "e1": { role: "link", name: "More info" }, ... }
+ *
+ * await page.click('e1');
+ * await browser.stop();
+ * ```
+ */
+declare class BrowserClaw {
+    private readonly cdpUrl;
+    private chrome;
+    private constructor();
+    /**
+     * Launch a new Chrome instance and connect to it.
+     *
+     * Automatically detects Chrome, Brave, Edge, or Chromium on the system.
+     * Creates a dedicated browser profile to avoid conflicts with your daily browser.
+     *
+     * @param opts - Launch options (headless, executablePath, cdpPort, etc.)
+     * @returns A connected BrowserClaw instance
+     *
+     * @example
+     * ```ts
+     * // Default: visible Chrome window
+     * const browser = await BrowserClaw.launch();
+     *
+     * // Headless mode
+     * const browser = await BrowserClaw.launch({ headless: true });
+     *
+     * // Specific browser
+     * const browser = await BrowserClaw.launch({
+     *   executablePath: '/usr/bin/google-chrome',
+     * });
+     * ```
+     */
+    static launch(opts?: LaunchOptions): Promise<BrowserClaw>;
+    /**
+     * Connect to an already-running Chrome instance via its CDP endpoint.
+     *
+     * The Chrome instance must have been started with `--remote-debugging-port`.
+     *
+     * @param cdpUrl - CDP endpoint URL (e.g. `'http://localhost:9222'`)
+     * @returns A connected BrowserClaw instance
+     *
+     * @example
+     * ```ts
+     * // Chrome started with: chrome --remote-debugging-port=9222
+     * const browser = await BrowserClaw.connect('http://localhost:9222');
+     * ```
+     */
+    static connect(cdpUrl: string): Promise<BrowserClaw>;
+    /**
+     * Open a URL in a new tab and return the page handle.
+     *
+     * @param url - URL to navigate to
+     * @returns A CrawlPage for the new tab
+     *
+     * @example
+     * ```ts
+     * const page = await browser.open('https://example.com');
+     * const { snapshot, refs } = await page.snapshot();
+     * ```
+     */
+    open(url: string): Promise<CrawlPage>;
+    /**
+     * Get a CrawlPage handle for the currently active tab.
+     *
+     * @returns CrawlPage for the first/active page
+     */
+    currentPage(): Promise<CrawlPage>;
+    /**
+     * List all open tabs.
+     *
+     * @returns Array of tab information objects
+     */
+    tabs(): Promise<BrowserTab[]>;
+    /**
+     * Bring a tab to the foreground.
+     *
+     * @param targetId - CDP target ID of the tab (from `tabs()` or `page.id`)
+     */
+    focus(targetId: string): Promise<void>;
+    /**
+     * Close a tab.
+     *
+     * @param targetId - CDP target ID of the tab to close
+     */
+    close(targetId: string): Promise<void>;
+    /**
+     * Get a CrawlPage handle for a specific tab by its target ID.
+     *
+     * Unlike `open()`, this doesn't create a new tab — it wraps an existing one.
+     *
+     * @param targetId - CDP target ID of the tab
+     * @returns CrawlPage for the specified tab
+     */
+    page(targetId: string): CrawlPage;
+    /** The CDP endpoint URL for this browser connection. */
+    get url(): string;
+    /**
+     * Stop the browser and clean up all resources.
+     *
+     * If the browser was launched by `BrowserClaw.launch()`, the Chrome process
+     * will be terminated. If connected via `BrowserClaw.connect()`, only the
+     * Playwright connection is closed.
+     */
+    stop(): Promise<void>;
+}
+
+export { type AriaNode, type AriaSnapshotResult, BrowserClaw, type BrowserTab, type ChromeExecutable, type ChromeKind, type ClickOptions, type ConnectOptions, type ConsoleMessage, type CookieData, CrawlPage, type FormField, type FrameEvalResult, type LaunchOptions, type NetworkRequest, type PageError, type RoleRefInfo, type RoleRefs, type ScreenshotOptions, type SnapshotOptions, type SnapshotResult, type SnapshotStats, type StorageKind, type TypeOptions, type WaitOptions };