@roxybrowser/playwright 2.0.2-beta.0

package/dist/page.d.ts

@@ -0,0 +1,907 @@
+import { RoxyElementHandle, type ElementHandleFrameResolver } from "./elementHandle.js";
+import { RoxyFrame, type RoxyFrameSnapshot } from "./frame.js";
+import { type InputFiles } from "./inputFiles.js";
+import type { RoxyBrowserContext } from "./browserContext.js";
+import type { ResolvedHumanizationOptions } from "./human/types.js";
+import type { ProtocolElementHandleAdapter, ProtocolElementHandleReference, ProtocolPageAdapter } from "./protocol/adapter.js";
+import type { PageEventListener, PageEventMap, PageEventName, PageEventPredicate, ConsoleMessage, PageConsoleMessage, PageErrorEntry } from "./types/events.js";
+import type { BindingSource, ElementArrayCallback, ElementCallback, Disposable, ElementHandle, ElementHandleForTag, FileChooser, Frame, FrameLocator, Locator, Page, Request, Response, ResolvedAriaRef, Route, BrowserContext, APIRequestContext, Clock, Coverage, Dialog, Download, EvaluationArgument, Keyboard, Mouse, PageFunction, PageFunctionOn, Screencast, SmartHandle, Touchscreen, Video, WebSocket, WebStorage, WebSocketRoute, Worker } from "./types/api.js";
+import type { AddScriptTagOptions, AddStyleTagOptions, AddLocatorHandlerOptions, BrowserContextOptions, GetByAltTextOptions, GetByLabelOptions, GetByPlaceholderOptions, GetByRoleOptions, GetByTextOptions, GetByTitleOptions, LoadState, PageGotoOptions, PageSetContentOptions, SetInputFilesOptions, ScreenshotOptions, ViewportSize, WaitForNavigationOptions, WaitForSelectorOptions } from "./types/options.js";
+type LocatorOptions = {
+    has?: Locator;
+    hasNot?: Locator;
+    hasNotText?: string | RegExp;
+    hasText?: string | RegExp;
+};
+type PageWaitForFunctionOptions = {
+    polling?: number | "raf";
+    timeout?: number;
+};
+type PlaywrightFilePayload = {
+    name: string;
+    mimeType: string;
+    buffer: Buffer;
+};
+type PlaywrightInputFiles = string | ReadonlyArray<string> | PlaywrightFilePayload | ReadonlyArray<PlaywrightFilePayload>;
+type PlaywrightSelectOptionValue = {
+    value?: string;
+    label?: string;
+    index?: number;
+};
+type PlaywrightSelectOptionValues = null | string | ElementHandle | ReadonlyArray<string> | PlaywrightSelectOptionValue | ReadonlyArray<ElementHandle> | ReadonlyArray<PlaywrightSelectOptionValue>;
+type InternalWaitForEventOptions<K extends PageEventName> = {
+    logLine?: string;
+    predicate?: PageEventPredicate<K>;
+    timeout?: number;
+};
+export declare class RoxyPage implements Page, ElementHandleFrameResolver {
+    private readonly adapter;
+    private readonly humanDefaults;
+    private readonly browserContext?;
+    private readonly contextOptions;
+    readonly clock: Clock;
+    readonly coverage: Coverage;
+    readonly keyboard: Keyboard;
+    readonly localStorage: WebStorage;
+    readonly mouse: Mouse;
+    readonly request: APIRequestContext;
+    readonly screencast: Screencast;
+    readonly sessionStorage: WebStorage;
+    readonly touchscreen: Touchscreen;
+    private readonly humanController;
+    private readonly eventObservations;
+    private readonly adapterDisposers;
+    private readonly pendingHandlers;
+    private rejectionHandler;
+    private readonly internalDisposers;
+    private readonly activeDialogs;
+    private closed;
+    private closePromise;
+    private closeReason;
+    private defaultTimeoutMs;
+    private defaultNavigationTimeoutMs;
+    private currentViewportSize;
+    private readonly consoleMessageHistory;
+    private readonly consoleMessageHistorySinceNavigation;
+    private readonly pageErrorHistory;
+    private readonly pageErrorHistorySinceNavigation;
+    private readonly requestHistory;
+    private readonly recordedRequests;
+    private readonly activeRequests;
+    private readonly observedRequestsById;
+    private readonly observedRequestsByUrl;
+    private readonly pendingRoutedRequestStates;
+    private readonly redirectTargets;
+    private readonly normalizedEventPayloads;
+    private readonly nativeFrameBindings;
+    private readonly frameMap;
+    private readonly frameOrder;
+    private frameSnapshotRefreshInProgress;
+    private openerPage;
+    private pauseSequence;
+    private readonly pageWorkers;
+    private pageVideo;
+    private stopPageVideoRecording;
+    private rejectPageVideoRecording;
+    private pageVideoFinalizePromise;
+    private emulatedMedia;
+    private readonly exposedBindings;
+    private readonly locatorHandlers;
+    private locatorHandlerRunningCounter;
+    private pickLocatorState;
+    private bindingPumpStarted;
+    private fileChooserAdapterDisposer;
+    private fileChooserBridgeInstalled;
+    private fileChooserInterceptionRequested;
+    private fileChooserRuntimeInitScriptInstalled;
+    private fileChooserInterceptionPromise;
+    private readonly pendingFileChoosers;
+    private routeInterceptorsInstalled;
+    private websocketRouteBridgeInstalled;
+    private routePumpStarted;
+    private readonly routeHandlers;
+    private readonly websocketRouteHandlers;
+    private readonly webSockets;
+    private readonly hostedWebSocketRoutes;
+    private readonly harRoutes;
+    private readonly activeRouteDispatches;
+    private readonly routeMatcherIds;
+    private nextRouteMatcherId;
+    private screenshotTaskChain;
+    private readonly detachedContextFallback;
+    constructor(adapter: ProtocolPageAdapter, humanDefaults: ResolvedHumanizationOptions, browserContext?: RoxyBrowserContext | undefined, contextOptions?: BrowserContextOptions);
+    addInitScript<Arg>(script: PageFunction<Arg, any> | {
+        path?: string;
+        content?: string;
+    }, arg?: Arg): Promise<Disposable>;
+    _ensurePlaywrightBuiltinsInstalled(): Promise<void>;
+    addLocatorHandler(locator: Locator, handler: (locator: Locator) => Promise<any>, options?: AddLocatorHandlerOptions): Promise<void>;
+    exposeBinding(name: string, playwrightBinding: (source: BindingSource, ...args: any[]) => any): Promise<Disposable>;
+    exposeFunction(name: string, callback: Function): Promise<Disposable>;
+    addScriptTag(options?: {
+        content?: string;
+        path?: string;
+        type?: string;
+        url?: string;
+    }): Promise<ElementHandle>;
+    addStyleTag(options?: {
+        content?: string;
+        path?: string;
+        url?: string;
+    }): Promise<ElementHandle>;
+    goto(url: string, options?: {
+        referer?: string;
+        timeout?: number;
+        waitUntil?: "load" | "domcontentloaded" | "networkidle" | "commit";
+    }): Promise<null | Response>;
+    url(): string;
+    goBack(options?: {
+        timeout?: number;
+        waitUntil?: "load" | "domcontentloaded" | "networkidle" | "commit";
+    }): Promise<null | Response>;
+    goForward(options?: {
+        timeout?: number;
+        waitUntil?: "load" | "domcontentloaded" | "networkidle" | "commit";
+    }): Promise<null | Response>;
+    reload(options?: {
+        timeout?: number;
+        waitUntil?: "load" | "domcontentloaded" | "networkidle" | "commit";
+    }): Promise<null | Response>;
+    title(): Promise<string>;
+    content(): Promise<string>;
+    setContent(html: string, options?: {
+        timeout?: number;
+        waitUntil?: "load" | "domcontentloaded" | "networkidle" | "commit";
+    }): Promise<void>;
+    evaluate<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg): Promise<R>;
+    evaluate<R>(pageFunction: PageFunction<void, R>, arg?: any): Promise<R>;
+    evaluateHandle<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg): Promise<SmartHandle<R>>;
+    evaluateHandle<R>(pageFunction: PageFunction<void, R>, arg?: any): Promise<SmartHandle<R>>;
+    waitForFunction<R, Arg>(pageFunction: PageFunction<Arg, R>, arg: Arg, options?: PageWaitForFunctionOptions): Promise<SmartHandle<R>>;
+    waitForFunction<R>(pageFunction: PageFunction<void, R>, arg?: any, options?: PageWaitForFunctionOptions): Promise<SmartHandle<R>>;
+    waitForTimeout(timeout: number): Promise<void>;
+    prepareForPendingFileChooser(): Promise<void>;
+    waitForURL(url: string | RegExp | URLPattern | ((url: URL) => boolean), options?: {
+        timeout?: number;
+        waitUntil?: "load" | "domcontentloaded" | "networkidle" | "commit";
+    }): Promise<void>;
+    waitForNavigation(options?: {
+        timeout?: number;
+        url?: string | RegExp | URLPattern | ((url: URL) => boolean);
+        waitUntil?: "load" | "domcontentloaded" | "networkidle" | "commit";
+    }): Promise<null | Response>;
+    waitForNavigationInFrame(frame: RoxyFrameSnapshot | null, options?: WaitForNavigationOptions): Promise<Response | null>;
+    waitForRequest(urlOrPredicate: string | RegExp | ((request: Request) => boolean | Promise<boolean>), options?: {
+        timeout?: number;
+    }): Promise<Request>;
+    waitForResponse(urlOrPredicate: string | RegExp | ((response: Response) => boolean | Promise<boolean>), options?: {
+        timeout?: number;
+    }): Promise<Response>;
+    waitForLoadState(state?: "load" | "domcontentloaded" | "networkidle", options?: {
+        timeout?: number;
+    }): Promise<void>;
+    waitForFrameLoadState(frame: RoxyFrameSnapshot, state: LoadState, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    waitForSelector<K extends keyof HTMLElementTagNameMap>(selector: K, options?: WaitForSelectorOptions & {
+        state?: "visible" | "attached";
+    }): Promise<ElementHandleForTag<K>>;
+    waitForSelector(selector: string, options?: WaitForSelectorOptions & {
+        state?: "visible" | "attached";
+    }): Promise<ElementHandle<SVGElement | HTMLElement>>;
+    waitForSelector<K extends keyof HTMLElementTagNameMap>(selector: K, options: WaitForSelectorOptions): Promise<ElementHandleForTag<K> | null>;
+    waitForSelector(selector: string, options: WaitForSelectorOptions): Promise<null | ElementHandle<SVGElement | HTMLElement>>;
+    ariaSnapshot(options?: {
+        boxes?: boolean;
+        depth?: number;
+        mode?: "ai" | "default";
+        timeout?: number;
+    }): Promise<string>;
+    resolveAriaRef(ref: string): Promise<ResolvedAriaRef>;
+    screenshot(options?: ScreenshotOptions): Promise<Buffer>;
+    runScreenshotTask<T>(task: () => Promise<T>): Promise<T>;
+    private screenshotWithoutQueue;
+    context(): BrowserContext;
+    consoleMessages(options?: {
+        filter?: "all" | "since-navigation";
+    }): Promise<Array<PageConsoleMessage>>;
+    clearConsoleMessages(): Promise<void>;
+    clearPageErrors(): Promise<void>;
+    pageErrors(options?: {
+        filter?: "all" | "since-navigation";
+    }): Promise<Array<PageErrorEntry>>;
+    requests(): Promise<Array<Request>>;
+    on(event: 'close', listener: (page: Page) => any): this;
+    on(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;
+    on(event: 'crash', listener: (page: Page) => any): this;
+    on(event: 'dialog', listener: (dialog: Dialog) => any): this;
+    on(event: 'domcontentloaded', listener: (page: Page) => any): this;
+    on(event: 'download', listener: (download: Download) => any): this;
+    on(event: 'filechooser', listener: (fileChooser: FileChooser) => any): this;
+    on(event: 'frameattached', listener: (frame: Frame) => any): this;
+    on(event: 'framedetached', listener: (frame: Frame) => any): this;
+    on(event: 'framenavigated', listener: (frame: Frame) => any): this;
+    on(event: 'load', listener: (page: Page) => any): this;
+    on(event: 'pageerror', listener: (error: Error) => any): this;
+    on(event: 'popup', listener: (page: Page) => any): this;
+    on(event: 'request', listener: (request: Request) => any): this;
+    on(event: 'requestfailed', listener: (request: Request) => any): this;
+    on(event: 'requestfinished', listener: (request: Request) => any): this;
+    on(event: 'response', listener: (response: Response) => any): this;
+    on(event: 'websocket', listener: (webSocket: WebSocket) => any): this;
+    on(event: 'worker', listener: (worker: Worker) => any): this;
+    addListener(event: 'close', listener: (page: Page) => any): this;
+    addListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;
+    addListener(event: 'crash', listener: (page: Page) => any): this;
+    addListener(event: 'dialog', listener: (dialog: Dialog) => any): this;
+    addListener(event: 'domcontentloaded', listener: (page: Page) => any): this;
+    addListener(event: 'download', listener: (download: Download) => any): this;
+    addListener(event: 'filechooser', listener: (fileChooser: FileChooser) => any): this;
+    addListener(event: 'frameattached', listener: (frame: Frame) => any): this;
+    addListener(event: 'framedetached', listener: (frame: Frame) => any): this;
+    addListener(event: 'framenavigated', listener: (frame: Frame) => any): this;
+    addListener(event: 'load', listener: (page: Page) => any): this;
+    addListener(event: 'pageerror', listener: (error: Error) => any): this;
+    addListener(event: 'popup', listener: (page: Page) => any): this;
+    addListener(event: 'request', listener: (request: Request) => any): this;
+    addListener(event: 'requestfailed', listener: (request: Request) => any): this;
+    addListener(event: 'requestfinished', listener: (request: Request) => any): this;
+    addListener(event: 'response', listener: (response: Response) => any): this;
+    addListener(event: 'websocket', listener: (webSocket: WebSocket) => any): this;
+    addListener(event: 'worker', listener: (worker: Worker) => any): this;
+    once(event: 'close', listener: (page: Page) => any): this;
+    once(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;
+    once(event: 'crash', listener: (page: Page) => any): this;
+    once(event: 'dialog', listener: (dialog: Dialog) => any): this;
+    once(event: 'domcontentloaded', listener: (page: Page) => any): this;
+    once(event: 'download', listener: (download: Download) => any): this;
+    once(event: 'filechooser', listener: (fileChooser: FileChooser) => any): this;
+    once(event: 'frameattached', listener: (frame: Frame) => any): this;
+    once(event: 'framedetached', listener: (frame: Frame) => any): this;
+    once(event: 'framenavigated', listener: (frame: Frame) => any): this;
+    once(event: 'load', listener: (page: Page) => any): this;
+    once(event: 'pageerror', listener: (error: Error) => any): this;
+    once(event: 'popup', listener: (page: Page) => any): this;
+    once(event: 'request', listener: (request: Request) => any): this;
+    once(event: 'requestfailed', listener: (request: Request) => any): this;
+    once(event: 'requestfinished', listener: (request: Request) => any): this;
+    once(event: 'response', listener: (response: Response) => any): this;
+    once(event: 'websocket', listener: (webSocket: WebSocket) => any): this;
+    once(event: 'worker', listener: (worker: Worker) => any): this;
+    removeListener(event: 'close', listener: (page: Page) => any): this;
+    removeListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;
+    removeListener(event: 'crash', listener: (page: Page) => any): this;
+    removeListener(event: 'dialog', listener: (dialog: Dialog) => any): this;
+    removeListener(event: 'domcontentloaded', listener: (page: Page) => any): this;
+    removeListener(event: 'download', listener: (download: Download) => any): this;
+    removeListener(event: 'filechooser', listener: (fileChooser: FileChooser) => any): this;
+    removeListener(event: 'frameattached', listener: (frame: Frame) => any): this;
+    removeListener(event: 'framedetached', listener: (frame: Frame) => any): this;
+    removeListener(event: 'framenavigated', listener: (frame: Frame) => any): this;
+    removeListener(event: 'load', listener: (page: Page) => any): this;
+    removeListener(event: 'pageerror', listener: (error: Error) => any): this;
+    removeListener(event: 'popup', listener: (page: Page) => any): this;
+    removeListener(event: 'request', listener: (request: Request) => any): this;
+    removeListener(event: 'requestfailed', listener: (request: Request) => any): this;
+    removeListener(event: 'requestfinished', listener: (request: Request) => any): this;
+    removeListener(event: 'response', listener: (response: Response) => any): this;
+    removeListener(event: 'websocket', listener: (webSocket: WebSocket) => any): this;
+    removeListener(event: 'worker', listener: (worker: Worker) => any): this;
+    off(event: 'close', listener: (page: Page) => any): this;
+    off(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;
+    off(event: 'crash', listener: (page: Page) => any): this;
+    off(event: 'dialog', listener: (dialog: Dialog) => any): this;
+    off(event: 'domcontentloaded', listener: (page: Page) => any): this;
+    off(event: 'download', listener: (download: Download) => any): this;
+    off(event: 'filechooser', listener: (fileChooser: FileChooser) => any): this;
+    off(event: 'frameattached', listener: (frame: Frame) => any): this;
+    off(event: 'framedetached', listener: (frame: Frame) => any): this;
+    off(event: 'framenavigated', listener: (frame: Frame) => any): this;
+    off(event: 'load', listener: (page: Page) => any): this;
+    off(event: 'pageerror', listener: (error: Error) => any): this;
+    off(event: 'popup', listener: (page: Page) => any): this;
+    off(event: 'request', listener: (request: Request) => any): this;
+    off(event: 'requestfailed', listener: (request: Request) => any): this;
+    off(event: 'requestfinished', listener: (request: Request) => any): this;
+    off(event: 'response', listener: (response: Response) => any): this;
+    off(event: 'websocket', listener: (webSocket: WebSocket) => any): this;
+    off(event: 'worker', listener: (worker: Worker) => any): this;
+    prependListener(event: 'close', listener: (page: Page) => any): this;
+    prependListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;
+    prependListener(event: 'crash', listener: (page: Page) => any): this;
+    prependListener(event: 'dialog', listener: (dialog: Dialog) => any): this;
+    prependListener(event: 'domcontentloaded', listener: (page: Page) => any): this;
+    prependListener(event: 'download', listener: (download: Download) => any): this;
+    prependListener(event: 'filechooser', listener: (fileChooser: FileChooser) => any): this;
+    prependListener(event: 'frameattached', listener: (frame: Frame) => any): this;
+    prependListener(event: 'framedetached', listener: (frame: Frame) => any): this;
+    prependListener(event: 'framenavigated', listener: (frame: Frame) => any): this;
+    prependListener(event: 'load', listener: (page: Page) => any): this;
+    prependListener(event: 'pageerror', listener: (error: Error) => any): this;
+    prependListener(event: 'popup', listener: (page: Page) => any): this;
+    prependListener(event: 'request', listener: (request: Request) => any): this;
+    prependListener(event: 'requestfailed', listener: (request: Request) => any): this;
+    prependListener(event: 'requestfinished', listener: (request: Request) => any): this;
+    prependListener(event: 'response', listener: (response: Response) => any): this;
+    prependListener(event: 'websocket', listener: (webSocket: WebSocket) => any): this;
+    prependListener(event: 'worker', listener: (worker: Worker) => any): this;
+    removeAllListeners(type?: string): this;
+    removeAllListeners(type: string | undefined, options: {
+        behavior?: 'wait' | 'ignoreErrors' | 'default';
+    }): Promise<void>;
+    waitForEvent(event: "console", optionsOrPredicate?: ((consoleMessage: PageConsoleMessage) => boolean | Promise<boolean>) | {
+        predicate?: (consoleMessage: PageConsoleMessage) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<PageConsoleMessage>;
+    waitForEvent<K extends PageEventName>(event: "dialog", optionsOrPredicate?: ((dialog: Dialog) => boolean | Promise<boolean>) | {
+        predicate?: (dialog: Dialog) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Dialog>;
+    waitForEvent<K extends PageEventName>(event: "crash", optionsOrPredicate?: ((page: Page) => boolean | Promise<boolean>) | {
+        predicate?: (page: Page) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Page>;
+    waitForEvent<K extends PageEventName>(event: "close", optionsOrPredicate?: ((page: Page) => boolean | Promise<boolean>) | {
+        predicate?: (page: Page) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Page>;
+    waitForEvent<K extends PageEventName>(event: "domcontentloaded", optionsOrPredicate?: ((page: Page) => boolean | Promise<boolean>) | {
+        predicate?: (page: Page) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Page>;
+    waitForEvent(event: "download", optionsOrPredicate?: ((download: Download) => boolean | Promise<boolean>) | {
+        predicate?: (download: Download) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Download>;
+    waitForEvent(event: "filechooser", optionsOrPredicate?: ((fileChooser: FileChooser) => boolean | Promise<boolean>) | {
+        predicate?: (fileChooser: FileChooser) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<FileChooser>;
+    waitForEvent(event: "frameattached", optionsOrPredicate?: ((frame: Frame) => boolean | Promise<boolean>) | {
+        predicate?: (frame: Frame) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Frame>;
+    waitForEvent(event: "framedetached", optionsOrPredicate?: ((frame: Frame) => boolean | Promise<boolean>) | {
+        predicate?: (frame: Frame) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Frame>;
+    waitForEvent(event: "framenavigated", optionsOrPredicate?: ((frame: Frame) => boolean | Promise<boolean>) | {
+        predicate?: (frame: Frame) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Frame>;
+    waitForEvent<K extends PageEventName>(event: "load", optionsOrPredicate?: ((page: Page) => boolean | Promise<boolean>) | {
+        predicate?: (page: Page) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Page>;
+    waitForEvent(event: "pageerror", optionsOrPredicate?: ((error: PageErrorEntry) => boolean | Promise<boolean>) | {
+        predicate?: (error: PageErrorEntry) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<PageErrorEntry>;
+    waitForEvent(event: "popup", optionsOrPredicate?: ((page: Page) => boolean | Promise<boolean>) | {
+        predicate?: (page: Page) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Page>;
+    waitForEvent<K extends PageEventName>(event: "request", optionsOrPredicate?: ((request: Request) => boolean | Promise<boolean>) | {
+        predicate?: (request: Request) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Request>;
+    waitForEvent(event: "requestfinished", optionsOrPredicate?: ((request: Request) => boolean | Promise<boolean>) | {
+        predicate?: (request: Request) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Request>;
+    waitForEvent(event: "requestfailed", optionsOrPredicate?: ((request: Request) => boolean | Promise<boolean>) | {
+        predicate?: (request: Request) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Request>;
+    waitForEvent(event: "response", optionsOrPredicate?: ((response: Response) => boolean | Promise<boolean>) | {
+        predicate?: (response: Response) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Response>;
+    waitForEvent(event: "websocket", optionsOrPredicate?: ((webSocket: WebSocket) => boolean | Promise<boolean>) | {
+        predicate?: (webSocket: WebSocket) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<WebSocket>;
+    waitForEvent(event: "worker", optionsOrPredicate?: ((worker: Worker) => boolean | Promise<boolean>) | {
+        predicate?: (worker: Worker) => boolean | Promise<boolean>;
+        timeout?: number;
+    }): Promise<Worker>;
+    waitForEvent<K extends PageEventName>(event: K, optionsOrPredicate?: PageEventPredicate<K> | InternalWaitForEventOptions<K>): Promise<PageEventMap[K]>;
+    $<K extends keyof HTMLElementTagNameMap>(selector: K, options?: {
+        strict: boolean;
+    }): Promise<ElementHandleForTag<K> | null>;
+    $(selector: string, options?: {
+        strict: boolean;
+    }): Promise<ElementHandle<SVGElement | HTMLElement> | null>;
+    $$<K extends keyof HTMLElementTagNameMap>(selector: K): Promise<ElementHandleForTag<K>[]>;
+    $$(selector: string): Promise<ElementHandle<SVGElement | HTMLElement>[]>;
+    $eval<K extends keyof HTMLElementTagNameMap, R, Arg>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K], Arg, R>, arg: Arg): Promise<R>;
+    $eval<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E, Arg, R>, arg: Arg): Promise<R>;
+    $eval<K extends keyof HTMLElementTagNameMap, R>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K], void, R>, arg?: any): Promise<R>;
+    $eval<R, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E, void, R>, arg?: any): Promise<R>;
+    $$eval<K extends keyof HTMLElementTagNameMap, R, Arg>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K][], Arg, R>, arg: Arg): Promise<R>;
+    $$eval<R, Arg, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E[], Arg, R>, arg: Arg): Promise<R>;
+    $$eval<K extends keyof HTMLElementTagNameMap, R>(selector: K, pageFunction: PageFunctionOn<HTMLElementTagNameMap[K][], void, R>, arg?: any): Promise<R>;
+    $$eval<R, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(selector: string, pageFunction: PageFunctionOn<E[], void, R>, arg?: any): Promise<R>;
+    frameLocator(selector: string): FrameLocator;
+    frame(frameSelector: string | {
+        name?: string;
+        url?: string | RegExp | URLPattern | ((url: URL) => boolean);
+    }): null | Frame;
+    frames(): Array<Frame>;
+    mainFrame(): Frame;
+    locator(selector: string, options?: LocatorOptions): Locator;
+    getByText(text: string | RegExp, options?: {
+        exact?: boolean;
+    }): Locator;
+    getByAltText(text: string | RegExp, options?: {
+        exact?: boolean;
+    }): Locator;
+    getByLabel(text: string | RegExp, options?: {
+        exact?: boolean;
+    }): Locator;
+    getByPlaceholder(text: string | RegExp, options?: {
+        exact?: boolean;
+    }): Locator;
+    getByTestId(testId: string | RegExp): Locator;
+    getByRole(role: "alert" | "alertdialog" | "application" | "article" | "banner" | "blockquote" | "button" | "caption" | "cell" | "checkbox" | "code" | "columnheader" | "combobox" | "complementary" | "contentinfo" | "definition" | "deletion" | "dialog" | "directory" | "document" | "emphasis" | "feed" | "figure" | "form" | "generic" | "grid" | "gridcell" | "group" | "heading" | "img" | "insertion" | "link" | "list" | "listbox" | "listitem" | "log" | "main" | "marquee" | "math" | "meter" | "menu" | "menubar" | "menuitem" | "menuitemcheckbox" | "menuitemradio" | "navigation" | "none" | "note" | "option" | "paragraph" | "presentation" | "progressbar" | "radio" | "radiogroup" | "region" | "row" | "rowgroup" | "rowheader" | "scrollbar" | "search" | "searchbox" | "separator" | "slider" | "spinbutton" | "status" | "strong" | "subscript" | "superscript" | "switch" | "tab" | "table" | "tablist" | "tabpanel" | "term" | "textbox" | "time" | "timer" | "toolbar" | "tooltip" | "tree" | "treegrid" | "treeitem", options?: {
+        checked?: boolean;
+        description?: string | RegExp;
+        disabled?: boolean;
+        exact?: boolean;
+        expanded?: boolean;
+        includeHidden?: boolean;
+        level?: number;
+        name?: string | RegExp;
+        pressed?: boolean;
+        selected?: boolean;
+    }): Locator;
+    getByTitle(text: string | RegExp, options?: {
+        exact?: boolean;
+    }): Locator;
+    cancelPickLocator(): Promise<void>;
+    hideHighlight(): Promise<void>;
+    opener(): Promise<Page | null>;
+    pause(_options?: {
+        __testHookKeepTestTimeout?: boolean;
+    }): Promise<void>;
+    pdf(options?: {
+        displayHeaderFooter?: boolean;
+        footerTemplate?: string;
+        format?: string;
+        headerTemplate?: string;
+        height?: string | number;
+        landscape?: boolean;
+        margin?: {
+            top?: string | number;
+            right?: string | number;
+            bottom?: string | number;
+            left?: string | number;
+        };
+        outline?: boolean;
+        pageRanges?: string;
+        path?: string;
+        preferCSSPageSize?: boolean;
+        printBackground?: boolean;
+        scale?: number;
+        tagged?: boolean;
+        width?: string | number;
+    }): Promise<Buffer>;
+    video(): Video | null;
+    pickLocator(): Promise<Locator>;
+    removeLocatorHandler(locator: Locator): Promise<void>;
+    route(url: string | RegExp | URLPattern | ((url: URL) => boolean), handler: (route: Route, request: Request) => Promise<any> | any, options?: {
+        times?: number;
+    }): Promise<Disposable>;
+    routeFromHAR(har: string, options?: {
+        notFound?: "abort" | "fallback";
+        update?: boolean;
+        updateContent?: "embed" | "attach";
+        updateMode?: "full" | "minimal";
+        url?: string | RegExp;
+    }): Promise<void>;
+    routeWebSocket(url: string | RegExp | URLPattern | ((url: URL) => boolean), handler: (websocketroute: WebSocketRoute) => Promise<any> | any): Promise<void>;
+    unroute(url: string | RegExp | URLPattern | ((url: URL) => boolean), handler?: (route: Route, request: Request) => Promise<any> | any): Promise<void>;
+    unrouteAll(options?: {
+        behavior?: "wait" | "ignoreErrors" | "default";
+    }): Promise<void>;
+    workers(): Array<Worker>;
+    textContent(selector: string, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<null | string>;
+    innerText(selector: string, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<string>;
+    innerHTML(selector: string, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<string>;
+    getAttribute(selector: string, name: string, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<null | string>;
+    inputValue(selector: string, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<string>;
+    isChecked(selector: string, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<boolean>;
+    isDisabled(selector: string, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<boolean>;
+    isEditable(selector: string, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<boolean>;
+    isEnabled(selector: string, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<boolean>;
+    isHidden(selector: string, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<boolean>;
+    isVisible(selector: string, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<boolean>;
+    focus(selector: string, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<void>;
+    check(selector: string, options?: {
+        force?: boolean;
+        noWaitAfter?: boolean;
+        position?: {
+            x: number;
+            y: number;
+        };
+        strict?: boolean;
+        timeout?: number;
+        trial?: boolean;
+    }): Promise<void>;
+    uncheck(selector: string, options?: {
+        force?: boolean;
+        noWaitAfter?: boolean;
+        position?: {
+            x: number;
+            y: number;
+        };
+        strict?: boolean;
+        timeout?: number;
+        trial?: boolean;
+    }): Promise<void>;
+    dragAndDrop(source: string, target: string, options?: {
+        force?: boolean;
+        noWaitAfter?: boolean;
+        sourcePosition?: {
+            x: number;
+            y: number;
+        };
+        steps?: number;
+        strict?: boolean;
+        targetPosition?: {
+            x: number;
+            y: number;
+        };
+        timeout?: number;
+        trial?: boolean;
+    }): Promise<void>;
+    emulateMedia(options?: {
+        colorScheme?: null | "light" | "dark" | "no-preference";
+        contrast?: null | "no-preference" | "more";
+        forcedColors?: null | "active" | "none";
+        media?: null | "screen" | "print";
+        reducedMotion?: null | "reduce" | "no-preference";
+    }): Promise<void>;
+    setChecked(selector: string, checked: boolean, options?: {
+        force?: boolean;
+        noWaitAfter?: boolean;
+        position?: {
+            x: number;
+            y: number;
+        };
+        strict?: boolean;
+        timeout?: number;
+        trial?: boolean;
+    }): Promise<void>;
+    setExtraHTTPHeaders(headers: {
+        [key: string]: string;
+    }): Promise<void>;
+    setInputFiles(selector: string, files: PlaywrightInputFiles, options?: {
+        noWaitAfter?: boolean;
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<void>;
+    setInputFiles(selector: ElementHandle, files: InputFiles, options?: SetInputFilesOptions): Promise<void>;
+    dispatchEvent(selector: string, type: string, eventInit?: EvaluationArgument, options?: {
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<void>;
+    requestGC(): Promise<void>;
+    selectOption(selector: string, values: PlaywrightSelectOptionValues, options?: {
+        force?: boolean;
+        noWaitAfter?: boolean;
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<Array<string>>;
+    bringToFront(): Promise<void>;
+    isClosed(): boolean;
+    setDefaultNavigationTimeout(timeout: number): void;
+    setDefaultTimeout(timeout: number): void;
+    setViewportSize(viewportSize: {
+        width: number;
+        height: number;
+    }): Promise<void>;
+    viewportSize(): ViewportSize | null;
+    dblclick(selector: string, options?: {
+        button?: "left" | "right" | "middle";
+        delay?: number;
+        force?: boolean;
+        modifiers?: Array<"Alt" | "Control" | "ControlOrMeta" | "Meta" | "Shift">;
+        noWaitAfter?: boolean;
+        position?: {
+            x: number;
+            y: number;
+        };
+        strict?: boolean;
+        timeout?: number;
+        trial?: boolean;
+    }): Promise<void>;
+    click(selector: string, options?: {
+        button?: "left" | "right" | "middle";
+        clickCount?: number;
+        delay?: number;
+        force?: boolean;
+        modifiers?: Array<"Alt" | "Control" | "ControlOrMeta" | "Meta" | "Shift">;
+        noWaitAfter?: boolean;
+        position?: {
+            x: number;
+            y: number;
+        };
+        strict?: boolean;
+        timeout?: number;
+        trial?: boolean;
+    }): Promise<void>;
+    hover(selector: string, options?: {
+        force?: boolean;
+        modifiers?: Array<"Alt" | "Control" | "ControlOrMeta" | "Meta" | "Shift">;
+        noWaitAfter?: boolean;
+        position?: {
+            x: number;
+            y: number;
+        };
+        strict?: boolean;
+        timeout?: number;
+        trial?: boolean;
+    }): Promise<void>;
+    fill(selector: string, value: string, options?: {
+        force?: boolean;
+        noWaitAfter?: boolean;
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<void>;
+    type(selector: string, text: string, options?: {
+        delay?: number;
+        noWaitAfter?: boolean;
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<void>;
+    press(selector: string, key: string, options?: {
+        delay?: number;
+        noWaitAfter?: boolean;
+        strict?: boolean;
+        timeout?: number;
+    }): Promise<void>;
+    tap(selector: string, options?: {
+        force?: boolean;
+        modifiers?: Array<"Alt" | "Control" | "ControlOrMeta" | "Meta" | "Shift">;
+        noWaitAfter?: boolean;
+        position?: {
+            x: number;
+            y: number;
+        };
+        strict?: boolean;
+        timeout?: number;
+        trial?: boolean;
+    }): Promise<void>;
+    close(options?: {
+        reason?: string;
+        runBeforeUnload?: boolean;
+    }): Promise<void>;
+    defaultTimeout(): number;
+    strictSelectors(): boolean;
+    defaultNavigationTimeout(): number;
+    baseURLForMatching(): string | undefined;
+    setOpener(page: Page | null): void;
+    emitPopup(popup: Page): void;
+    setVideoPath(videoPath: string | null): void;
+    setVideo(video: Video | null, stopRecording?: () => Promise<void>, rejectRecording?: (error: unknown) => void): void;
+    startVideoRecording(options: {
+        path: string;
+        size?: {
+            width: number;
+            height: number;
+        };
+        quality?: number;
+        showActions?: {
+            duration?: number;
+            position?: "top-left" | "top" | "top-right" | "bottom-left" | "bottom" | "bottom-right";
+            fontSize?: number;
+        };
+    }): Promise<Disposable>;
+    attachWorker(worker?: Worker): Worker;
+    private finalizeVideoRecording;
+    private handleAdapterClosed;
+    maybeRunLocatorHandlers(locator: Locator, options?: {
+        force?: boolean;
+        timeout?: number;
+        __roxyBeforeActionRetry?: () => Promise<boolean | void>;
+    }): Promise<boolean>;
+    frameById(id: string): RoxyFrame | null;
+    createElementHandle(adapter: ProtocolElementHandleAdapter): RoxyElementHandle;
+    createElementHandleFromReference(reference: ProtocolElementHandleReference): ElementHandle;
+    frameElementForFrame(frame: RoxyFrameSnapshot): Promise<ElementHandle | null>;
+    contentFrameForElement(handle: RoxyElementHandle): Promise<Frame | null>;
+    private matchContentFrameByOwnerElement;
+    private ensureContentFrame;
+    ownerFrameForElement(handle: RoxyElementHandle): Promise<Frame | null>;
+    private resolveFrameAcrossKnownPages;
+    private frameByNativeId;
+    private referencesSameNode;
+    private evaluateOwnerFrameMatch;
+    evaluateInFrame<R, Arg>(frame: RoxyFrameSnapshot, pageFunction: PageFunction<Arg, R>, arg?: Arg): Promise<R>;
+    evaluateInFrameWithFunctionFlag<R, Arg>(frame: RoxyFrameSnapshot, pageFunction: PageFunction<Arg, R>, arg: Arg | undefined, isFunction: boolean): Promise<R>;
+    evaluateHandleInFrame<R, Arg>(frame: RoxyFrameSnapshot, pageFunction: PageFunction<Arg, R>, arg?: Arg): Promise<SmartHandle<R>>;
+    private shouldFallbackToOwnerElementFrameEvaluation;
+    private isMainFrameExecutionContextUnavailable;
+    private ownerElementAdapterForFrame;
+    queryInFrame(frame: RoxyFrameSnapshot, selector: string, options?: {
+        strict?: boolean;
+    }): Promise<ElementHandle | null>;
+    queryAllInFrame(frame: RoxyFrameSnapshot, selector: string): Promise<ElementHandle[]>;
+    refreshFramesForExternalMutation(): Promise<void>;
+    gotoInFrame(frame: RoxyFrameSnapshot, url: string, options?: PageGotoOptions): Promise<Response | null>;
+    titleInFrame(frame: RoxyFrameSnapshot): Promise<string>;
+    contentInFrame(frame: RoxyFrameSnapshot): Promise<string>;
+    setContentInFrame(frame: RoxyFrameSnapshot, html: string, options?: PageSetContentOptions): Promise<void>;
+    evalOnSelectorInFrame<TResult, TArg = unknown>(frame: RoxyFrameSnapshot, selector: string, pageFunction: string | ElementCallback<TResult, TArg>, arg?: TArg): Promise<TResult>;
+    evalOnSelectorAllInFrame<TResult, TArg = unknown>(frame: RoxyFrameSnapshot, selector: string, pageFunction: string | ElementArrayCallback<TResult, TArg>, arg?: TArg): Promise<TResult>;
+    addScriptTagInFrame(frame: RoxyFrameSnapshot, options?: AddScriptTagOptions): Promise<ElementHandle>;
+    addStyleTagInFrame(frame: RoxyFrameSnapshot, options?: AddStyleTagOptions): Promise<ElementHandle>;
+    locatorInFrame(frame: RoxyFrameSnapshot, selector: string): Locator;
+    getByTextInFrame(frame: RoxyFrameSnapshot, text: string | RegExp, options?: GetByTextOptions): Locator;
+    getByAltTextInFrame(frame: RoxyFrameSnapshot, text: string | RegExp, options?: GetByAltTextOptions): Locator;
+    getByLabelInFrame(frame: RoxyFrameSnapshot, text: string | RegExp, options?: GetByLabelOptions): Locator;
+    getByPlaceholderInFrame(frame: RoxyFrameSnapshot, text: string | RegExp, options?: GetByPlaceholderOptions): Locator;
+    getByTestIdInFrame(frame: RoxyFrameSnapshot, testId: string | RegExp): Locator;
+    getByRoleInFrame(frame: RoxyFrameSnapshot, role: string, options?: GetByRoleOptions): Locator;
+    getByTitleInFrame(frame: RoxyFrameSnapshot, text: string | RegExp, options?: GetByTitleOptions): Locator;
+    private normalizeScriptTagOptions;
+    private normalizeStyleTagOptions;
+    private matchesURL;
+    private matchesEventURLPredicate;
+    private ensureObservation;
+    private ensurePublicListenerSet;
+    private ensureInternalListenerSet;
+    private addInternalListener;
+    private removeInternalListener;
+    attachInternalListener<K extends PageEventName>(event: K, listener: PageEventListener<K>): () => void;
+    addInternalFrameWaitListener<K extends "close" | "framedetached">(event: K, listener: PageEventListener<K>): void;
+    addInternalNavigationWaitListener(event: "framenavigated", listener: PageEventListener<"framenavigated">): void;
+    removeInternalFrameWaitListener<K extends "close" | "framedetached">(event: K, listener: PageEventListener<K>): void;
+    removeInternalNavigationWaitListener(event: "framenavigated", listener: PageEventListener<"framenavigated">): void;
+    private ensureAdapterObservation;
+    private trimObservation;
+    private emit;
+    private removeAllListenersInternal;
+    private hasFrameEventObservers;
+    private trackPendingHandler;
+    private waitForPendingHandlers;
+    private recordEvent;
+    private resetHistorySinceNavigation;
+    private resolveDanglingMainFrameRequestsAfterNavigation;
+    private initializeInternalEventRecording;
+    private handleAdapterBackedEvent;
+    private normalizePublicEventPayload;
+    private handleRawWebSocketEvent;
+    private createPublicDialog;
+    private shouldAutoHandleDialog;
+    private autoHandleDialog;
+    private dismissActiveDialogsForClose;
+    private createPublicConsoleMessage;
+    private observeAdapterRequest;
+    private observeAdapterResponse;
+    private isRedirectResponsePayload;
+    private observeRequestCompletion;
+    private observeRequestFailure;
+    private createObservedRequest;
+    private createObservedResponse;
+    private createObservedRequestForResponseOnly;
+    private toPublicResponse;
+    private resolveObservedRequestFrame;
+    private ensureSyntheticRequestFrame;
+    private matchFrameForObservedRequest;
+    private isMainFrameNavigationRequest;
+    private isRawMainFrameNavigation;
+    private observeSyntheticObservedRequest;
+    private findObservedRequestForResponse;
+    private findObservedRequestState;
+    private removeObservedRequestFromUrlIndex;
+    private consumeRedirectSource;
+    private findRedirectSourceForRequest;
+    private createLocatorFromChain;
+    private createLocatorFromAdapterChain;
+    private rootLocatorForFrame;
+    private chainForFrame;
+    private referenceForFrame;
+    private elementHandleForSelector;
+    private requiredElementHandleForSelector;
+    private refreshFrameSnapshots;
+    private applyEmulatedMedia;
+    private registerExposedBinding;
+    private startBindingPump;
+    private drainBindingCalls;
+    flushExposedBindingCallsForInternalUse(): Promise<void>;
+    private createBindingSource;
+    private resolveBindingCall;
+    private reinstallExposedBindings;
+    private maybeStartFileChooserInterception;
+    private ensureFileChooserInterception;
+    private installFileChooserRuntimeIntoCurrentFrames;
+    private waitForFileChooserInterceptionIfPending;
+    private installFileChooserRuntimeInitScript;
+    private installFileChooserBridge;
+    private handleFileChooserOpened;
+    private handleNativeFileChooserOpened;
+    private installFileChooserHandleFactory;
+    private installExposedBinding;
+    private removeExposedBinding;
+    private installRouteInterceptors;
+    private syncRouteInterception;
+    _ensureRouteInterceptorsInstalled(): Promise<void>;
+    _syncRouteInterceptionForContext(): Promise<void>;
+    private needsWebSocketRouteBridge;
+    private installWebSocketRouteBridge;
+    private installRouteBridge;
+    private startRoutePump;
+    private drainRouteCalls;
+    private trackRouteDispatch;
+    private dispatchRoutedRequest;
+    private applyRoutedRequestStateToObservedRequest;
+    private applyRoutedRequestStateToObservedRequestState;
+    private consumePendingRoutedRequestState;
+    private dispatchHarRoute;
+    private findHarRouteEntry;
+    private fetchRouteRequest;
+    private buildFulfillDecision;
+    private maybeAddCorsHeaders;
+    private createRouteRequest;
+    private consumeRouteHandler;
+    private stopRouteHandlers;
+    private resolveRoutedRequest;
+    private dispatchWebSocketOpen;
+    private createHostedWebSocketRoute;
+    private dispatchWebSocketEvent;
+    private resolveWebSocketOpen;
+    private flushWebSocketCommands;
+    private matchesRouteMatcher;
+    private matchesHarRouteMatcher;
+    private tryParseUrl;
+    private baseURL;
+    private remainingTimeout;
+    private raceAgainstPageClose;
+    private createClosedError;
+    private locatorKey;
+    private waitForLocatorToHide;
+    private routeMatcherKey;
+    private maybeResolvePickLocator;
+    private showHighlight;
+    private prepareScreenshotBackground;
+}
+export {};
+//# sourceMappingURL=page.d.ts.map