browser-pilot 0.0.1

package/dist/types-Cs89wle0.d.cts

@@ -0,0 +1,925 @@
+import { C as CDPClient } from './client-7Nqka5MV.cjs';
+
+/**
+ * Wait strategy implementations
+ */
+
+type WaitState = 'visible' | 'hidden' | 'attached' | 'detached';
+interface WaitOptions {
+    /** State to wait for */
+    state?: WaitState;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Polling interval in milliseconds */
+    pollInterval?: number;
+    /** Execution context ID for iframe evaluation */
+    contextId?: number;
+}
+interface WaitResult {
+    success: boolean;
+    waitedMs: number;
+}
+/**
+ * Wait for an element to reach a specific state
+ */
+declare function waitForElement(cdp: CDPClient, selector: string, options?: WaitOptions): Promise<WaitResult>;
+/**
+ * Wait for any of the given selectors to match
+ * Returns the selector that matched first
+ */
+declare function waitForAnyElement(cdp: CDPClient, selectors: string[], options?: WaitOptions): Promise<{
+    success: boolean;
+    selector?: string;
+    waitedMs: number;
+}>;
+interface NavigationOptions {
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Include same-document navigation (pushState, anchors) */
+    allowSameDocument?: boolean;
+}
+/**
+ * Wait for navigation to complete using multi-signal detection
+ * Listens for:
+ * - Page.loadEventFired: Full page load
+ * - Page.frameNavigated: Frame navigation (includes history.back/forward)
+ * - Page.navigatedWithinDocument: Same-document navigation (pushState, anchors)
+ * Also polls for URL changes as a fallback
+ */
+declare function waitForNavigation(cdp: CDPClient, options?: NavigationOptions): Promise<WaitResult>;
+/**
+ * Wait for network to be idle (no requests in flight for a given duration)
+ */
+declare function waitForNetworkIdle(cdp: CDPClient, options?: {
+    timeout?: number;
+    idleTime?: number;
+}): Promise<WaitResult>;
+
+/**
+ * Browser and Page type definitions
+ */
+
+interface ActionOptions {
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Don't throw on failure, return false instead */
+    optional?: boolean;
+}
+interface FillOptions extends ActionOptions {
+    /** Clear existing content before filling */
+    clear?: boolean;
+}
+interface TypeOptions extends ActionOptions {
+    /** Delay between keystrokes in ms */
+    delay?: number;
+}
+interface SubmitOptions extends ActionOptions {
+    /** How to submit: 'enter' | 'click' | 'enter+click' */
+    method?: 'enter' | 'click' | 'enter+click';
+    /**
+     * Wait for navigation after submit:
+     * - 'auto' (default): Race navigation detection vs short delay for client-side forms
+     * - true: Always wait for full navigation
+     * - false: Return immediately without waiting
+     */
+    waitForNavigation?: boolean | 'auto';
+}
+interface WaitForOptions extends ActionOptions {
+    /** State to wait for */
+    state?: WaitState;
+    /** Polling interval in ms */
+    pollInterval?: number;
+}
+interface NetworkIdleOptions extends ActionOptions {
+    /** Time with no requests before considered idle */
+    idleTime?: number;
+}
+interface CustomSelectConfig {
+    /** Selector for the dropdown trigger */
+    trigger: string | string[];
+    /** Selector pattern for options */
+    option: string | string[];
+    /** Value to select */
+    value: string;
+    /** How to match the value */
+    match?: 'text' | 'value' | 'contains';
+}
+interface FileInput {
+    /** File name */
+    name: string;
+    /** MIME type */
+    mimeType: string;
+    /** File content as base64 or ArrayBuffer */
+    buffer: ArrayBuffer | string;
+}
+interface Download {
+    /** Downloaded file name */
+    filename: string;
+    /** Path to downloaded file (if available) */
+    path?: string;
+    /** Get file content as ArrayBuffer */
+    content(): Promise<ArrayBuffer>;
+}
+interface ElementInfo {
+    /** Node ID in the DOM */
+    nodeId: number;
+    /** Backend node ID */
+    backendNodeId: number;
+    /** Selector that matched */
+    selector: string;
+    /** Time spent waiting for element */
+    waitedMs: number;
+}
+interface ActionResult {
+    /** Whether the action succeeded */
+    success: boolean;
+    /** Time taken in ms */
+    durationMs: number;
+    /** Selector used (if multiple provided) */
+    selectorUsed?: string;
+    /** Selectors that failed (if multiple provided) */
+    failedSelectors?: Array<{
+        selector: string;
+        reason: string;
+    }>;
+}
+interface PageSnapshot {
+    /** Current URL */
+    url: string;
+    /** Page title */
+    title: string;
+    /** Snapshot timestamp */
+    timestamp: string;
+    /** Accessibility tree nodes */
+    accessibilityTree: SnapshotNode[];
+    /** Interactive elements for quick reference */
+    interactiveElements: InteractiveElement[];
+    /** Text representation of the page */
+    text: string;
+}
+interface SnapshotNode {
+    /** Accessibility role */
+    role: string;
+    /** Accessible name */
+    name?: string;
+    /** Current value */
+    value?: string;
+    /** Element reference (e.g., "e1", "e2") */
+    ref: string;
+    /** Child nodes */
+    children?: SnapshotNode[];
+    /** Whether the element is disabled */
+    disabled?: boolean;
+    /** Whether the element is checked (for checkboxes) */
+    checked?: boolean;
+    /** Additional properties */
+    properties?: Record<string, unknown>;
+}
+interface InteractiveElement {
+    /** Element reference */
+    ref: string;
+    /** Accessibility role */
+    role: string;
+    /** Accessible name */
+    name: string;
+    /** CSS selector to target this element */
+    selector: string;
+    /** Whether the element is disabled */
+    disabled?: boolean;
+}
+declare class ElementNotFoundError extends Error {
+    selectors: string[];
+    constructor(selectors: string | string[]);
+}
+declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
+declare class NavigationError extends Error {
+    constructor(message: string);
+}
+interface ViewportOptions {
+    /** Viewport width in pixels */
+    width: number;
+    /** Viewport height in pixels */
+    height: number;
+    /** Device scale factor (default: 1) */
+    deviceScaleFactor?: number;
+    /** Whether to emulate mobile (default: false) */
+    isMobile?: boolean;
+    /** Whether the meta viewport tag should be accounted for (default: false) */
+    hasTouch?: boolean;
+    /** Whether to emulate landscape orientation (default: false) */
+    isLandscape?: boolean;
+}
+interface GeolocationOptions {
+    /** Latitude in degrees */
+    latitude: number;
+    /** Longitude in degrees */
+    longitude: number;
+    /** Accuracy in meters (default: 1) */
+    accuracy?: number;
+}
+interface UserAgentOptions {
+    /** User agent string */
+    userAgent: string;
+    /** Accept-Language header value */
+    acceptLanguage?: string;
+    /** Platform override (e.g., "Win32", "MacIntel") */
+    platform?: string;
+    /** User agent metadata for Client Hints */
+    userAgentMetadata?: UserAgentMetadata;
+}
+interface UserAgentMetadata {
+    brands?: Array<{
+        brand: string;
+        version: string;
+    }>;
+    fullVersionList?: Array<{
+        brand: string;
+        version: string;
+    }>;
+    fullVersion?: string;
+    platform?: string;
+    platformVersion?: string;
+    architecture?: string;
+    model?: string;
+    mobile?: boolean;
+    bitness?: string;
+    wow64?: boolean;
+}
+interface EmulationState {
+    viewport?: ViewportOptions;
+    userAgent?: UserAgentOptions;
+    geolocation?: GeolocationOptions;
+    timezone?: string;
+    locale?: string;
+}
+type ConsoleMessageType = 'log' | 'debug' | 'info' | 'error' | 'warning' | 'dir' | 'dirxml' | 'table' | 'trace' | 'clear' | 'startGroup' | 'startGroupCollapsed' | 'endGroup' | 'assert' | 'profile' | 'profileEnd' | 'count' | 'timeEnd';
+interface ConsoleMessage {
+    /** Message type */
+    type: ConsoleMessageType;
+    /** Message text */
+    text: string;
+    /** Arguments passed to console method */
+    args: unknown[];
+    /** Source URL */
+    url?: string;
+    /** Line number */
+    lineNumber?: number;
+    /** Column number */
+    columnNumber?: number;
+    /** Stack trace if available */
+    stackTrace?: string[];
+    /** Timestamp */
+    timestamp: number;
+}
+interface PageError {
+    /** Error message */
+    message: string;
+    /** Source URL */
+    url?: string;
+    /** Line number */
+    lineNumber?: number;
+    /** Column number */
+    columnNumber?: number;
+    /** Stack trace */
+    stackTrace?: string[];
+    /** Timestamp */
+    timestamp: number;
+}
+type DialogType = 'alert' | 'confirm' | 'prompt' | 'beforeunload';
+interface Dialog {
+    /** Dialog type */
+    type: DialogType;
+    /** Dialog message */
+    message: string;
+    /** Default value for prompt dialogs */
+    defaultValue?: string;
+    /** Accept the dialog (click OK) */
+    accept(promptText?: string): Promise<void>;
+    /** Dismiss the dialog (click Cancel) */
+    dismiss(): Promise<void>;
+}
+type ConsoleHandler = (message: ConsoleMessage) => void;
+type ErrorHandler = (error: PageError) => void;
+type DialogHandler = (dialog: Dialog) => void | Promise<void>;
+
+/**
+ * Device presets for common emulation scenarios
+ */
+
+interface DeviceDescriptor {
+    name: string;
+    viewport: ViewportOptions;
+    userAgent: UserAgentOptions;
+}
+declare const devices: Record<string, DeviceDescriptor>;
+type DeviceName = keyof typeof devices;
+
+/**
+ * Network interception types
+ */
+type ResourceType = 'Document' | 'Stylesheet' | 'Image' | 'Media' | 'Font' | 'Script' | 'TextTrack' | 'XHR' | 'Fetch' | 'Prefetch' | 'EventSource' | 'WebSocket' | 'Manifest' | 'SignedExchange' | 'Ping' | 'CSPViolationReport' | 'Preflight' | 'Other';
+interface RequestPattern {
+    /** URL pattern (glob or regex string) */
+    urlPattern?: string;
+    /** Resource type to match */
+    resourceType?: ResourceType;
+    /** Request stage to intercept */
+    requestStage?: 'Request' | 'Response';
+}
+interface InterceptedRequest {
+    /** Unique request ID */
+    requestId: string;
+    /** Request URL */
+    url: string;
+    /** HTTP method */
+    method: string;
+    /** Request headers */
+    headers: Record<string, string>;
+    /** POST data if present */
+    postData?: string;
+    /** Resource type */
+    resourceType: ResourceType;
+    /** Frame ID that initiated the request */
+    frameId: string;
+    /** Whether this is a navigation request */
+    isNavigationRequest: boolean;
+    /** Response status (only if intercepting response) */
+    responseStatusCode?: number;
+    /** Response headers (only if intercepting response) */
+    responseHeaders?: Record<string, string>;
+}
+interface ContinueRequestOptions {
+    /** Override URL */
+    url?: string;
+    /** Override method */
+    method?: string;
+    /** Override headers */
+    headers?: Record<string, string>;
+    /** Override POST data */
+    postData?: string;
+}
+interface FulfillRequestOptions {
+    /** Response status code */
+    status: number;
+    /** Response headers */
+    headers?: Record<string, string>;
+    /** Response body (string or base64 for binary) */
+    body?: string;
+    /** Whether body is base64 encoded */
+    isBase64Encoded?: boolean;
+}
+interface FailRequestOptions {
+    /** Error reason */
+    reason: 'Failed' | 'Aborted' | 'TimedOut' | 'AccessDenied' | 'ConnectionClosed' | 'ConnectionReset' | 'ConnectionRefused' | 'ConnectionAborted' | 'ConnectionFailed' | 'NameNotResolved' | 'InternetDisconnected' | 'AddressUnreachable' | 'BlockedByClient' | 'BlockedByResponse';
+}
+type RequestHandler = (request: InterceptedRequest, actions: RequestActions) => void | Promise<void>;
+interface RequestActions {
+    /** Continue request, optionally modifying it */
+    continue(options?: ContinueRequestOptions): Promise<void>;
+    /** Fulfill request with custom response */
+    fulfill(options: FulfillRequestOptions): Promise<void>;
+    /** Fail/abort the request */
+    fail(options?: FailRequestOptions): Promise<void>;
+}
+interface RouteOptions {
+    /** Response status code */
+    status?: number;
+    /** Response headers */
+    headers?: Record<string, string>;
+    /** Response body */
+    body?: string | object;
+    /** Content type (auto-sets header) */
+    contentType?: string;
+}
+
+/**
+ * Cookie and storage types
+ */
+interface Cookie {
+    /** Cookie name */
+    name: string;
+    /** Cookie value */
+    value: string;
+    /** Cookie domain */
+    domain: string;
+    /** Cookie path */
+    path: string;
+    /** Expiration timestamp (Unix epoch in seconds) */
+    expires: number;
+    /** Size in bytes */
+    size: number;
+    /** HTTP only flag */
+    httpOnly: boolean;
+    /** Secure flag */
+    secure: boolean;
+    /** Session cookie flag */
+    session: boolean;
+    /** SameSite attribute */
+    sameSite: 'Strict' | 'Lax' | 'None';
+    /** Priority */
+    priority: 'Low' | 'Medium' | 'High';
+    /** Source scheme */
+    sourceScheme: 'Unset' | 'NonSecure' | 'Secure';
+}
+interface SetCookieOptions {
+    /** Cookie name */
+    name: string;
+    /** Cookie value */
+    value: string;
+    /** Cookie domain (optional, defaults to current page domain) */
+    domain?: string;
+    /** Cookie path (default: "/") */
+    path?: string;
+    /** Expiration timestamp or Date */
+    expires?: number | Date;
+    /** HTTP only flag */
+    httpOnly?: boolean;
+    /** Secure flag */
+    secure?: boolean;
+    /** SameSite attribute */
+    sameSite?: 'Strict' | 'Lax' | 'None';
+    /** URL to associate cookie with (alternative to domain+path) */
+    url?: string;
+}
+interface DeleteCookieOptions {
+    /** Cookie name */
+    name: string;
+    /** Cookie domain */
+    domain?: string;
+    /** Cookie path */
+    path?: string;
+    /** URL to scope cookie deletion */
+    url?: string;
+}
+interface ClearCookiesOptions {
+    /** Clear only for specific domain */
+    domain?: string;
+}
+
+/**
+ * Page class - provides high-level browser automation API
+ */
+
+declare class Page {
+    private cdp;
+    private rootNodeId;
+    private batchExecutor;
+    private emulationState;
+    private interceptor;
+    private consoleHandlers;
+    private errorHandlers;
+    private dialogHandler;
+    private consoleEnabled;
+    /** Map of ref (e.g., "e4") to backendNodeId for ref-based selectors */
+    private refMap;
+    /** Current frame context (null = main frame) */
+    private currentFrame;
+    /** Stored frame document node IDs for context switching */
+    private frameContexts;
+    /** Map of frameId → executionContextId for JS evaluation in frames */
+    private frameExecutionContexts;
+    /** Current frame's execution context ID (null = main frame default) */
+    private currentFrameContextId;
+    constructor(cdp: CDPClient);
+    /**
+     * Initialize the page (enable required CDP domains)
+     */
+    init(): Promise<void>;
+    /**
+     * Navigate to a URL
+     */
+    goto(url: string, options?: ActionOptions): Promise<void>;
+    /**
+     * Get the current URL
+     */
+    url(): Promise<string>;
+    /**
+     * Get the page title
+     */
+    title(): Promise<string>;
+    /**
+     * Reload the page
+     */
+    reload(options?: ActionOptions): Promise<void>;
+    /**
+     * Go back in history
+     */
+    goBack(options?: ActionOptions): Promise<void>;
+    /**
+     * Go forward in history
+     */
+    goForward(options?: ActionOptions): Promise<void>;
+    /**
+     * Click an element (supports multi-selector)
+     *
+     * Uses CDP mouse events for regular elements. For form submit buttons,
+     * uses dispatchEvent to reliably trigger form submission in headless Chrome.
+     */
+    click(selector: string | string[], options?: ActionOptions): Promise<boolean>;
+    /**
+     * Fill an input field (clears first by default)
+     */
+    fill(selector: string | string[], value: string, options?: FillOptions): Promise<boolean>;
+    /**
+     * Type text character by character (for autocomplete fields, etc.)
+     */
+    type(selector: string | string[], text: string, options?: TypeOptions): Promise<boolean>;
+    /**
+     * Select option(s) from a native select element
+     */
+    select(selector: string | string[], value: string | string[], options?: ActionOptions): Promise<boolean>;
+    select(config: CustomSelectConfig, options?: ActionOptions): Promise<boolean>;
+    /**
+     * Handle custom (non-native) select/dropdown components
+     */
+    private selectCustom;
+    /**
+     * Check a checkbox or radio button
+     */
+    check(selector: string | string[], options?: ActionOptions): Promise<boolean>;
+    /**
+     * Uncheck a checkbox
+     */
+    uncheck(selector: string | string[], options?: ActionOptions): Promise<boolean>;
+    /**
+     * Submit a form (tries Enter key first, then click)
+     *
+     * Navigation waiting behavior:
+     * - 'auto' (default): Attempt to detect navigation for 1 second, then assume client-side handling
+     * - true: Wait for full navigation (traditional forms)
+     * - false: Return immediately (AJAX forms where you'll wait for something else)
+     */
+    submit(selector: string | string[], options?: SubmitOptions): Promise<boolean>;
+    /**
+     * Press a key
+     */
+    press(key: string): Promise<void>;
+    /**
+     * Focus an element
+     */
+    focus(selector: string | string[], options?: ActionOptions): Promise<boolean>;
+    /**
+     * Hover over an element
+     */
+    hover(selector: string | string[], options?: ActionOptions): Promise<boolean>;
+    /**
+     * Scroll an element into view (or scroll to coordinates)
+     */
+    scroll(selector: string | string[], options?: ActionOptions & {
+        x?: number;
+        y?: number;
+    }): Promise<boolean>;
+    /**
+     * Switch context to an iframe for subsequent actions
+     * @param selector - Selector for the iframe element
+     * @param options - Optional timeout and optional flags
+     * @returns true if switch succeeded
+     */
+    switchToFrame(selector: string | string[], options?: ActionOptions): Promise<boolean>;
+    /**
+     * Switch back to the main document from an iframe
+     */
+    switchToMain(): Promise<void>;
+    /**
+     * Get the current frame context (null = main frame)
+     */
+    getCurrentFrame(): string | null;
+    /**
+     * Wait for an element to reach a state
+     */
+    waitFor(selector: string | string[], options?: WaitForOptions): Promise<boolean>;
+    /**
+     * Wait for navigation to complete
+     */
+    waitForNavigation(options?: ActionOptions): Promise<boolean>;
+    /**
+     * Wait for network to be idle
+     */
+    waitForNetworkIdle(options?: NetworkIdleOptions): Promise<boolean>;
+    /**
+     * Evaluate JavaScript in the page context (or current frame context if in iframe)
+     */
+    evaluate<T = unknown, Args extends unknown[] = unknown[]>(expression: string | ((...args: Args) => T), ...args: Args): Promise<T>;
+    /**
+     * Take a screenshot
+     */
+    screenshot(options?: {
+        format?: 'png' | 'jpeg' | 'webp';
+        quality?: number;
+        fullPage?: boolean;
+    }): Promise<string>;
+    /**
+     * Get text content from the page or a specific element
+     */
+    text(selector?: string): Promise<string>;
+    /**
+     * Set files on a file input
+     */
+    setInputFiles(selector: string | string[], files: FileInput[], options?: ActionOptions): Promise<boolean>;
+    /**
+     * Wait for a download to complete, triggered by an action
+     */
+    waitForDownload(trigger: () => Promise<void>, options?: ActionOptions): Promise<Download>;
+    /**
+     * Get an accessibility tree snapshot of the page
+     */
+    snapshot(): Promise<PageSnapshot>;
+    /**
+     * Execute a batch of steps
+     */
+    batch(steps: Step[], options?: BatchOptions): Promise<BatchResult>;
+    /**
+     * Set the viewport size and device metrics
+     */
+    setViewport(options: ViewportOptions): Promise<void>;
+    /**
+     * Clear viewport override, return to default
+     */
+    clearViewport(): Promise<void>;
+    /**
+     * Set the user agent string and optional metadata
+     */
+    setUserAgent(options: string | UserAgentOptions): Promise<void>;
+    /**
+     * Set geolocation coordinates
+     */
+    setGeolocation(options: GeolocationOptions): Promise<void>;
+    /**
+     * Clear geolocation override
+     */
+    clearGeolocation(): Promise<void>;
+    /**
+     * Set timezone override
+     */
+    setTimezone(timezoneId: string): Promise<void>;
+    /**
+     * Set locale override
+     */
+    setLocale(locale: string): Promise<void>;
+    /**
+     * Emulate a specific device
+     */
+    emulate(device: DeviceDescriptor): Promise<void>;
+    /**
+     * Get current emulation state
+     */
+    getEmulationState(): EmulationState;
+    /**
+     * Add request interception handler
+     * @param pattern URL pattern or resource type to match
+     * @param handler Handler function for matched requests
+     * @returns Unsubscribe function
+     */
+    intercept(pattern: string | RequestPattern, handler: RequestHandler): Promise<() => void>;
+    /**
+     * Route requests matching pattern to a mock response
+     * Convenience wrapper around intercept()
+     */
+    route(urlPattern: string, options: RouteOptions): Promise<() => void>;
+    /**
+     * Block requests matching resource types
+     */
+    blockResources(types: ResourceType[]): Promise<() => void>;
+    /**
+     * Disable all request interception
+     */
+    disableInterception(): Promise<void>;
+    /**
+     * Get all cookies for the current page
+     */
+    cookies(urls?: string[]): Promise<Cookie[]>;
+    /**
+     * Set a cookie
+     */
+    setCookie(options: SetCookieOptions): Promise<boolean>;
+    /**
+     * Set multiple cookies
+     */
+    setCookies(cookies: SetCookieOptions[]): Promise<void>;
+    /**
+     * Delete a specific cookie
+     */
+    deleteCookie(options: DeleteCookieOptions): Promise<void>;
+    /**
+     * Delete multiple cookies
+     */
+    deleteCookies(cookies: DeleteCookieOptions[]): Promise<void>;
+    /**
+     * Clear all cookies
+     */
+    clearCookies(options?: ClearCookiesOptions): Promise<void>;
+    /**
+     * Get localStorage value
+     */
+    getLocalStorage(key: string): Promise<string | null>;
+    /**
+     * Set localStorage value
+     */
+    setLocalStorage(key: string, value: string): Promise<void>;
+    /**
+     * Remove localStorage item
+     */
+    removeLocalStorage(key: string): Promise<void>;
+    /**
+     * Clear localStorage
+     */
+    clearLocalStorage(): Promise<void>;
+    /**
+     * Get sessionStorage value
+     */
+    getSessionStorage(key: string): Promise<string | null>;
+    /**
+     * Set sessionStorage value
+     */
+    setSessionStorage(key: string, value: string): Promise<void>;
+    /**
+     * Remove sessionStorage item
+     */
+    removeSessionStorage(key: string): Promise<void>;
+    /**
+     * Clear sessionStorage
+     */
+    clearSessionStorage(): Promise<void>;
+    /**
+     * Enable console message capture
+     */
+    private enableConsole;
+    /**
+     * Handle console API calls
+     */
+    private handleConsoleMessage;
+    /**
+     * Handle JavaScript exceptions
+     */
+    private handleException;
+    /**
+     * Handle dialog opening
+     */
+    private handleDialogOpening;
+    /**
+     * Format console arguments to string
+     */
+    private formatConsoleArgs;
+    /**
+     * Subscribe to console messages
+     */
+    onConsole(handler: ConsoleHandler): Promise<() => void>;
+    /**
+     * Subscribe to page errors
+     */
+    onError(handler: ErrorHandler): Promise<() => void>;
+    /**
+     * Set dialog handler (only one at a time)
+     */
+    onDialog(handler: DialogHandler | null): Promise<void>;
+    /**
+     * Collect console messages during an action
+     */
+    collectConsole<T>(fn: () => Promise<T>): Promise<{
+        result: T;
+        messages: ConsoleMessage[];
+    }>;
+    /**
+     * Collect errors during an action
+     */
+    collectErrors<T>(fn: () => Promise<T>): Promise<{
+        result: T;
+        errors: PageError[];
+    }>;
+    /**
+     * Reset page state for clean test isolation
+     * - Stops any pending operations
+     * - Clears localStorage and sessionStorage
+     * - Resets internal state
+     */
+    reset(): Promise<void>;
+    /**
+     * Close this page (no-op for now, managed by Browser)
+     * This is a placeholder for API compatibility
+     */
+    close(): Promise<void>;
+    /**
+     * Retry wrapper for operations that may encounter stale nodes
+     * Catches "Could not find node with given id" errors and retries
+     */
+    private withStaleNodeRetry;
+    /**
+     * Find an element using single or multiple selectors
+     * Supports ref: prefix for ref-based selectors (e.g., "ref:e4")
+     */
+    private findElement;
+    /**
+     * Ensure we have a valid root node ID
+     */
+    private ensureRootNode;
+    /**
+     * Execute Runtime.evaluate in the current frame context
+     * Automatically injects contextId when in an iframe
+     */
+    private evaluateInFrame;
+    /**
+     * Scroll an element into view
+     */
+    private scrollIntoView;
+    /**
+     * Get element box model (position and dimensions)
+     */
+    private getBoxModel;
+    /**
+     * Click an element by node ID
+     */
+    private clickElement;
+}
+
+/**
+ * Action/Step types for batch execution
+ */
+type ActionType = 'goto' | 'click' | 'fill' | 'type' | 'select' | 'check' | 'uncheck' | 'submit' | 'press' | 'focus' | 'hover' | 'scroll' | 'wait' | 'snapshot' | 'screenshot' | 'evaluate' | 'text' | 'switchFrame' | 'switchToMain';
+interface Step {
+    /** Action type */
+    action: ActionType;
+    /** Target selector(s) - array means try each until one works */
+    selector?: string | string[];
+    /** URL for goto action */
+    url?: string;
+    /** Value for fill, type, select, evaluate actions */
+    value?: string | string[];
+    /** Key for press action */
+    key?: string;
+    /** What to wait for (wait action) */
+    waitFor?: 'visible' | 'hidden' | 'attached' | 'detached' | 'navigation' | 'networkIdle';
+    /** Step-specific timeout override (ms) */
+    timeout?: number;
+    /** Should this step's failure be ignored? */
+    optional?: boolean;
+    /** Submit method */
+    method?: 'enter' | 'click' | 'enter+click';
+    /** Clear input before filling */
+    clear?: boolean;
+    /** Delay between keystrokes for type action */
+    delay?: number;
+    /** Wait for navigation after click action completes */
+    waitForNavigation?: boolean;
+    /** Custom select: trigger selector */
+    trigger?: string | string[];
+    /** Custom select: option selector */
+    option?: string | string[];
+    /** Custom select: match type */
+    match?: 'text' | 'value' | 'contains';
+    /** Scroll coordinates */
+    x?: number;
+    y?: number;
+    /** Scroll direction for page-level scroll */
+    direction?: 'up' | 'down' | 'left' | 'right';
+    /** Scroll amount in pixels */
+    amount?: number;
+    /** Screenshot options */
+    format?: 'png' | 'jpeg' | 'webp';
+    quality?: number;
+    fullPage?: boolean;
+}
+interface BatchOptions {
+    /** Default timeout for all steps (ms) */
+    timeout?: number;
+    /** How to handle failures */
+    onFail?: 'stop' | 'continue';
+}
+interface StepResult {
+    /** Step index */
+    index: number;
+    /** Action type */
+    action: ActionType;
+    /** Target selector(s) if provided */
+    selector?: string | string[];
+    /** Which selector was actually used (if multiple provided) */
+    selectorUsed?: string;
+    /** Whether the step succeeded */
+    success: boolean;
+    /** Time taken in ms */
+    durationMs: number;
+    /** Error message if failed */
+    error?: string;
+    /** Selectors that failed before success (if multiple provided) */
+    failedSelectors?: Array<{
+        selector: string;
+        reason: string;
+    }>;
+    /** Result value (for snapshot, screenshot, evaluate) */
+    result?: unknown;
+    /** Text content (for text action) */
+    text?: string;
+}
+interface BatchResult {
+    /** Whether all steps succeeded */
+    success: boolean;
+    /** Index where execution stopped (if onFail: 'stop') */
+    stoppedAtIndex?: number;
+    /** Individual step results */
+    steps: StepResult[];
+    /** Total execution time in ms */
+    totalDurationMs: number;
+}
+
+export { type WaitResult as $, type ActionType as A, type BatchOptions as B, type ConsoleHandler as C, type Dialog as D, type ElementInfo as E, type FileInput as F, type GeolocationOptions as G, type FailRequestOptions as H, type InteractiveElement as I, type FulfillRequestOptions as J, type InterceptedRequest as K, type RequestActions as L, type ResourceType as M, NavigationError as N, type RouteOptions as O, Page as P, type ClearCookiesOptions as Q, type RequestPattern as R, type Step as S, TimeoutError as T, type UserAgentMetadata as U, type ViewportOptions as V, type WaitForOptions as W, type Cookie as X, type DeleteCookieOptions as Y, type SetCookieOptions as Z, type WaitOptions as _, type RequestHandler as a, type WaitState as a0, waitForAnyElement as a1, waitForElement as a2, waitForNavigation as a3, waitForNetworkIdle as a4, type BatchResult as b, type StepResult as c, type ActionOptions as d, type ActionResult as e, type ConsoleMessage as f, type ConsoleMessageType as g, type CustomSelectConfig as h, type DialogHandler as i, type DialogType as j, type Download as k, ElementNotFoundError as l, type EmulationState as m, type ErrorHandler as n, type FillOptions as o, type NetworkIdleOptions as p, type PageError as q, type PageSnapshot as r, type SnapshotNode as s, type SubmitOptions as t, type TypeOptions as u, type UserAgentOptions as v, type DeviceDescriptor as w, type DeviceName as x, devices as y, type ContinueRequestOptions as z };