selenium-webdriver 4.44.0 → 4.46.0

package/CHANGES.md

@@ -1,3 +1,23 @@
+## 4.46.0
+
+- Support CDP versions: v148, v149, v150
+- Add binding-neutral BiDi schema with cddl2ts-gated fidelity (#17700)
+- Update cddl to 0.21.0 to fix quoted reserved-word parsing in BiDi codegen (#17752)
+- Add guidance for testing conventions in each language (#16734)
+
+## 4.45.0
+
+- Support CDP versions: v147, v148, v149
+- update vulnerable dependency with a range (#17466)
+- update dev dependencies (#17479)
+- update eslint to v10 with fixes (#17482)
+- Use the typescript atom for get attribute (#17526)
+- Move JS bindings to use typescript atoms for isDisplayed and Find-Element (#17547)
+- trim agent formatting guidance (#17617)
+- [build] Automated Browser Version Update (#17609)
+- Add Javascript/Typescript CDDL code generator for WebDriver BiDi (#17574)
+- Expose BiDi CDDL ast and model as shared artifacts (#17657)
+
 ## 4.44.0
 
 - Support CDP versions: v146, v147, v148

package/bidi/browsingContextInspector.js

@@ -124,7 +124,7 @@ class BrowsingContextInspector {
     this.ws.on('message', (event) => {
       const { params } = JSON.parse(Buffer.from(event.toString()))
       if (params) {
-        let response = null
+        let response
         if ('navigation' in params) {
           response = new NavigationInfo(params.context, params.navigation, params.timestamp, params.url)
         } else if ('accepted' in params) {

package/bidi/generated/bluetooth.d.ts

@@ -0,0 +1,223 @@
+export type BluetoothBluetoothUuid = string;
+export interface BluetoothBluetoothManufacturerData {
+    key: number;
+    data: string;
+}
+export interface BluetoothCharacteristicProperties {
+    broadcast?: boolean;
+    read?: boolean;
+    writeWithoutResponse?: boolean;
+    write?: boolean;
+    notify?: boolean;
+    indicate?: boolean;
+    authenticatedSignedWrites?: boolean;
+    extendedProperties?: boolean;
+}
+export type BluetoothRequestDevice = string;
+export interface BluetoothRequestDeviceInfo {
+    id: BluetoothRequestDevice;
+    name: string | null;
+}
+export type BluetoothRequestDevicePrompt = string;
+export interface BluetoothScanRecord {
+    name?: string;
+    uuids?: BluetoothBluetoothUuid[];
+    appearance?: Number;
+    manufacturerData?: BluetoothBluetoothManufacturerData[];
+}
+export type BluetoothCommand = BluetoothHandleRequestDevicePrompt | BluetoothSimulateAdapter | BluetoothDisableSimulation | BluetoothSimulatePreconnectedPeripheral | BluetoothSimulateAdvertisement | BluetoothSimulateGattConnectionResponse | BluetoothSimulateGattDisconnection | BluetoothSimulateService | BluetoothSimulateCharacteristic | BluetoothSimulateCharacteristicResponse | BluetoothSimulateDescriptor | BluetoothSimulateDescriptorResponse;
+export interface BluetoothHandleRequestDevicePrompt {
+    method: "bluetooth.handleRequestDevicePrompt";
+    params: BluetoothHandleRequestDevicePromptParameters;
+}
+export type BluetoothHandleRequestDevicePromptParameters = (BluetoothHandleRequestDevicePromptAcceptParameters | BluetoothHandleRequestDevicePromptCancelParameters) & {
+    context: string;
+    prompt: BluetoothRequestDevicePrompt;
+};
+export interface BluetoothHandleRequestDevicePromptAcceptParameters {
+    accept: true;
+    device: BluetoothRequestDevice;
+}
+export interface BluetoothHandleRequestDevicePromptCancelParameters {
+    accept: false;
+}
+export interface BluetoothSimulateAdapter {
+    method: "bluetooth.simulateAdapter";
+    params: BluetoothSimulateAdapterParameters;
+}
+export interface BluetoothSimulateAdapterParameters {
+    context: string;
+    leSupported?: boolean;
+    state: "absent" | "powered-off" | "powered-on";
+}
+export interface BluetoothDisableSimulation {
+    method: "bluetooth.disableSimulation";
+    params: BluetoothDisableSimulationParameters;
+}
+export interface BluetoothDisableSimulationParameters {
+    context: string;
+}
+export interface BluetoothSimulatePreconnectedPeripheral {
+    method: "bluetooth.simulatePreconnectedPeripheral";
+    params: BluetoothSimulatePreconnectedPeripheralParameters;
+}
+export interface BluetoothSimulatePreconnectedPeripheralParameters {
+    context: string;
+    address: string;
+    name: string;
+    manufacturerData: BluetoothBluetoothManufacturerData[];
+    knownServiceUuids: BluetoothBluetoothUuid[];
+}
+export interface BluetoothSimulateAdvertisement {
+    method: "bluetooth.simulateAdvertisement";
+    params: BluetoothSimulateAdvertisementParameters;
+}
+export interface BluetoothSimulateAdvertisementParameters {
+    context: string;
+    scanEntry: BluetoothSimulateAdvertisementScanEntryParameters;
+}
+export interface BluetoothSimulateAdvertisementScanEntryParameters {
+    deviceAddress: string;
+    rssi: Number;
+    scanRecord: BluetoothScanRecord;
+}
+export interface BluetoothSimulateGattConnectionResponse {
+    method: "bluetooth.simulateGattConnectionResponse";
+    params: BluetoothSimulateGattConnectionResponseParameters;
+}
+export interface BluetoothSimulateGattConnectionResponseParameters {
+    context: string;
+    address: string;
+    code: number;
+}
+export interface BluetoothSimulateGattDisconnection {
+    method: "bluetooth.simulateGattDisconnection";
+    params: BluetoothSimulateGattDisconnectionParameters;
+}
+export interface BluetoothSimulateGattDisconnectionParameters {
+    context: string;
+    address: string;
+}
+export interface BluetoothSimulateService {
+    method: "bluetooth.simulateService";
+    params: BluetoothSimulateServiceParameters;
+}
+export interface BluetoothSimulateServiceParameters {
+    context: string;
+    address: string;
+    uuid: BluetoothBluetoothUuid;
+    type: "add" | "remove";
+}
+export interface BluetoothSimulateCharacteristic {
+    method: "bluetooth.simulateCharacteristic";
+    params: BluetoothSimulateCharacteristicParameters;
+}
+export interface BluetoothSimulateCharacteristicParameters {
+    context: string;
+    address: string;
+    serviceUuid: BluetoothBluetoothUuid;
+    characteristicUuid: BluetoothBluetoothUuid;
+    characteristicProperties?: BluetoothCharacteristicProperties;
+    type: "add" | "remove";
+}
+export interface BluetoothSimulateCharacteristicResponse {
+    method: "bluetooth.simulateCharacteristicResponse";
+    params: BluetoothSimulateCharacteristicResponseParameters;
+}
+export interface BluetoothSimulateCharacteristicResponseParameters {
+    context: string;
+    address: string;
+    serviceUuid: BluetoothBluetoothUuid;
+    characteristicUuid: BluetoothBluetoothUuid;
+    type: "read" | "write" | "subscribe-to-notifications" | "unsubscribe-from-notifications";
+    code: number;
+    data?: number[];
+}
+export interface BluetoothSimulateDescriptor {
+    method: "bluetooth.simulateDescriptor";
+    params: BluetoothSimulateDescriptorParameters;
+}
+export interface BluetoothSimulateDescriptorParameters {
+    context: string;
+    address: string;
+    serviceUuid: BluetoothBluetoothUuid;
+    characteristicUuid: BluetoothBluetoothUuid;
+    descriptorUuid: BluetoothBluetoothUuid;
+    type: "add" | "remove";
+}
+export interface BluetoothSimulateDescriptorResponse {
+    method: "bluetooth.simulateDescriptorResponse";
+    params: BluetoothSimulateDescriptorResponseParameters;
+}
+export interface BluetoothSimulateDescriptorResponseParameters {
+    context: string;
+    address: string;
+    serviceUuid: BluetoothBluetoothUuid;
+    characteristicUuid: BluetoothBluetoothUuid;
+    descriptorUuid: BluetoothBluetoothUuid;
+    type: "read" | "write";
+    code: number;
+    data?: number[];
+}
+export type BluetoothEvent = BluetoothRequestDevicePromptUpdated | BluetoothGattConnectionAttempted;
+export interface BluetoothRequestDevicePromptUpdated {
+    method: "bluetooth.requestDevicePromptUpdated";
+    params: BluetoothRequestDevicePromptUpdatedParameters;
+}
+export interface BluetoothRequestDevicePromptUpdatedParameters {
+    context: string;
+    prompt: BluetoothRequestDevicePrompt;
+    devices: BluetoothRequestDeviceInfo[];
+}
+export interface BluetoothGattConnectionAttempted {
+    method: "bluetooth.gattConnectionAttempted";
+    params: BluetoothGattConnectionAttemptedParameters;
+}
+export interface BluetoothGattConnectionAttemptedParameters {
+    context: string;
+    address: string;
+}
+export interface BluetoothCharacteristicEventGenerated {
+    method: "bluetooth.characteristicEventGenerated";
+    params: BluetoothCharacteristicEventGeneratedParameters;
+}
+export interface BluetoothCharacteristicEventGeneratedParameters {
+    context: string;
+    address: string;
+    serviceUuid: BluetoothBluetoothUuid;
+    characteristicUuid: BluetoothBluetoothUuid;
+    type: "read" | "write-with-response" | "write-without-response" | "subscribe-to-notifications" | "unsubscribe-from-notifications";
+    data?: number[];
+}
+export interface BluetoothDescriptorEventGenerated {
+    method: "bluetooth.descriptorEventGenerated";
+    params: BluetoothDescriptorEventGeneratedParameters;
+}
+export interface BluetoothDescriptorEventGeneratedParameters {
+    context: string;
+    address: string;
+    serviceUuid: BluetoothBluetoothUuid;
+    characteristicUuid: BluetoothBluetoothUuid;
+    descriptorUuid: BluetoothBluetoothUuid;
+    type: "read" | "write";
+    data?: number[];
+}
+export declare class Bluetooth {
+    private readonly bidi;
+    private constructor();
+    static create(driver: unknown): Promise<Bluetooth>;
+    handleRequestDevicePrompt(params: BluetoothHandleRequestDevicePromptParameters): Promise<void>;
+    simulateAdapter(params: BluetoothSimulateAdapterParameters): Promise<void>;
+    disableSimulation(params: BluetoothDisableSimulationParameters): Promise<void>;
+    simulatePreconnectedPeripheral(params: BluetoothSimulatePreconnectedPeripheralParameters): Promise<void>;
+    simulateAdvertisement(params: BluetoothSimulateAdvertisementParameters): Promise<void>;
+    simulateGattConnectionResponse(params: BluetoothSimulateGattConnectionResponseParameters): Promise<void>;
+    simulateGattDisconnection(params: BluetoothSimulateGattDisconnectionParameters): Promise<void>;
+    simulateService(params: BluetoothSimulateServiceParameters): Promise<void>;
+    simulateCharacteristic(params: BluetoothSimulateCharacteristicParameters): Promise<void>;
+    simulateCharacteristicResponse(params: BluetoothSimulateCharacteristicResponseParameters): Promise<void>;
+    simulateDescriptor(params: BluetoothSimulateDescriptorParameters): Promise<void>;
+    simulateDescriptorResponse(params: BluetoothSimulateDescriptorResponseParameters): Promise<void>;
+    onRequestDevicePromptUpdated(callback: (params: BluetoothRequestDevicePromptUpdatedParameters) => void): Promise<void>;
+    onGattConnectionAttempted(callback: (params: BluetoothGattConnectionAttemptedParameters) => void): Promise<void>;
+}

package/bidi/generated/bluetooth.js

@@ -0,0 +1,154 @@
+"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.Bluetooth = void 0;
+// --- Implementation ---
+class Bluetooth {
+    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 Bluetooth(bidi);
+    }
+    async handleRequestDevicePrompt(params) {
+        const response = await this.bidi.send({
+            method: 'bluetooth.handleRequestDevicePrompt',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async simulateAdapter(params) {
+        const response = await this.bidi.send({
+            method: 'bluetooth.simulateAdapter',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async disableSimulation(params) {
+        const response = await this.bidi.send({
+            method: 'bluetooth.disableSimulation',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async simulatePreconnectedPeripheral(params) {
+        const response = await this.bidi.send({
+            method: 'bluetooth.simulatePreconnectedPeripheral',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async simulateAdvertisement(params) {
+        const response = await this.bidi.send({
+            method: 'bluetooth.simulateAdvertisement',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async simulateGattConnectionResponse(params) {
+        const response = await this.bidi.send({
+            method: 'bluetooth.simulateGattConnectionResponse',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async simulateGattDisconnection(params) {
+        const response = await this.bidi.send({
+            method: 'bluetooth.simulateGattDisconnection',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async simulateService(params) {
+        const response = await this.bidi.send({
+            method: 'bluetooth.simulateService',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async simulateCharacteristic(params) {
+        const response = await this.bidi.send({
+            method: 'bluetooth.simulateCharacteristic',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async simulateCharacteristicResponse(params) {
+        const response = await this.bidi.send({
+            method: 'bluetooth.simulateCharacteristicResponse',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async simulateDescriptor(params) {
+        const response = await this.bidi.send({
+            method: 'bluetooth.simulateDescriptor',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async simulateDescriptorResponse(params) {
+        const response = await this.bidi.send({
+            method: 'bluetooth.simulateDescriptorResponse',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async onRequestDevicePromptUpdated(callback) {
+        await this.bidi.subscribe('bluetooth.requestDevicePromptUpdated');
+        this.bidi.on('bluetooth.requestDevicePromptUpdated', (params) => {
+            callback(params);
+        });
+    }
+    async onGattConnectionAttempted(callback) {
+        await this.bidi.subscribe('bluetooth.gattConnectionAttempted');
+        this.bidi.on('bluetooth.gattConnectionAttempted', (params) => {
+            callback(params);
+        });
+    }
+}
+exports.Bluetooth = Bluetooth;

package/bidi/generated/browser.d.ts

@@ -0,0 +1,104 @@
+import type { EmptyParams, EmptyResult, JsInt, JsUint } from './common.js';
+import type { SessionProxyConfiguration, SessionUserPromptHandler } from './session.js';
+export type BrowserCommand = BrowserClose | BrowserCreateUserContext | BrowserGetClientWindows | BrowserGetUserContexts | BrowserRemoveUserContext | BrowserSetClientWindowState | BrowserSetDownloadBehavior;
+export type BrowserResult = BrowserCloseResult | BrowserCreateUserContextResult | BrowserGetClientWindowsResult | BrowserGetUserContextsResult | BrowserRemoveUserContextResult | BrowserSetClientWindowStateResult | BrowserSetDownloadBehaviorResult;
+export type BrowserClientWindow = string;
+export interface BrowserClientWindowInfo {
+    active: boolean;
+    clientWindow: BrowserClientWindow;
+    height: JsUint;
+    state: "fullscreen" | "maximized" | "minimized" | "normal";
+    width: JsUint;
+    x: JsInt;
+    y: JsInt;
+}
+export type BrowserUserContext = string;
+export interface BrowserUserContextInfo {
+    userContext: BrowserUserContext;
+}
+export interface BrowserClose {
+    method: "browser.close";
+    params: EmptyParams;
+}
+export type BrowserCloseResult = EmptyResult;
+export interface BrowserCreateUserContext {
+    method: "browser.createUserContext";
+    params: BrowserCreateUserContextParameters;
+}
+export interface BrowserCreateUserContextParameters {
+    acceptInsecureCerts?: boolean;
+    proxy?: SessionProxyConfiguration;
+    unhandledPromptBehavior?: SessionUserPromptHandler;
+}
+export type BrowserCreateUserContextResult = BrowserUserContextInfo;
+export interface BrowserGetClientWindows {
+    method: "browser.getClientWindows";
+    params: EmptyParams;
+}
+export interface BrowserGetClientWindowsResult {
+    clientWindows: BrowserClientWindowInfo[];
+}
+export interface BrowserGetUserContexts {
+    method: "browser.getUserContexts";
+    params: EmptyParams;
+}
+export interface BrowserGetUserContextsResult {
+    userContexts: BrowserUserContextInfo[];
+}
+export interface BrowserRemoveUserContext {
+    method: "browser.removeUserContext";
+    params: BrowserRemoveUserContextParameters;
+}
+export interface BrowserRemoveUserContextParameters {
+    userContext: BrowserUserContext;
+}
+export type BrowserRemoveUserContextResult = EmptyResult;
+export interface BrowserSetClientWindowState {
+    method: "browser.setClientWindowState";
+    params: BrowserSetClientWindowStateParameters;
+}
+export type BrowserSetClientWindowStateParameters = (BrowserClientWindowNamedState | BrowserClientWindowRectState) & {
+    clientWindow: BrowserClientWindow;
+};
+export interface BrowserClientWindowNamedState {
+    state: "fullscreen" | "maximized" | "minimized";
+}
+export interface BrowserClientWindowRectState {
+    state: "normal";
+    width?: JsUint;
+    height?: JsUint;
+    x?: JsInt;
+    y?: JsInt;
+}
+export type BrowserSetClientWindowStateResult = BrowserClientWindowInfo;
+export interface BrowserSetDownloadBehavior {
+    method: "browser.setDownloadBehavior";
+    params: BrowserSetDownloadBehaviorParameters;
+}
+export interface BrowserSetDownloadBehaviorParameters {
+    downloadBehavior: BrowserDownloadBehavior | null;
+    userContexts?: BrowserUserContext[];
+}
+export type BrowserDownloadBehavior = (BrowserDownloadBehaviorAllowed | BrowserDownloadBehaviorDenied);
+export interface BrowserDownloadBehaviorAllowed {
+    type: "allowed";
+    destinationFolder: string;
+}
+export interface BrowserDownloadBehaviorDenied {
+    type: "denied";
+}
+export type BrowserSetDownloadBehaviorResult = EmptyResult;
+/** @deprecated Use {@link Browser.create} instead — will be removed in a future major version. */
+export declare function getBrowserInstance(driver: unknown): Promise<Browser>;
+export declare class Browser {
+    private readonly bidi;
+    private constructor();
+    static create(driver: unknown): Promise<Browser>;
+    close(): Promise<void>;
+    createUserContext(params: BrowserCreateUserContextParameters): Promise<BrowserCreateUserContextResult>;
+    getClientWindows(): Promise<BrowserGetClientWindowsResult>;
+    getUserContexts(): Promise<BrowserGetUserContextsResult>;
+    removeUserContext(params: BrowserRemoveUserContextParameters): Promise<void>;
+    setClientWindowState(params: BrowserSetClientWindowStateParameters): Promise<BrowserSetClientWindowStateResult>;
+    setDownloadBehavior(params: BrowserSetDownloadBehaviorParameters): Promise<void>;
+}

package/bidi/generated/browser.js

@@ -0,0 +1,107 @@
+"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.Browser = void 0;
+exports.getBrowserInstance = getBrowserInstance;
+// --- Additional Types ---
+/** @deprecated Use {@link Browser.create} instead — will be removed in a future major version. */
+async function getBrowserInstance(driver) {
+    return Browser.create(driver);
+}
+// --- Implementation ---
+class Browser {
+    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 Browser(bidi);
+    }
+    async close() {
+        const response = await this.bidi.send({
+            method: 'browser.close',
+            params: {},
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async createUserContext(params) {
+        const response = await this.bidi.send({
+            method: 'browser.createUserContext',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async getClientWindows() {
+        const response = await this.bidi.send({
+            method: 'browser.getClientWindows',
+            params: {},
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async getUserContexts() {
+        const response = await this.bidi.send({
+            method: 'browser.getUserContexts',
+            params: {},
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async removeUserContext(params) {
+        const response = await this.bidi.send({
+            method: 'browser.removeUserContext',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async setClientWindowState(params) {
+        const response = await this.bidi.send({
+            method: 'browser.setClientWindowState',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async setDownloadBehavior(params) {
+        const response = await this.bidi.send({
+            method: 'browser.setDownloadBehavior',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+}
+exports.Browser = Browser;