selenium-webdriver 4.44.0 → 4.45.0

package/bidi/generated/browsing_context.d.ts

@@ -0,0 +1,394 @@
+import type { BrowserClientWindow, BrowserUserContext } from './browser.js';
+import type { EmptyResult, JsInt, JsUint } from './common.js';
+import type { ScriptNodeRemoteValue, ScriptSerializationOptions, ScriptSharedReference } from './script.js';
+import type { SessionUserPromptHandlerType } from './session.js';
+export type BrowsingContextCommand = BrowsingContextActivate | BrowsingContextCaptureScreenshot | BrowsingContextClose | BrowsingContextCreate | BrowsingContextGetTree | BrowsingContextHandleUserPrompt | BrowsingContextLocateNodes | BrowsingContextNavigate | BrowsingContextPrint | BrowsingContextReload | BrowsingContextSetBypassCsp | BrowsingContextSetViewport | BrowsingContextTraverseHistory;
+export type BrowsingContextResult = BrowsingContextActivateResult | BrowsingContextCaptureScreenshotResult | BrowsingContextCloseResult | BrowsingContextCreateResult | BrowsingContextGetTreeResult | BrowsingContextHandleUserPromptResult | BrowsingContextLocateNodesResult | BrowsingContextNavigateResult | BrowsingContextPrintResult | BrowsingContextReloadResult | BrowsingContextSetBypassCspResult | BrowsingContextSetViewportResult | BrowsingContextTraverseHistoryResult;
+export type BrowsingContextEvent = BrowsingContextContextCreated | BrowsingContextContextDestroyed | BrowsingContextDomContentLoaded | BrowsingContextDownloadEnd | BrowsingContextDownloadWillBegin | BrowsingContextFragmentNavigated | BrowsingContextHistoryUpdated | BrowsingContextLoad | BrowsingContextNavigationAborted | BrowsingContextNavigationCommitted | BrowsingContextNavigationFailed | BrowsingContextNavigationStarted | BrowsingContextUserPromptClosed | BrowsingContextUserPromptOpened;
+export type BrowsingContextBrowsingContext = string;
+export type BrowsingContextInfoList = BrowsingContextInfo[];
+export interface BrowsingContextInfo {
+    children: BrowsingContextInfoList | null;
+    clientWindow: BrowserClientWindow;
+    context: BrowsingContextBrowsingContext;
+    originalOpener: BrowsingContextBrowsingContext | null;
+    url: string;
+    userContext: BrowserUserContext;
+    parent?: BrowsingContextBrowsingContext | null;
+}
+export type BrowsingContextLocator = BrowsingContextAccessibilityLocator | BrowsingContextCssLocator | BrowsingContextContextLocator | BrowsingContextInnerTextLocator | BrowsingContextXPathLocator;
+export interface BrowsingContextAccessibilityLocator {
+    type: "accessibility";
+    value: {
+        name?: string;
+        role?: string;
+    };
+}
+export interface BrowsingContextCssLocator {
+    type: "css";
+    value: string;
+}
+export interface BrowsingContextContextLocator {
+    type: "context";
+    value: {
+        context: BrowsingContextBrowsingContext;
+    };
+}
+export interface BrowsingContextInnerTextLocator {
+    type: "innerText";
+    value: string;
+    ignoreCase?: boolean;
+    matchType?: "full" | "partial";
+    maxDepth?: JsUint;
+}
+export interface BrowsingContextXPathLocator {
+    type: "xpath";
+    value: string;
+}
+export type BrowsingContextNavigation = string;
+export interface BrowsingContextBaseNavigationInfo {
+    context: BrowsingContextBrowsingContext;
+    navigation: BrowsingContextNavigation | null;
+    timestamp: JsUint;
+    url: string;
+    userContext?: BrowserUserContext;
+}
+export type BrowsingContextNavigationInfo = BrowsingContextBaseNavigationInfo;
+export type BrowsingContextReadinessState = "none" | "interactive" | "complete";
+export type BrowsingContextUserPromptType = "alert" | "beforeunload" | "confirm" | "prompt";
+export interface BrowsingContextActivate {
+    method: "browsingContext.activate";
+    params: BrowsingContextActivateParameters;
+}
+export interface BrowsingContextActivateParameters {
+    context: BrowsingContextBrowsingContext;
+}
+export type BrowsingContextActivateResult = EmptyResult;
+export interface BrowsingContextCaptureScreenshot {
+    method: "browsingContext.captureScreenshot";
+    params: BrowsingContextCaptureScreenshotParameters;
+}
+export interface BrowsingContextCaptureScreenshotParameters {
+    context: BrowsingContextBrowsingContext;
+    /**
+     * @default 'viewport'
+     */
+    origin?: "viewport" | "document";
+    format?: BrowsingContextImageFormat;
+    clip?: BrowsingContextClipRectangle;
+}
+export interface BrowsingContextImageFormat {
+    type: string;
+    quality?: number;
+}
+export type BrowsingContextClipRectangle = BrowsingContextBoxClipRectangle | BrowsingContextElementClipRectangle;
+export interface BrowsingContextElementClipRectangle {
+    type: "element";
+    element: ScriptSharedReference;
+}
+export interface BrowsingContextBoxClipRectangle {
+    type: "box";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface BrowsingContextCaptureScreenshotResult {
+    data: string;
+}
+export interface BrowsingContextClose {
+    method: "browsingContext.close";
+    params: BrowsingContextCloseParameters;
+}
+export interface BrowsingContextCloseParameters {
+    context: BrowsingContextBrowsingContext;
+    promptUnload?: boolean;
+}
+export type BrowsingContextCloseResult = EmptyResult;
+export interface BrowsingContextCreate {
+    method: "browsingContext.create";
+    params: BrowsingContextCreateParameters;
+}
+export type BrowsingContextCreateType = "tab" | "window";
+export interface BrowsingContextCreateParameters {
+    type: BrowsingContextCreateType;
+    referenceContext?: BrowsingContextBrowsingContext;
+    background?: boolean;
+    userContext?: BrowserUserContext;
+}
+export interface BrowsingContextCreateResult {
+    context: BrowsingContextBrowsingContext;
+    userContext?: BrowserUserContext;
+}
+export interface BrowsingContextGetTree {
+    method: "browsingContext.getTree";
+    params: BrowsingContextGetTreeParameters;
+}
+export interface BrowsingContextGetTreeParameters {
+    maxDepth?: JsUint;
+    root?: BrowsingContextBrowsingContext;
+}
+export interface BrowsingContextGetTreeResult {
+    contexts: BrowsingContextInfoList;
+}
+export interface BrowsingContextHandleUserPrompt {
+    method: "browsingContext.handleUserPrompt";
+    params: BrowsingContextHandleUserPromptParameters;
+}
+export interface BrowsingContextHandleUserPromptParameters {
+    context: BrowsingContextBrowsingContext;
+    accept?: boolean;
+    userText?: string;
+}
+export type BrowsingContextHandleUserPromptResult = EmptyResult;
+export interface BrowsingContextLocateNodes {
+    method: "browsingContext.locateNodes";
+    params: BrowsingContextLocateNodesParameters;
+}
+export interface BrowsingContextLocateNodesParameters {
+    context: BrowsingContextBrowsingContext;
+    locator: BrowsingContextLocator;
+    maxNodeCount?: JsUint;
+    serializationOptions?: ScriptSerializationOptions;
+    startNodes?: ScriptSharedReference[];
+}
+export interface BrowsingContextLocateNodesResult {
+    nodes: ScriptNodeRemoteValue[];
+}
+export interface BrowsingContextNavigate {
+    method: "browsingContext.navigate";
+    params: BrowsingContextNavigateParameters;
+}
+export interface BrowsingContextNavigateParameters {
+    context: BrowsingContextBrowsingContext;
+    url: string;
+    wait?: BrowsingContextReadinessState;
+}
+export interface BrowsingContextNavigateResult {
+    navigation: BrowsingContextNavigation | null;
+    url: string;
+}
+export interface BrowsingContextPrint {
+    method: "browsingContext.print";
+    params: BrowsingContextPrintParameters;
+}
+export interface BrowsingContextPrintParameters {
+    context: BrowsingContextBrowsingContext;
+    background?: boolean;
+    margin?: BrowsingContextPrintMarginParameters;
+    /**
+     * @default 'portrait'
+     */
+    orientation?: "portrait" | "landscape";
+    page?: BrowsingContextPrintPageParameters;
+    pageRanges?: (JsUint | string)[];
+    /**
+     * @default 1
+     */
+    scale?: number;
+    /**
+     * @default true
+     */
+    shrinkToFit?: boolean;
+}
+export interface BrowsingContextPrintMarginParameters {
+    /**
+     * @default 1
+     */
+    bottom?: number;
+    /**
+     * @default 1
+     */
+    left?: number;
+    /**
+     * @default 1
+     */
+    right?: number;
+    /**
+     * @default 1
+     */
+    top?: number;
+}
+export interface BrowsingContextPrintPageParameters {
+    /**
+     * @default 27.94
+     */
+    height?: number;
+    /**
+     * @default 21.59
+     */
+    width?: number;
+}
+export interface BrowsingContextPrintResult {
+    data: string;
+}
+export interface BrowsingContextReload {
+    method: "browsingContext.reload";
+    params: BrowsingContextReloadParameters;
+}
+export interface BrowsingContextReloadParameters {
+    context: BrowsingContextBrowsingContext;
+    ignoreCache?: boolean;
+    wait?: BrowsingContextReadinessState;
+}
+export type BrowsingContextReloadResult = BrowsingContextNavigateResult;
+export interface BrowsingContextSetBypassCsp {
+    method: "browsingContext.setBypassCSP";
+    params: BrowsingContextSetBypassCspParameters;
+}
+export interface BrowsingContextSetBypassCspParameters {
+    bypass: true | null;
+    contexts?: BrowsingContextBrowsingContext[];
+    userContexts?: BrowserUserContext[];
+}
+export type BrowsingContextSetBypassCspResult = EmptyResult;
+export interface BrowsingContextSetViewport {
+    method: "browsingContext.setViewport";
+    params: BrowsingContextSetViewportParameters;
+}
+export interface BrowsingContextSetViewportParameters {
+    context?: BrowsingContextBrowsingContext;
+    viewport?: BrowsingContextViewport | null;
+    devicePixelRatio?: number | null;
+    userContexts?: BrowserUserContext[];
+}
+export interface BrowsingContextViewport {
+    width: JsUint;
+    height: JsUint;
+}
+export type BrowsingContextSetViewportResult = EmptyResult;
+export interface BrowsingContextTraverseHistory {
+    method: "browsingContext.traverseHistory";
+    params: BrowsingContextTraverseHistoryParameters;
+}
+export interface BrowsingContextTraverseHistoryParameters {
+    context: BrowsingContextBrowsingContext;
+    delta: JsInt;
+}
+export type BrowsingContextTraverseHistoryResult = EmptyResult;
+export interface BrowsingContextContextCreated {
+    method: "browsingContext.contextCreated";
+    params: BrowsingContextInfo;
+}
+export interface BrowsingContextContextDestroyed {
+    method: "browsingContext.contextDestroyed";
+    params: BrowsingContextInfo;
+}
+export interface BrowsingContextNavigationStarted {
+    method: "browsingContext.navigationStarted";
+    params: BrowsingContextNavigationInfo;
+}
+export interface BrowsingContextFragmentNavigated {
+    method: "browsingContext.fragmentNavigated";
+    params: BrowsingContextNavigationInfo;
+}
+export interface BrowsingContextHistoryUpdated {
+    method: "browsingContext.historyUpdated";
+    params: BrowsingContextHistoryUpdatedParameters;
+}
+export interface BrowsingContextHistoryUpdatedParameters {
+    context: BrowsingContextBrowsingContext;
+    timestamp: JsUint;
+    url: string;
+    userContext?: BrowserUserContext;
+}
+export interface BrowsingContextDomContentLoaded {
+    method: "browsingContext.domContentLoaded";
+    params: BrowsingContextNavigationInfo;
+}
+export interface BrowsingContextLoad {
+    method: "browsingContext.load";
+    params: BrowsingContextNavigationInfo;
+}
+export interface BrowsingContextDownloadWillBegin {
+    method: "browsingContext.downloadWillBegin";
+    params: BrowsingContextDownloadWillBeginParams;
+}
+export type BrowsingContextDownloadWillBeginParams = BrowsingContextBaseNavigationInfo & {
+    suggestedFilename: string;
+};
+export interface BrowsingContextDownloadEnd {
+    method: "browsingContext.downloadEnd";
+    params: BrowsingContextDownloadEndParams;
+}
+export type BrowsingContextDownloadEndParams = (BrowsingContextDownloadCanceledParams | BrowsingContextDownloadCompleteParams);
+export type BrowsingContextDownloadCanceledParams = BrowsingContextBaseNavigationInfo & {
+    status: "canceled";
+};
+export type BrowsingContextDownloadCompleteParams = BrowsingContextBaseNavigationInfo & {
+    status: "complete";
+    filepath: string | null;
+};
+export interface BrowsingContextNavigationAborted {
+    method: "browsingContext.navigationAborted";
+    params: BrowsingContextNavigationInfo;
+}
+export interface BrowsingContextNavigationCommitted {
+    method: "browsingContext.navigationCommitted";
+    params: BrowsingContextNavigationInfo;
+}
+export interface BrowsingContextNavigationFailed {
+    method: "browsingContext.navigationFailed";
+    params: BrowsingContextNavigationInfo;
+}
+export interface BrowsingContextUserPromptClosed {
+    method: "browsingContext.userPromptClosed";
+    params: BrowsingContextUserPromptClosedParameters;
+}
+export interface BrowsingContextUserPromptClosedParameters {
+    context: BrowsingContextBrowsingContext;
+    accepted: boolean;
+    type: BrowsingContextUserPromptType;
+    userContext?: BrowserUserContext;
+    userText?: string;
+}
+export interface BrowsingContextUserPromptOpened {
+    method: "browsingContext.userPromptOpened";
+    params: BrowsingContextUserPromptOpenedParameters;
+}
+export interface BrowsingContextUserPromptOpenedParameters {
+    context: BrowsingContextBrowsingContext;
+    handler: SessionUserPromptHandlerType;
+    message: string;
+    type: BrowsingContextUserPromptType;
+    userContext?: BrowserUserContext;
+    defaultValue?: string;
+}
+/** @deprecated Use {@link BrowsingContext.create} instead — will be removed in a future major version. */
+export declare function getBrowsingContextInstance(driver: unknown): Promise<BrowsingContext>;
+export declare class BrowsingContext {
+    private readonly bidi;
+    private constructor();
+    static create(driver: unknown): Promise<BrowsingContext>;
+    activate(params: BrowsingContextActivateParameters): Promise<void>;
+    captureScreenshot(params: BrowsingContextCaptureScreenshotParameters): Promise<BrowsingContextCaptureScreenshotResult>;
+    close(params: BrowsingContextCloseParameters): Promise<void>;
+    create(params: BrowsingContextCreateParameters): Promise<BrowsingContextCreateResult>;
+    getTree(params: BrowsingContextGetTreeParameters): Promise<BrowsingContextGetTreeResult>;
+    handleUserPrompt(params: BrowsingContextHandleUserPromptParameters): Promise<void>;
+    locateNodes(params: BrowsingContextLocateNodesParameters): Promise<BrowsingContextLocateNodesResult>;
+    navigate(params: BrowsingContextNavigateParameters): Promise<BrowsingContextNavigateResult>;
+    print(params: BrowsingContextPrintParameters): Promise<BrowsingContextPrintResult>;
+    reload(params: BrowsingContextReloadParameters): Promise<BrowsingContextReloadResult>;
+    setBypassCSP(params: BrowsingContextSetBypassCspParameters): Promise<void>;
+    setViewport(params: BrowsingContextSetViewportParameters): Promise<void>;
+    traverseHistory(params: BrowsingContextTraverseHistoryParameters): Promise<void>;
+    onContextCreated(callback: (params: BrowsingContextInfo) => void): Promise<void>;
+    onContextDestroyed(callback: (params: BrowsingContextInfo) => void): Promise<void>;
+    onDomContentLoaded(callback: (params: BrowsingContextNavigationInfo) => void): Promise<void>;
+    onDownloadEnd(callback: (params: BrowsingContextDownloadEndParams) => void): Promise<void>;
+    onDownloadWillBegin(callback: (params: BrowsingContextDownloadWillBeginParams) => void): Promise<void>;
+    onFragmentNavigated(callback: (params: BrowsingContextNavigationInfo) => void): Promise<void>;
+    onHistoryUpdated(callback: (params: BrowsingContextHistoryUpdatedParameters) => void): Promise<void>;
+    onLoad(callback: (params: BrowsingContextNavigationInfo) => void): Promise<void>;
+    onNavigationAborted(callback: (params: BrowsingContextNavigationInfo) => void): Promise<void>;
+    onNavigationCommitted(callback: (params: BrowsingContextNavigationInfo) => void): Promise<void>;
+    onNavigationFailed(callback: (params: BrowsingContextNavigationInfo) => void): Promise<void>;
+    onNavigationStarted(callback: (params: BrowsingContextNavigationInfo) => void): Promise<void>;
+    onUserPromptClosed(callback: (params: BrowsingContextUserPromptClosedParameters) => void): Promise<void>;
+    onUserPromptOpened(callback: (params: BrowsingContextUserPromptOpenedParameters) => void): Promise<void>;
+    back(context: BrowsingContextBrowsingContext): Promise<void>;
+    forward(context: BrowsingContextBrowsingContext): Promise<void>;
+    getTopLevelContexts(): Promise<BrowsingContextGetTreeResult>;
+    printPage(params: BrowsingContextPrintParameters): Promise<BrowsingContextPrintResult>;
+}

package/bidi/generated/browsing_context.js

@@ -0,0 +1,260 @@
+"use strict";
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowsingContext = exports.getBrowsingContextInstance = void 0;
+// --- Additional Types ---
+/** @deprecated Use {@link BrowsingContext.create} instead — will be removed in a future major version. */
+async function getBrowsingContextInstance(driver) {
+    return BrowsingContext.create(driver);
+}
+exports.getBrowsingContextInstance = getBrowsingContextInstance;
+// --- Implementation ---
+class BrowsingContext {
+    constructor(bidi) {
+        this.bidi = bidi;
+    }
+    static async create(driver) {
+        const caps = await driver.getCapabilities();
+        if (!caps.get('webSocketUrl')) {
+            throw new Error('WebDriver instance must support BiDi protocol');
+        }
+        const bidi = await driver.getBidi();
+        return new BrowsingContext(bidi);
+    }
+    async activate(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.activate',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async captureScreenshot(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.captureScreenshot',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async close(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.close',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async create(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.create',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async getTree(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.getTree',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async handleUserPrompt(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.handleUserPrompt',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async locateNodes(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.locateNodes',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async navigate(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.navigate',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async print(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.print',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async reload(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.reload',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async setBypassCSP(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.setBypassCSP',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async setViewport(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.setViewport',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async traverseHistory(params) {
+        const response = await this.bidi.send({
+            method: 'browsingContext.traverseHistory',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async onContextCreated(callback) {
+        await this.bidi.subscribe('browsingContext.contextCreated');
+        this.bidi.on('browsingContext.contextCreated', (params) => {
+            callback(params);
+        });
+    }
+    async onContextDestroyed(callback) {
+        await this.bidi.subscribe('browsingContext.contextDestroyed');
+        this.bidi.on('browsingContext.contextDestroyed', (params) => {
+            callback(params);
+        });
+    }
+    async onDomContentLoaded(callback) {
+        await this.bidi.subscribe('browsingContext.domContentLoaded');
+        this.bidi.on('browsingContext.domContentLoaded', (params) => {
+            callback(params);
+        });
+    }
+    async onDownloadEnd(callback) {
+        await this.bidi.subscribe('browsingContext.downloadEnd');
+        this.bidi.on('browsingContext.downloadEnd', (params) => {
+            callback(params);
+        });
+    }
+    async onDownloadWillBegin(callback) {
+        await this.bidi.subscribe('browsingContext.downloadWillBegin');
+        this.bidi.on('browsingContext.downloadWillBegin', (params) => {
+            callback(params);
+        });
+    }
+    async onFragmentNavigated(callback) {
+        await this.bidi.subscribe('browsingContext.fragmentNavigated');
+        this.bidi.on('browsingContext.fragmentNavigated', (params) => {
+            callback(params);
+        });
+    }
+    async onHistoryUpdated(callback) {
+        await this.bidi.subscribe('browsingContext.historyUpdated');
+        this.bidi.on('browsingContext.historyUpdated', (params) => {
+            callback(params);
+        });
+    }
+    async onLoad(callback) {
+        await this.bidi.subscribe('browsingContext.load');
+        this.bidi.on('browsingContext.load', (params) => {
+            callback(params);
+        });
+    }
+    async onNavigationAborted(callback) {
+        await this.bidi.subscribe('browsingContext.navigationAborted');
+        this.bidi.on('browsingContext.navigationAborted', (params) => {
+            callback(params);
+        });
+    }
+    async onNavigationCommitted(callback) {
+        await this.bidi.subscribe('browsingContext.navigationCommitted');
+        this.bidi.on('browsingContext.navigationCommitted', (params) => {
+            callback(params);
+        });
+    }
+    async onNavigationFailed(callback) {
+        await this.bidi.subscribe('browsingContext.navigationFailed');
+        this.bidi.on('browsingContext.navigationFailed', (params) => {
+            callback(params);
+        });
+    }
+    async onNavigationStarted(callback) {
+        await this.bidi.subscribe('browsingContext.navigationStarted');
+        this.bidi.on('browsingContext.navigationStarted', (params) => {
+            callback(params);
+        });
+    }
+    async onUserPromptClosed(callback) {
+        await this.bidi.subscribe('browsingContext.userPromptClosed');
+        this.bidi.on('browsingContext.userPromptClosed', (params) => {
+            callback(params);
+        });
+    }
+    async onUserPromptOpened(callback) {
+        await this.bidi.subscribe('browsingContext.userPromptOpened');
+        this.bidi.on('browsingContext.userPromptOpened', (params) => {
+            callback(params);
+        });
+    }
+    async back(context) {
+        await this.traverseHistory({ context, delta: -1 });
+    }
+    async forward(context) {
+        await this.traverseHistory({ context, delta: 1 });
+    }
+    async getTopLevelContexts() {
+        return this.getTree({});
+    }
+    async printPage(params) {
+        return this.print(params);
+    }
+}
+exports.BrowsingContext = BrowsingContext;

package/bidi/generated/common.d.ts

@@ -0,0 +1,38 @@
+import type { BrowserCommand, BrowserResult } from './browser.js';
+import type { BrowsingContextCommand, BrowsingContextEvent, BrowsingContextResult } from './browsing_context.js';
+import type { EmulationCommand, EmulationResult } from './emulation.js';
+import type { InputCommand, InputEvent, InputResult } from './input.js';
+import type { LogEvent } from './log.js';
+import type { NetworkCommand, NetworkEvent, NetworkResult } from './network.js';
+import type { ScriptCommand, ScriptEvent, ScriptResult } from './script.js';
+import type { SessionCommand, SessionResult } from './session.js';
+import type { StorageCommand, StorageResult } from './storage.js';
+import type { WebExtensionCommand, WebExtensionResult } from './webextension.js';
+export type Command = CommandData & Extensible & {
+    id: JsUint;
+};
+export type CommandData = BrowserCommand | BrowsingContextCommand | EmulationCommand | InputCommand | NetworkCommand | ScriptCommand | SessionCommand | StorageCommand | WebExtensionCommand;
+export type EmptyParams = Extensible;
+export type Message = CommandResponse | ErrorResponse | Event;
+export type CommandResponse = Extensible & {
+    type: "success";
+    id: JsUint;
+    result: ResultData;
+};
+export type ErrorResponse = Extensible & {
+    type: "error";
+    id: JsUint | null;
+    error: ErrorCode;
+    message: string;
+    stacktrace?: string;
+};
+export type ResultData = BrowserResult | BrowsingContextResult | EmulationResult | InputResult | NetworkResult | ScriptResult | SessionResult | StorageResult | WebExtensionResult;
+export type EmptyResult = Extensible;
+export type Event = EventData & Extensible & {
+    type: "event";
+};
+export type EventData = BrowsingContextEvent | InputEvent | LogEvent | NetworkEvent | ScriptEvent;
+export type Extensible = Record<string, unknown>;
+export type JsInt = number;
+export type JsUint = number;
+export type ErrorCode = "invalid argument" | "invalid selector" | "invalid session id" | "invalid web extension" | "move target out of bounds" | "no such alert" | "no such network collector" | "no such element" | "no such frame" | "no such handle" | "no such history entry" | "no such intercept" | "no such network data" | "no such node" | "no such request" | "no such script" | "no such storage partition" | "no such user context" | "no such web extension" | "session not created" | "unable to capture screen" | "unable to close browser" | "unable to set cookie" | "unable to set file input" | "unavailable network data" | "underspecified storage partition" | "unknown command" | "unknown error" | "unsupported operation";