selenium-webdriver 4.44.0 → 4.46.0

package/bidi/generated/script.d.ts

@@ -0,0 +1,410 @@
+import type { BrowserUserContext } from './browser.js';
+import type { BrowsingContextBrowsingContext } from './browsing_context.js';
+import type { EmptyResult, Extensible, JsUint } from './common.js';
+export type ScriptCommand = ScriptAddPreloadScript | ScriptCallFunction | ScriptDisown | ScriptEvaluate | ScriptGetRealms | ScriptRemovePreloadScript;
+export type ScriptResult = ScriptAddPreloadScriptResult | ScriptCallFunctionResult | ScriptDisownResult | ScriptEvaluateResult | ScriptGetRealmsResult | ScriptRemovePreloadScriptResult;
+export type ScriptEvent = ScriptMessage | ScriptRealmCreated | ScriptRealmDestroyed;
+export type ScriptChannel = string;
+export interface ScriptChannelValue {
+    type: "channel";
+    value: ScriptChannelProperties;
+}
+export interface ScriptChannelProperties {
+    channel: ScriptChannel;
+    serializationOptions?: ScriptSerializationOptions;
+    ownership?: ScriptResultOwnership;
+}
+export type ScriptEvaluateResult = ScriptEvaluateResultSuccess | ScriptEvaluateResultException;
+export interface ScriptEvaluateResultSuccess {
+    type: "success";
+    result: ScriptRemoteValue;
+    realm: ScriptRealm;
+}
+export interface ScriptEvaluateResultException {
+    type: "exception";
+    exceptionDetails: ScriptExceptionDetails;
+    realm: ScriptRealm;
+}
+export interface ScriptExceptionDetails {
+    columnNumber: JsUint;
+    exception: ScriptRemoteValue;
+    lineNumber: JsUint;
+    stackTrace: ScriptStackTrace;
+    text: string;
+}
+export type ScriptHandle = string;
+export type ScriptInternalId = string;
+export type ScriptLocalValue = ScriptRemoteReference | ScriptPrimitiveProtocolValue | ScriptChannelValue | ScriptArrayLocalValue | ScriptDateLocalValue | ScriptMapLocalValue | ScriptObjectLocalValue | ScriptRegExpLocalValue | ScriptSetLocalValue;
+export type ScriptListLocalValue = ScriptLocalValue[];
+export interface ScriptArrayLocalValue {
+    type: "array";
+    value: ScriptListLocalValue;
+}
+export interface ScriptDateLocalValue {
+    type: "date";
+    value: string;
+}
+export type ScriptMappingLocalValue = (ScriptLocalValue | ScriptLocalValue)[];
+export interface ScriptMapLocalValue {
+    type: "map";
+    value: ScriptMappingLocalValue;
+}
+export interface ScriptObjectLocalValue {
+    type: "object";
+    value: ScriptMappingLocalValue;
+}
+export interface ScriptRegExpValue {
+    pattern: string;
+    flags?: string;
+}
+export interface ScriptRegExpLocalValue {
+    type: "regexp";
+    value: ScriptRegExpValue;
+}
+export interface ScriptSetLocalValue {
+    type: "set";
+    value: ScriptListLocalValue;
+}
+export type ScriptPreloadScript = string;
+export type ScriptRealm = string;
+export type ScriptPrimitiveProtocolValue = ScriptUndefinedValue | ScriptNullValue | ScriptStringValue | ScriptNumberValue | ScriptBooleanValue | ScriptBigIntValue;
+export interface ScriptUndefinedValue {
+    type: "undefined";
+}
+export interface ScriptNullValue {
+    type: "null";
+}
+export interface ScriptStringValue {
+    type: "string";
+    value: string;
+}
+export type ScriptSpecialNumber = "NaN" | "-0" | "Infinity" | "-Infinity";
+export interface ScriptNumberValue {
+    type: "number";
+    value: Number | ScriptSpecialNumber;
+}
+export interface ScriptBooleanValue {
+    type: "boolean";
+    value: boolean;
+}
+export interface ScriptBigIntValue {
+    type: "bigint";
+    value: string;
+}
+export type ScriptRealmInfo = ScriptWindowRealmInfo | ScriptDedicatedWorkerRealmInfo | ScriptSharedWorkerRealmInfo | ScriptServiceWorkerRealmInfo | ScriptWorkerRealmInfo | ScriptPaintWorkletRealmInfo | ScriptAudioWorkletRealmInfo | ScriptWorkletRealmInfo;
+export interface ScriptBaseRealmInfo {
+    realm: ScriptRealm;
+    origin: string;
+}
+export type ScriptWindowRealmInfo = ScriptBaseRealmInfo & {
+    type: "window";
+    context: BrowsingContextBrowsingContext;
+    userContext?: BrowserUserContext;
+    sandbox?: string;
+};
+export type ScriptDedicatedWorkerRealmInfo = ScriptBaseRealmInfo & {
+    type: "dedicated-worker";
+    owners: ScriptRealm[];
+};
+export type ScriptSharedWorkerRealmInfo = ScriptBaseRealmInfo & {
+    type: "shared-worker";
+};
+export type ScriptServiceWorkerRealmInfo = ScriptBaseRealmInfo & {
+    type: "service-worker";
+};
+export type ScriptWorkerRealmInfo = ScriptBaseRealmInfo & {
+    type: "worker";
+};
+export type ScriptPaintWorkletRealmInfo = ScriptBaseRealmInfo & {
+    type: "paint-worklet";
+};
+export type ScriptAudioWorkletRealmInfo = ScriptBaseRealmInfo & {
+    type: "audio-worklet";
+};
+export type ScriptWorkletRealmInfo = ScriptBaseRealmInfo & {
+    type: "worklet";
+};
+export type ScriptRealmType = "window" | "dedicated-worker" | "shared-worker" | "service-worker" | "worker" | "paint-worklet" | "audio-worklet" | "worklet";
+export type ScriptRemoteReference = ScriptSharedReference | ScriptRemoteObjectReference;
+export type ScriptSharedReference = Extensible & {
+    sharedId: ScriptSharedId;
+    handle?: ScriptHandle;
+};
+export type ScriptRemoteObjectReference = Extensible & {
+    handle: ScriptHandle;
+    sharedId?: ScriptSharedId;
+};
+export type ScriptRemoteValue = ScriptPrimitiveProtocolValue | ScriptSymbolRemoteValue | ScriptArrayRemoteValue | ScriptObjectRemoteValue | ScriptFunctionRemoteValue | ScriptRegExpRemoteValue | ScriptDateRemoteValue | ScriptMapRemoteValue | ScriptSetRemoteValue | ScriptWeakMapRemoteValue | ScriptWeakSetRemoteValue | ScriptGeneratorRemoteValue | ScriptErrorRemoteValue | ScriptProxyRemoteValue | ScriptPromiseRemoteValue | ScriptTypedArrayRemoteValue | ScriptArrayBufferRemoteValue | ScriptNodeListRemoteValue | ScriptHtmlCollectionRemoteValue | ScriptNodeRemoteValue | ScriptWindowProxyRemoteValue;
+export type ScriptListRemoteValue = ScriptRemoteValue[];
+export type ScriptMappingRemoteValue = (ScriptRemoteValue | ScriptRemoteValue)[];
+export interface ScriptSymbolRemoteValue {
+    type: "symbol";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+}
+export interface ScriptArrayRemoteValue {
+    type: "array";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+    value?: ScriptListRemoteValue;
+}
+export interface ScriptObjectRemoteValue {
+    type: "object";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+    value?: ScriptMappingRemoteValue;
+}
+export interface ScriptFunctionRemoteValue {
+    type: "function";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+}
+export type ScriptRegExpRemoteValue = ScriptRegExpLocalValue & {
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+};
+export type ScriptDateRemoteValue = ScriptDateLocalValue & {
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+};
+export interface ScriptMapRemoteValue {
+    type: "map";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+    value?: ScriptMappingRemoteValue;
+}
+export interface ScriptSetRemoteValue {
+    type: "set";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+    value?: ScriptListRemoteValue;
+}
+export interface ScriptWeakMapRemoteValue {
+    type: "weakmap";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+}
+export interface ScriptWeakSetRemoteValue {
+    type: "weakset";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+}
+export interface ScriptGeneratorRemoteValue {
+    type: "generator";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+}
+export interface ScriptErrorRemoteValue {
+    type: "error";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+}
+export interface ScriptProxyRemoteValue {
+    type: "proxy";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+}
+export interface ScriptPromiseRemoteValue {
+    type: "promise";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+}
+export interface ScriptTypedArrayRemoteValue {
+    type: "typedarray";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+}
+export interface ScriptArrayBufferRemoteValue {
+    type: "arraybuffer";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+}
+export interface ScriptNodeListRemoteValue {
+    type: "nodelist";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+    value?: ScriptListRemoteValue;
+}
+export interface ScriptHtmlCollectionRemoteValue {
+    type: "htmlcollection";
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+    value?: ScriptListRemoteValue;
+}
+export interface ScriptNodeRemoteValue {
+    type: "node";
+    sharedId?: ScriptSharedId;
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+    value?: ScriptNodeProperties;
+}
+export interface ScriptNodeProperties {
+    nodeType: JsUint;
+    childNodeCount: JsUint;
+    attributes?: Record<string, string>;
+    children?: ScriptNodeRemoteValue[];
+    localName?: string;
+    mode?: "open" | "closed";
+    namespaceUri?: string;
+    nodeValue?: string;
+    shadowRoot?: ScriptNodeRemoteValue | null;
+}
+export interface ScriptWindowProxyRemoteValue {
+    type: "window";
+    value: ScriptWindowProxyProperties;
+    handle?: ScriptHandle;
+    internalId?: ScriptInternalId;
+}
+export interface ScriptWindowProxyProperties {
+    context: BrowsingContextBrowsingContext;
+}
+export type ScriptResultOwnership = "root" | "none";
+export interface ScriptSerializationOptions {
+    maxDomDepth?: JsUint | null;
+    /**
+     * @default null
+     */
+    maxObjectDepth?: JsUint | null;
+    /**
+     * @default 'none'
+     */
+    includeShadowTree?: "none" | "open" | "all";
+}
+export type ScriptSharedId = string;
+export interface ScriptStackFrame {
+    columnNumber: JsUint;
+    functionName: string;
+    lineNumber: JsUint;
+    url: string;
+}
+export interface ScriptStackTrace {
+    callFrames: ScriptStackFrame[];
+}
+export interface ScriptSource {
+    realm: ScriptRealm;
+    context?: BrowsingContextBrowsingContext;
+    userContext?: BrowserUserContext;
+}
+export interface ScriptRealmTarget {
+    realm: ScriptRealm;
+}
+export interface ScriptContextTarget {
+    context: BrowsingContextBrowsingContext;
+    sandbox?: string;
+}
+export type ScriptTarget = ScriptContextTarget | ScriptRealmTarget;
+export interface ScriptAddPreloadScript {
+    method: "script.addPreloadScript";
+    params: ScriptAddPreloadScriptParameters;
+}
+export interface ScriptAddPreloadScriptParameters {
+    functionDeclaration: string;
+    arguments?: ScriptChannelValue[];
+    contexts?: BrowsingContextBrowsingContext[];
+    userContexts?: BrowserUserContext[];
+    sandbox?: string;
+}
+export interface ScriptAddPreloadScriptResult {
+    script: ScriptPreloadScript;
+}
+export interface ScriptDisown {
+    method: "script.disown";
+    params: ScriptDisownParameters;
+}
+export interface ScriptDisownParameters {
+    handles: ScriptHandle[];
+    target: ScriptTarget;
+}
+export type ScriptDisownResult = EmptyResult;
+export interface ScriptCallFunction {
+    method: "script.callFunction";
+    params: ScriptCallFunctionParameters;
+}
+export interface ScriptCallFunctionParameters {
+    functionDeclaration: string;
+    awaitPromise: boolean;
+    target: ScriptTarget;
+    arguments?: ScriptLocalValue[];
+    resultOwnership?: ScriptResultOwnership;
+    serializationOptions?: ScriptSerializationOptions;
+    this?: ScriptLocalValue;
+    userActivation?: boolean;
+}
+export type ScriptCallFunctionResult = ScriptEvaluateResult;
+export interface ScriptEvaluate {
+    method: "script.evaluate";
+    params: ScriptEvaluateParameters;
+}
+export interface ScriptEvaluateParameters {
+    expression: string;
+    target: ScriptTarget;
+    awaitPromise: boolean;
+    resultOwnership?: ScriptResultOwnership;
+    serializationOptions?: ScriptSerializationOptions;
+    userActivation?: boolean;
+}
+export interface ScriptGetRealms {
+    method: "script.getRealms";
+    params: ScriptGetRealmsParameters;
+}
+export interface ScriptGetRealmsParameters {
+    context?: BrowsingContextBrowsingContext;
+    type?: ScriptRealmType;
+}
+export interface ScriptGetRealmsResult {
+    realms: ScriptRealmInfo[];
+}
+export interface ScriptRemovePreloadScript {
+    method: "script.removePreloadScript";
+    params: ScriptRemovePreloadScriptParameters;
+}
+export interface ScriptRemovePreloadScriptParameters {
+    script: ScriptPreloadScript;
+}
+export type ScriptRemovePreloadScriptResult = EmptyResult;
+export interface ScriptMessage {
+    method: "script.message";
+    params: ScriptMessageParameters;
+}
+export interface ScriptMessageParameters {
+    channel: ScriptChannel;
+    data: ScriptRemoteValue;
+    source: ScriptSource;
+}
+export interface ScriptRealmCreated {
+    method: "script.realmCreated";
+    params: ScriptRealmInfo;
+}
+export interface ScriptRealmDestroyed {
+    method: "script.realmDestroyed";
+    params: ScriptRealmDestroyedParameters;
+}
+export interface ScriptRealmDestroyedParameters {
+    realm: ScriptRealm;
+}
+/** @deprecated Use {@link Script.create} instead — will be removed in a future major version. */
+export declare function getScriptManagerInstance(driver: unknown): Promise<Script>;
+export declare class Script {
+    private readonly bidi;
+    private constructor();
+    static create(driver: unknown): Promise<Script>;
+    addPreloadScript(params: ScriptAddPreloadScriptParameters): Promise<ScriptAddPreloadScriptResult>;
+    callFunction(params: ScriptCallFunctionParameters): Promise<ScriptCallFunctionResult>;
+    disown(params: ScriptDisownParameters): Promise<void>;
+    evaluate(params: ScriptEvaluateParameters): Promise<ScriptEvaluateResult>;
+    getRealms(params: ScriptGetRealmsParameters): Promise<ScriptGetRealmsResult>;
+    removePreloadScript(params: ScriptRemovePreloadScriptParameters): Promise<void>;
+    onMessage(callback: (params: ScriptMessageParameters) => void): Promise<void>;
+    onRealmCreated(callback: (params: ScriptRealmInfo) => void): Promise<void>;
+    onRealmDestroyed(callback: (params: ScriptRealmDestroyedParameters) => void): Promise<void>;
+    getAllRealms(): Promise<ScriptGetRealmsResult>;
+    getRealmsByType(type: ScriptRealmType): Promise<ScriptGetRealmsResult>;
+    getRealmsInBrowsingContext(context: BrowsingContextBrowsingContext): Promise<ScriptGetRealmsResult>;
+    getRealmsInBrowsingContextByType(context: BrowsingContextBrowsingContext, type: ScriptRealmType): Promise<ScriptGetRealmsResult>;
+    callFunctionInRealm(realmId: ScriptRealm, functionDeclaration: string, awaitPromise: boolean, args?: ScriptLocalValue[], resultOwnership?: ScriptResultOwnership, serializationOptions?: ScriptSerializationOptions, userActivation?: boolean): Promise<ScriptEvaluateResult>;
+    callFunctionInBrowsingContext(browsingContextId: BrowsingContextBrowsingContext, functionDeclaration: string, awaitPromise: boolean, args?: ScriptLocalValue[], sandbox?: string, resultOwnership?: ScriptResultOwnership, serializationOptions?: ScriptSerializationOptions, userActivation?: boolean): Promise<ScriptEvaluateResult>;
+    evaluateFunctionInRealm(realmId: ScriptRealm, expression: string, awaitPromise: boolean, resultOwnership?: ScriptResultOwnership, serializationOptions?: ScriptSerializationOptions, userActivation?: boolean): Promise<ScriptEvaluateResult>;
+    evaluateFunctionInBrowsingContext(browsingContextId: BrowsingContextBrowsingContext, expression: string, awaitPromise: boolean, sandbox?: string, resultOwnership?: ScriptResultOwnership, serializationOptions?: ScriptSerializationOptions, userActivation?: boolean): Promise<ScriptEvaluateResult>;
+    disownRealmScript(realmId: ScriptRealm, handles: ScriptHandle[]): Promise<void>;
+    disownBrowsingContextScript(browsingContextId: BrowsingContextBrowsingContext, handles: ScriptHandle[], sandbox?: string): Promise<void>;
+}

