selenium-webdriver/bidi/generated/network.d.ts

The official WebDriver JavaScript bindings from the Selenium project

import type { BrowserUserContext } from './browser.js';
import type { BrowsingContextBrowsingContext, BrowsingContextNavigation } from './browsing_context.js';
import type { EmptyResult, Extensible, JsInt, JsUint } from './common.js';
import type { ScriptStackTrace } from './script.js';
export type NetworkCommand = NetworkAddDataCollector | NetworkAddIntercept | NetworkContinueRequest | NetworkContinueResponse | NetworkContinueWithAuth | NetworkDisownData | NetworkFailRequest | NetworkGetData | NetworkProvideResponse | NetworkRemoveDataCollector | NetworkRemoveIntercept | NetworkSetCacheBehavior | NetworkSetExtraHeaders;
export type NetworkResult = NetworkAddDataCollectorResult | NetworkAddInterceptResult | NetworkContinueRequestResult | NetworkContinueResponseResult | NetworkContinueWithAuthResult | NetworkDisownDataResult | NetworkFailRequestResult | NetworkGetDataResult | NetworkProvideResponseResult | NetworkRemoveDataCollectorResult | NetworkRemoveInterceptResult | NetworkSetCacheBehaviorResult | NetworkSetExtraHeadersResult;
export type NetworkEvent = NetworkAuthRequired | NetworkBeforeRequestSent | NetworkFetchError | NetworkResponseCompleted | NetworkResponseStarted;
export interface NetworkAuthChallenge {
    scheme: string;
    realm: string;
}
export interface NetworkAuthCredentials {
    type: "password";
    username: string;
    password: string;
}
export interface NetworkBaseParameters {
    context: BrowsingContextBrowsingContext | null;
    isBlocked: boolean;
    navigation: BrowsingContextNavigation | null;
    redirectCount: JsUint;
    request: NetworkRequestData;
    timestamp: JsUint;
    userContext?: BrowserUserContext | null;
    intercepts?: NetworkIntercept[];
}
export type NetworkBytesValue = NetworkStringValue | NetworkBase64Value;
export interface NetworkStringValue {
    type: "string";
    value: string;
}
export interface NetworkBase64Value {
    type: "base64";
    value: string;
}
export type NetworkCollector = string;
export type NetworkCollectorType = "blob";
export type NetworkSameSite = "strict" | "lax" | "none" | "default";
export type NetworkCookie = Extensible & {
    name: string;
    value: NetworkBytesValue;
    domain: string;
    path: string;
    size: JsUint;
    httpOnly: boolean;
    secure: boolean;
    sameSite: NetworkSameSite;
    expiry?: JsUint;
};
export interface NetworkCookieHeader {
    name: string;
    value: NetworkBytesValue;
}
export type NetworkDataType = "request" | "response";
export interface NetworkFetchTimingInfo {
    timeOrigin: number;
    requestTime: number;
    redirectStart: number;
    redirectEnd: number;
    fetchStart: number;
    dnsStart: number;
    dnsEnd: number;
    connectStart: number;
    connectEnd: number;
    tlsStart: number;
    requestStart: number;
    responseStart: number;
    responseEnd: number;
}
export interface NetworkHeader {
    name: string;
    value: NetworkBytesValue;
}
export interface NetworkInitiator {
    columnNumber?: JsUint;
    lineNumber?: JsUint;
    request?: NetworkRequest;
    stackTrace?: ScriptStackTrace;
    type?: "parser" | "script" | "preflight" | "other";
}
export type NetworkIntercept = string;
export type NetworkRequest = string;
export interface NetworkRequestData {
    request: NetworkRequest;
    url: string;
    method: string;
    headers: NetworkHeader[];
    cookies: NetworkCookie[];
    headersSize: JsUint;
    bodySize: JsUint | null;
    destination: string;
    initiatorType: string | null;
    timings: NetworkFetchTimingInfo;
}
export interface NetworkResponseContent {
    size: JsUint;
}
export interface NetworkResponseData {
    url: string;
    protocol: string;
    status: JsUint;
    statusText: string;
    fromCache: boolean;
    headers: NetworkHeader[];
    mimeType: string;
    bytesReceived: JsUint;
    headersSize: JsUint | null;
    bodySize: JsUint | null;
    content: NetworkResponseContent;
    authChallenges?: NetworkAuthChallenge[];
}
export interface NetworkSetCookieHeader {
    name: string;
    value: NetworkBytesValue;
    domain?: string;
    httpOnly?: boolean;
    expiry?: string;
    maxAge?: JsInt;
    path?: string;
    sameSite?: NetworkSameSite;
    secure?: boolean;
}
export type NetworkUrlPattern = NetworkUrlPatternPattern | NetworkUrlPatternString;
export interface NetworkUrlPatternPattern {
    type: "pattern";
    protocol?: string;
    hostname?: string;
    port?: string;
    pathname?: string;
    search?: string;
}
export interface NetworkUrlPatternString {
    type: "string";
    pattern: string;
}
export interface NetworkAddDataCollector {
    method: "network.addDataCollector";
    params: NetworkAddDataCollectorParameters;
}
export interface NetworkAddDataCollectorParameters {
    dataTypes: NetworkDataType[];
    maxEncodedDataSize: JsUint;
    /**
     * @default 'blob'
     */
    collectorType?: NetworkCollectorType;
    contexts?: BrowsingContextBrowsingContext[];
    userContexts?: BrowserUserContext[];
}
export interface NetworkAddDataCollectorResult {
    collector: NetworkCollector;
}
export interface NetworkAddIntercept {
    method: "network.addIntercept";
    params: NetworkAddInterceptParameters;
}
export interface NetworkAddInterceptParameters {
    phases: NetworkInterceptPhase[];
    contexts?: BrowsingContextBrowsingContext[];
    urlPatterns?: NetworkUrlPattern[];
}
export type NetworkInterceptPhase = "beforeRequestSent" | "responseStarted" | "authRequired";
export interface NetworkAddInterceptResult {
    intercept: NetworkIntercept;
}
export interface NetworkContinueRequest {
    method: "network.continueRequest";
    params: NetworkContinueRequestParameters;
}
export interface NetworkContinueRequestParameters {
    request: NetworkRequest;
    body?: NetworkBytesValue;
    cookies?: NetworkCookieHeader[];
    headers?: NetworkHeader[];
    method?: string;
    url?: string;
}
export type NetworkContinueRequestResult = EmptyResult;
export interface NetworkContinueResponse {
    method: "network.continueResponse";
    params: NetworkContinueResponseParameters;
}
export interface NetworkContinueResponseParameters {
    request: NetworkRequest;
    cookies?: NetworkSetCookieHeader[];
    credentials?: NetworkAuthCredentials;
    headers?: NetworkHeader[];
    reasonPhrase?: string;
    statusCode?: JsUint;
}
export type NetworkContinueResponseResult = EmptyResult;
export interface NetworkContinueWithAuth {
    method: "network.continueWithAuth";
    params: NetworkContinueWithAuthParameters;
}
export type NetworkContinueWithAuthParameters = (NetworkContinueWithAuthCredentials | NetworkContinueWithAuthNoCredentials) & {
    request: NetworkRequest;
};
export interface NetworkContinueWithAuthCredentials {
    action: "provideCredentials";
    credentials: NetworkAuthCredentials;
}
export interface NetworkContinueWithAuthNoCredentials {
    action: "default" | "cancel";
}
export type NetworkContinueWithAuthResult = EmptyResult;
export interface NetworkDisownData {
    method: "network.disownData";
    params: NetworkDisownDataParameters;
}
export interface NetworkDisownDataParameters {
    dataType: NetworkDataType;
    collector: NetworkCollector;
    request: NetworkRequest;
}
export type NetworkDisownDataResult = EmptyResult;
export interface NetworkFailRequest {
    method: "network.failRequest";
    params: NetworkFailRequestParameters;
}
export interface NetworkFailRequestParameters {
    request: NetworkRequest;
}
export type NetworkFailRequestResult = EmptyResult;
export interface NetworkGetData {
    method: "network.getData";
    params: NetworkGetDataParameters;
}
export interface NetworkGetDataParameters {
    dataType: NetworkDataType;
    collector?: NetworkCollector;
    disown?: boolean;
    request: NetworkRequest;
}
export interface NetworkGetDataResult {
    bytes: NetworkBytesValue;
}
export interface NetworkProvideResponse {
    method: "network.provideResponse";
    params: NetworkProvideResponseParameters;
}
export interface NetworkProvideResponseParameters {
    request: NetworkRequest;
    body?: NetworkBytesValue;
    cookies?: NetworkSetCookieHeader[];
    headers?: NetworkHeader[];
    reasonPhrase?: string;
    statusCode?: JsUint;
}
export type NetworkProvideResponseResult = EmptyResult;
export interface NetworkRemoveDataCollector {
    method: "network.removeDataCollector";
    params: NetworkRemoveDataCollectorParameters;
}
export interface NetworkRemoveDataCollectorParameters {
    collector: NetworkCollector;
}
export type NetworkRemoveDataCollectorResult = EmptyResult;
export interface NetworkRemoveIntercept {
    method: "network.removeIntercept";
    params: NetworkRemoveInterceptParameters;
}
export interface NetworkRemoveInterceptParameters {
    intercept: NetworkIntercept;
}
export type NetworkRemoveInterceptResult = EmptyResult;
export interface NetworkSetCacheBehavior {
    method: "network.setCacheBehavior";
    params: NetworkSetCacheBehaviorParameters;
}
export interface NetworkSetCacheBehaviorParameters {
    cacheBehavior: "default" | "bypass";
    contexts?: BrowsingContextBrowsingContext[];
}
export type NetworkSetCacheBehaviorResult = EmptyResult;
export interface NetworkSetExtraHeaders {
    method: "network.setExtraHeaders";
    params: NetworkSetExtraHeadersParameters;
}
export interface NetworkSetExtraHeadersParameters {
    headers: NetworkHeader[];
    contexts?: BrowsingContextBrowsingContext[];
    userContexts?: BrowserUserContext[];
}
export type NetworkSetExtraHeadersResult = EmptyResult;
export interface NetworkAuthRequired {
    method: "network.authRequired";
    params: NetworkAuthRequiredParameters;
}
export type NetworkAuthRequiredParameters = NetworkBaseParameters & {
    response: NetworkResponseData;
};
export interface NetworkBeforeRequestSent {
    method: "network.beforeRequestSent";
    params: NetworkBeforeRequestSentParameters;
}
export type NetworkBeforeRequestSentParameters = NetworkBaseParameters & {
    initiator?: NetworkInitiator;
};
export interface NetworkFetchError {
    method: "network.fetchError";
    params: NetworkFetchErrorParameters;
}
export type NetworkFetchErrorParameters = NetworkBaseParameters & {
    errorText: string;
};
export interface NetworkResponseCompleted {
    method: "network.responseCompleted";
    params: NetworkResponseCompletedParameters;
}
export type NetworkResponseCompletedParameters = NetworkBaseParameters & {
    response: NetworkResponseData;
};
export interface NetworkResponseStarted {
    method: "network.responseStarted";
    params: NetworkResponseStartedParameters;
}
export type NetworkResponseStartedParameters = NetworkBaseParameters & {
    response: NetworkResponseData;
};
/** @deprecated Use {@link Network.create} instead — will be removed in a future major version. */
export declare function getNetworkInstance(driver: unknown): Promise<Network>;
export declare class Network {
    private readonly bidi;
    private constructor();
    static create(driver: unknown): Promise<Network>;
    addDataCollector(params: NetworkAddDataCollectorParameters): Promise<NetworkAddDataCollectorResult>;
    addIntercept(params: NetworkAddInterceptParameters): Promise<NetworkAddInterceptResult>;
    continueRequest(params: NetworkContinueRequestParameters): Promise<void>;
    continueResponse(params: NetworkContinueResponseParameters): Promise<void>;
    continueWithAuth(params: NetworkContinueWithAuthParameters): Promise<void>;
    /** @deprecated Pass a NetworkContinueWithAuthParameters object instead — will be removed in a future major version. */
    continueWithAuth(requestId: NetworkRequest, username: string, password: string): Promise<void>;
    disownData(params: NetworkDisownDataParameters): Promise<void>;
    failRequest(params: NetworkFailRequestParameters): Promise<void>;
    getData(params: NetworkGetDataParameters): Promise<NetworkGetDataResult>;
    provideResponse(params: NetworkProvideResponseParameters): Promise<void>;
    removeDataCollector(params: NetworkRemoveDataCollectorParameters): Promise<void>;
    removeIntercept(params: NetworkRemoveInterceptParameters): Promise<void>;
    setCacheBehavior(params: NetworkSetCacheBehaviorParameters): Promise<void>;
    setExtraHeaders(params: NetworkSetExtraHeadersParameters): Promise<void>;
    onAuthRequired(callback: (params: NetworkAuthRequiredParameters) => void): Promise<void>;
    onBeforeRequestSent(callback: (params: NetworkBeforeRequestSentParameters) => void): Promise<void>;
    onFetchError(callback: (params: NetworkFetchErrorParameters) => void): Promise<void>;
    onResponseCompleted(callback: (params: NetworkResponseCompletedParameters) => void): Promise<void>;
    onResponseStarted(callback: (params: NetworkResponseStartedParameters) => void): Promise<void>;
    cancelAuth(requestId: NetworkRequest): Promise<void>;
    continueWithAuthNoCredentials(requestId: NetworkRequest): Promise<void>;
    /** @deprecated Use {@link onBeforeRequestSent} instead — will be removed in a future major version. */
    beforeRequestSent(callback: (params: NetworkBeforeRequestSentParameters) => void): Promise<void>;
    /** @deprecated Use {@link onAuthRequired} instead — will be removed in a future major version. */
    authRequired(callback: (params: NetworkAuthRequiredParameters) => void): Promise<void>;
    /** @deprecated Use {@link onFetchError} instead — will be removed in a future major version. */
    fetchError(callback: (params: NetworkFetchErrorParameters) => void): Promise<void>;
    /** @deprecated Use {@link onResponseCompleted} instead — will be removed in a future major version. */
    responseCompleted(callback: (params: NetworkResponseCompletedParameters) => void): Promise<void>;
    /** @deprecated Use {@link onResponseStarted} instead — will be removed in a future major version. */
    responseStarted(callback: (params: NetworkResponseStartedParameters) => void): Promise<void>;
}