package/bidi/generated/script.js

@@ -0,0 +1,146 @@
+"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.Script = void 0;
+exports.getScriptManagerInstance = getScriptManagerInstance;
+// --- Additional Types ---
+/** @deprecated Use {@link Script.create} instead — will be removed in a future major version. */
+async function getScriptManagerInstance(driver) {
+    return Script.create(driver);
+}
+// --- Implementation ---
+class Script {
+    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 Script(bidi);
+    }
+    async addPreloadScript(params) {
+        const response = await this.bidi.send({
+            method: 'script.addPreloadScript',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async callFunction(params) {
+        const response = await this.bidi.send({
+            method: 'script.callFunction',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async disown(params) {
+        const response = await this.bidi.send({
+            method: 'script.disown',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async evaluate(params) {
+        const response = await this.bidi.send({
+            method: 'script.evaluate',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async getRealms(params) {
+        const response = await this.bidi.send({
+            method: 'script.getRealms',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+        return response.result;
+    }
+    async removePreloadScript(params) {
+        const response = await this.bidi.send({
+            method: 'script.removePreloadScript',
+            params: params,
+        });
+        if (response['type'] === 'error') {
+            throw new Error(`${response['error']}: ${response['message']}`);
+        }
+    }
+    async onMessage(callback) {
+        await this.bidi.subscribe('script.message');
+        this.bidi.on('script.message', (params) => {
+            callback(params);
+        });
+    }
+    async onRealmCreated(callback) {
+        await this.bidi.subscribe('script.realmCreated');
+        this.bidi.on('script.realmCreated', (params) => {
+            callback(params);
+        });
+    }
+    async onRealmDestroyed(callback) {
+        await this.bidi.subscribe('script.realmDestroyed');
+        this.bidi.on('script.realmDestroyed', (params) => {
+            callback(params);
+        });
+    }
+    async getAllRealms() {
+        return this.getRealms({});
+    }
+    async getRealmsByType(type) {
+        return this.getRealms({ type });
+    }
+    async getRealmsInBrowsingContext(context) {
+        return this.getRealms({ context });
+    }
+    async getRealmsInBrowsingContextByType(context, type) {
+        return this.getRealms({ context, type });
+    }
+    async callFunctionInRealm(realmId, functionDeclaration, awaitPromise, args, resultOwnership, serializationOptions, userActivation) {
+        return this.callFunction({ functionDeclaration, awaitPromise, target: { realm: realmId }, arguments: args, resultOwnership, serializationOptions, userActivation });
+    }
+    async callFunctionInBrowsingContext(browsingContextId, functionDeclaration, awaitPromise, args, sandbox, resultOwnership, serializationOptions, userActivation) {
+        return this.callFunction({ functionDeclaration, awaitPromise, target: { context: browsingContextId, sandbox }, arguments: args, resultOwnership, serializationOptions, userActivation });
+    }
+    async evaluateFunctionInRealm(realmId, expression, awaitPromise, resultOwnership, serializationOptions, userActivation) {
+        return this.evaluate({ expression, awaitPromise, target: { realm: realmId }, resultOwnership, serializationOptions, userActivation });
+    }
+    async evaluateFunctionInBrowsingContext(browsingContextId, expression, awaitPromise, sandbox, resultOwnership, serializationOptions, userActivation) {
+        return this.evaluate({ expression, awaitPromise, target: { context: browsingContextId, sandbox }, resultOwnership, serializationOptions, userActivation });
+    }
+    async disownRealmScript(realmId, handles) {
+        await this.disown({ handles, target: { realm: realmId } });
+    }
+    async disownBrowsingContextScript(browsingContextId, handles, sandbox) {
+        await this.disown({ handles, target: { context: browsingContextId, sandbox } });
+    }
+}
+exports.Script = Script;

package/bidi/generated/session.d.ts

@@ -0,0 +1,119 @@
+import type { BrowserUserContext } from './browser.js';
+import type { BrowsingContextBrowsingContext } from './browsing_context.js';
+import type { EmptyParams, EmptyResult, Extensible } from './common.js';
+export type SessionCommand = SessionEnd | SessionNew | SessionStatus | SessionSubscribe | SessionUnsubscribe;
+export type SessionResult = SessionEndResult | SessionNewResult | SessionStatusResult | SessionSubscribeResult | SessionUnsubscribeResult;
+export interface SessionCapabilitiesRequest {
+    alwaysMatch?: SessionCapabilityRequest;
+    firstMatch?: SessionCapabilityRequest[];
+}
+export type SessionCapabilityRequest = Extensible & {
+    acceptInsecureCerts?: boolean;
+    browserName?: string;
+    browserVersion?: string;
+    platformName?: string;
+    proxy?: SessionProxyConfiguration;
+    unhandledPromptBehavior?: SessionUserPromptHandler;
+};
+export type SessionProxyConfiguration = SessionAutodetectProxyConfiguration | SessionDirectProxyConfiguration | SessionManualProxyConfiguration | SessionPacProxyConfiguration | SessionSystemProxyConfiguration;
+export type SessionAutodetectProxyConfiguration = Extensible & {
+    proxyType: "autodetect";
+};
+export type SessionDirectProxyConfiguration = Extensible & {
+    proxyType: "direct";
+};
+export type SessionManualProxyConfiguration = SessionSocksProxyConfiguration & Extensible & {
+    proxyType: "manual";
+    httpProxy?: string;
+    sslProxy?: string;
+    noProxy?: string[];
+};
+export interface SessionSocksProxyConfiguration {
+    socksProxy: string;
+    socksVersion: number;
+}
+export type SessionPacProxyConfiguration = Extensible & {
+    proxyType: "pac";
+    proxyAutoconfigUrl: string;
+};
+export type SessionSystemProxyConfiguration = Extensible & {
+    proxyType: "system";
+};
+export interface SessionUserPromptHandler {
+    alert?: SessionUserPromptHandlerType;
+    beforeUnload?: SessionUserPromptHandlerType;
+    confirm?: SessionUserPromptHandlerType;
+    default?: SessionUserPromptHandlerType;
+    file?: SessionUserPromptHandlerType;
+    prompt?: SessionUserPromptHandlerType;
+}
+export type SessionUserPromptHandlerType = "accept" | "dismiss" | "ignore";
+export type SessionSubscription = string;
+export interface SessionSubscribeParameters {
+    events: string[];
+    contexts?: BrowsingContextBrowsingContext[];
+    userContexts?: BrowserUserContext[];
+}
+export interface SessionUnsubscribeByIdRequest {
+    subscriptions: SessionSubscription[];
+}
+export interface SessionUnsubscribeByAttributesRequest {
+    events: string[];
+}
+export interface SessionStatus {
+    method: "session.status";
+    params: EmptyParams;
+}
+export interface SessionStatusResult {
+    ready: boolean;
+    message: string;
+}
+export interface SessionNew {
+    method: "session.new";
+    params: SessionNewParameters;
+}
+export interface SessionNewParameters {
+    capabilities: SessionCapabilitiesRequest;
+}
+export interface SessionNewResult {
+    sessionId: string;
+    capabilities: {
+        acceptInsecureCerts: boolean;
+        browserName: string;
+        browserVersion: string;
+        platformName: string;
+        setWindowRect: boolean;
+        userAgent: string;
+        proxy?: SessionProxyConfiguration;
+        unhandledPromptBehavior?: SessionUserPromptHandler;
+        webSocketUrl?: string;
+    };
+}
+export interface SessionEnd {
+    method: "session.end";
+    params: EmptyParams;
+}
+export type SessionEndResult = EmptyResult;
+export interface SessionSubscribe {
+    method: "session.subscribe";
+    params: SessionSubscribeParameters;
+}
+export interface SessionSubscribeResult {
+    subscription: SessionSubscription;
+}
+export interface SessionUnsubscribe {
+    method: "session.unsubscribe";
+    params: SessionUnsubscribeParameters;
+}
+export type SessionUnsubscribeParameters = SessionUnsubscribeByAttributesRequest | SessionUnsubscribeByIdRequest;
+export type SessionUnsubscribeResult = EmptyResult;
+export declare class Session {
+    private readonly bidi;
+    private constructor();
+    static create(driver: unknown): Promise<Session>;
+    end(): Promise<void>;
+    new(params: SessionNewParameters): Promise<SessionNewResult>;
+    status(): Promise<SessionStatusResult>;
+    subscribe(params: SessionSubscribeParameters): Promise<SessionSubscribeResult>;
+    unsubscribe(params: SessionUnsubscribeParameters): Promise<void>;
+}