@types/selenium-webdriver

constructor

constructor(
    executor: Executor,
    options?:
        | { async: boolean; bridge: boolean }
        | { async: boolean }
        | { bridge: boolean }
);

method clear

clear: () => Promise<void>;

• Executes this action sequence. {!Promise} A promise that will be resolved once this sequence has completed.

method click

click: (element?: WebElement) => Actions;

• Short-hand for performing a simple left-click (down/up) with the mouse.

  Parameter element

  If specified, the mouse will first be moved to the center of the element before performing the click. {!Actions} a self reference.

method contextClick

contextClick: (element?: WebElement) => Actions;

• Short-hand for performing a simple right-click (down/up) with the mouse.

  Parameter element

  If specified, the mouse will first be moved to the center of the element before performing the click. {!Actions} a self reference.

method doubleClick

doubleClick: (element?: WebElement) => Actions;

• Short-hand for performing a double left-click with the mouse.

  Parameter element

  If specified, the mouse will first be moved to the center of the element before performing the click. {!Actions} a self reference.

method dragAndDrop

dragAndDrop: (
    from: WebElement,
    to?:
        | WebElement
        | { x?: number | string | undefined; y?: number | string | undefined }
        | null
) => Actions;

• Convenience function for performing a 'drag and drop' manuever. The target element may be moved to the location of another element, or by an offset (in pixels).

method keyboard

keyboard: () => Keyboard;

method keyDown

keyDown: (key: string) => Actions;

• Performs a modifier key press. The modifier key is not released until or is called. The key press will be targetted at the currently focused element.

  Parameter key

  The modifier key to push. Must be one of {ALT, CONTROL, SHIFT, COMMAND, META}. {!Actions} A self reference.

  Throws

  {Error} If the key is not a valid modifier key.

method keyUp

keyUp: (key: string) => Actions;

• Performs a modifier key release. The release is targetted at the currently focused element.

  Parameter key

  The modifier key to release. Must be one of {ALT, CONTROL, SHIFT, COMMAND, META}. {!Actions} A self reference.

  Throws

  {Error} If the key is not a valid modifier key.

method mouse

mouse: () => Pointer;

method move

move: (direction: IDirection) => Actions;

• Inserts an action for moving the mouse x and y pixels relative to the specified origin. The origin may be defined as the mouse's , the , or the center of a specific .

  You may adjust how long the remote end should take, in milliseconds, to perform the move using the duration parameter (defaults to 100 ms). The number of incremental move events generated over this duration is an implementation detail for the remote end.

  Defaults to moving the mouse to the top-left corner of the viewport over 100ms.

method pause

pause: (duration?: number | Device, ...devices: Device[]) => Actions;

method perform

perform: () => Promise<void>;

• Executes this action sequence. {!Promise} A promise that will be resolved once this sequence has completed.

method press

press: (button?: Button) => Actions;

• Inserts an action to press a mouse button at the mouse's current location. Defaults to LEFT.

method release

release: (button?: Button) => Actions;

• Inserts an action to release a mouse button at the mouse's current location. Defaults to LEFT.

method sendKeys

sendKeys: (...var_args: Array<string | Promise<string>>) => Actions;

• Simulates typing multiple keys. Each modifier key encountered in the sequence will not be released until it is encountered again. All key events will be targeted at the currently focused element.

  Parameter var_args

  The keys to type. {!Actions} A self reference.

  Throws

  {Error} If the key is not a valid modifier key.

constructor

constructor(driver: WebDriver, text: string);

• Parameter driver

  The driver controlling the browser this alert is attached to.

  Parameter text

  The message text displayed with this alert.

method accept

accept: () => Promise<void>;

• Accepts this alert.

  {!Promise} A promise that will be resolved when this command has completed.

method dismiss

dismiss: () => Promise<void>;

• Dismisses this alert.

  {!Promise} A promise that will be resolved when this command has completed.

method getText

getText: () => Promise<string>;

• Retrieves the message text displayed with this alert. For instance, if the alert were opened with alert("hello"), then this would return "hello".

  {!Promise} A promise that will be resolved to the text displayed with this alert.

method sendKeys

sendKeys: (text: string) => Promise<void>;

• Sets the response text on this alert. This command will return an error if the underlying alert does not support response text (e.g. window.alert and window.confirm).

  Parameter text

  The text to set. {!Promise} A promise that will be resolved when this command has completed.

constructor

constructor();

method build

build: () => ThenableWebDriver;

• Creates a new WebDriver client based on this builder's current configuration.

  This method will return a instance, allowing users to issue commands directly without calling then(). The returned thenable wraps a promise that will resolve to a concrete instance. The promise will be rejected if the remote end fails to create a new session.

  {!ThenableWebDriver} A new WebDriver instance.

  Throws

  {Error} If the current configuration is invalid.

method disableEnvironmentOverrides

disableEnvironmentOverrides: () => Builder;

• Configures this builder to ignore any environment variable overrides and to only use the configuration specified through this instance's API.

  {!Builder} A self reference.

method forBrowser

forBrowser: (
    name: string,
    opt_version?: string,
    opt_platform?: string
) => Builder;

• Configures the target browser for clients created by this instance. Any calls to after this function will overwrite these settings.

  You may also define the target browser using the environment variable. If set, this environment variable should be of the form .

  Parameter name

  The name of the target browser; common defaults are available on the Browser enum.

  Parameter opt_version

  A desired version; may be omitted if any version should be used.

  Parameter opt_platform

  The desired platform; may be omitted if any version may be used. {!Builder} A self reference.

method getCapabilities

getCapabilities: () => Capabilities;

• Returns the base set of capabilities this instance is currently configured to use. {!Capabilities} The current capabilities for this builder.

method getChromeOptions

getChromeOptions: () => chrome.Options;

• {chrome.Options} the Chrome specific options currently configured for this builder.

method getFirefoxOptions

getFirefoxOptions: () => firefox.Options;

• {firefox.Options} the Firefox specific options currently configured for this instance.

method getHttpAgent

getHttpAgent: () => any | null;

• {http.Agent} The http agent used for each request

method getSafariOptions

getSafariOptions: () => safari.Options;

• {safari.Options} the Safari specific options currently configured for this instance.

method getServerUrl

getServerUrl: () => string;

• {string} The URL of the WebDriver server this instance is configured to use.

method getWebDriverProxy

getWebDriverProxy: () => string | null;

• {?string} The URL of the proxy server to use for the WebDriver's HTTP connections, or null if not set.

method setAlertBehavior

setAlertBehavior: (behavior?: string) => Builder;

• Sets the default action to take with an unexpected alert before returning an error.

  Parameter beahvior

  The desired behavior; should be 'accept', 'dismiss', or 'ignore'. Defaults to 'dismiss'. {!Builder} A self reference.

method setChromeOptions

setChromeOptions: (options: chrome.Options) => Builder;

• Sets Chrome-specific options for drivers created by this builder. Any logging or proxy settings defined on the given options will take precedence over those set through and , respectively.

  Parameter options

  The ChromeDriver options to use. {!Builder} A self reference.

method setChromeService

setChromeService: (service: chrome.ServiceBuilder) => Builder;

• Sets the service builder to use for managing the chromedriver child process when creating new Chrome sessions.

  Parameter service

  the service to use. {!Builder} A self reference.

method setEdgeOptions

setEdgeOptions: (options: edge.Options) => Builder;

• Set specific to Microsoft's Edge browser for drivers created by this builder. Any proxy settings defined on the given options will take precedence over those set through .

  Parameter options

  The MicrosoftEdgeDriver options to use. {!Builder} A self reference.

method setEdgeService

setEdgeService: (service: edge.ServiceBuilder) => Builder;

• Sets the edge.ServiceBuilder to use to manage the MicrosoftEdgeDriver child process when creating sessions locally.

  Parameter service

  the service to use. {!Builder} a self reference.

method setFirefoxOptions

setFirefoxOptions: (options: firefox.Options) => Builder;

• Sets Firefox-specific options for drivers created by this builder. Any logging or proxy settings defined on the given options will take precedence over those set through and , respectively.

  Parameter options

  The FirefoxDriver options to use. {!Builder} A self reference.

method setFirefoxService

setFirefoxService: (service: firefox.ServiceBuilder) => Builder;

• Sets the firefox.ServiceBuilder to use to manage the geckodriver child process when creating Firefox sessions locally.

  Parameter service

  the service to use. {!Builder} a self reference.

method setIeOptions

setIeOptions: (options: ie.Options) => Builder;

• Set Internet Explorer specific for drivers created by this builder. Any proxy settings defined on the given options will take precedence over those set through .

  Parameter options

  The IEDriver options to use. {!Builder} A self reference.

method setIeService

setIeService: (service: ie.ServiceBuilder) => Builder;

• Sets the ie.ServiceBuilder to use to manage the geckodriver child process when creating IE sessions locally.

  Parameter service

  the service to use. {!Builder} a self reference.

method setLoggingPrefs

setLoggingPrefs: (prefs: logging.Preferences | {}) => Builder;

• Sets the logging preferences for the created session. Preferences may be changed by repeated calls, or by calling .

  Parameter prefs

  The desired logging preferences. {!Builder} A self reference.

method setProxy

setProxy: (config: ProxyConfig) => Builder;

• Sets the proxy configuration to use for WebDriver clients created by this builder. Any calls to after this function will overwrite these settings.

  Parameter config

  The configuration to use. {!Builder} A self reference.

method setSafariOptions

setSafariOptions: (options: safari.Options) => Builder;

• Sets Safari specific for drivers created by this builder. Any logging settings defined on the given options will take precedence over those set through .

  Parameter options

  The Safari options to use. {!Builder} A self reference.

method usingHttpAgent

usingHttpAgent: (agent: any) => Builder;

• Sets the http agent to use for each request. If this method is not called, the Builder will use http.globalAgent by default.

  Parameter agent

  The agent to use for each request. {!Builder} A self reference.

method usingServer

usingServer: (url: string) => Builder;

• Sets the URL of a remote WebDriver server to use. Once a remote URL has been specified, the builder direct all new clients to that server. If this method is never called, the Builder will attempt to create all clients locally.

  As an alternative to this method, you may also set the environment variable.

  Parameter url

  The URL of a remote server to use. {!Builder} A self reference.

method usingWebDriverProxy

usingWebDriverProxy: (proxy: string) => Builder;

• Sets the URL of the proxy to use for the WebDriver's HTTP connections. If this method is never called, the Builder will create a connection without a proxy.

  Parameter proxy

  The URL of a proxy to use. {!Builder} A self reference.

method withCapabilities

withCapabilities: (capabilities: {} | Capabilities) => Builder;

• Sets the desired capabilities when requesting a new session. This will overwrite any previously set capabilities.

  Parameter capabilities

  The desired capabilities for a new session. {!Builder} A self reference.

constructor

constructor(using: string, value: string);

• Parameter using

  the name of the location strategy to use.

  Parameter value

  the value to search for.

property using

using: string;

property value

value: string;

method className

static className: (name: string) => By;

• Locates elements that have a specific class name.

  Parameter name

  The class name to search for. {!By} The new locator.

  See Also

  • http://www.w3.org/TR/2011/WD-html5-20110525/elements.html#classes

  • http://www.w3.org/TR/CSS2/selector.html#class-html

method css

static css: (selector: string) => By;

• Locates elements using a CSS selector.

  Parameter selector

  The CSS selector to use. {!By} The new locator.

  See Also

  • http://www.w3.org/TR/CSS2/selector.html

method id

static id: (id: string) => By;

• Locates eleemnts by the ID attribute. This locator uses the CSS selector *[id='$ID'], _not_ document.getElementById.

  Parameter id

  The ID to search for. {!By} The new locator.

method js

static js: (
    script: string | Function,
    ...var_args: any[]
) => (webdriver: WebDriver) => Promise<any>;

• Locates an elements by evaluating a . The result of this expression must be an element or list of elements.

  Parameter script

  The script to execute.

  Parameter var_args

  The arguments to pass to the script. {function(!./WebDriver): !./Promise} A new JavaScript-based locator function.

method linkText

static linkText: (text: string) => By;

• Locates link elements whose matches the given string.

  Parameter text

  The link text to search for. {!By} The new locator.

method name

static name: (name: string) => By;

• Locates elements whose name attribute has the given value.

  Parameter name

  The name attribute to search for. {!By} The new locator.

method partialLinkText

static partialLinkText: (text: string) => By;

• Locates link elements whose contains the given substring.

  Parameter text

  The substring to check for in a link's visible text. {!By} The new locator.

method tagName

static tagName: (name: string) => By;

• Locates elements with a given tag name.

  Parameter name

  The tag name to search for. {!By} The new locator.

  Deprecated

  Use instead.

method toObject

toObject: () => Object;

method toString

toString: () => string;

• Modifiers

  • @override

method xpath

static xpath: (xpath: string) => By;

• Locates elements matching a XPath selector. Care should be taken when using an XPath selector with a WebElement as WebDriver will respect the context in the specified in the selector. For example, given the selector //div, WebDriver will search from the document root regardless of whether the locator was used with a WebElement.

  Parameter xpath

  The XPath selector to use. {!By} The new locator.

  See Also

  • http://www.w3.org/TR/xpath/

constructor

constructor(other?: {} | Capabilities | Map<string, any>);

• Parameter other

  Another set of capabilities to initialize this instance from.

method [Symbols.serialize]

[Symbols.serialize]: () => {};

• {!Object<string, ?>} The JSON representation of this instance. Note, the returned object may contain nested promised values. {checkTypes} Suppress [] access on a struct (state inherited from Map).

method chrome

static chrome: () => Capabilities;

• {!Capabilities} A basic set of capabilities for Chrome.

method delete

delete: (key: string) => boolean;

• Deletes an entry from this set of capabilities.

  Parameter key

  the capability key to delete.

method edge

static edge: () => Capabilities;

• {!Capabilities} A basic set of capabilities for Microsoft Edge.

method firefox

static firefox: () => Capabilities;

• {!Capabilities} A basic set of capabilities for Firefox.

method get

get: (key: string) => any;

• Parameter key

  The capability to return. {*} The capability with the given key, or if it has not been set.

method getAcceptInsecureCerts

getAcceptInsecureCerts: () => boolean;

• {boolean} whether the session is configured to accept insecure TLS certificates.

method getAlertBehavior

getAlertBehavior: () => string | undefined;

• {(UserPromptHandler|undefined)} the behavior pattern for responding to unhandled user prompts, or undefined if not set.

method getBrowserName

getBrowserName: () => string | undefined;

• {(string|undefined)} the configured browser name, or undefined if not set.

method getBrowserVersion

getBrowserVersion: () => string | undefined;

• {(string|undefined)} the configured browser version, or undefined if not set.

method getPageLoadStrategy

getPageLoadStrategy: () => string | undefined;

• Returns the configured page load strategy.

  {(string|undefined)} the page load strategy.

method getPlatform

getPlatform: () => string | undefined;

• {(string|undefined)} the configured platform or undefined if not set.

method getProxy

getProxy: () => ProxyConfig | undefined;

• {(proxy.Config|undefined)} the configured proxy settings, or undefined if not set.

method has

has: (key: string) => boolean;

• Parameter key

  The capability to check. {boolean} Whether the specified capability is set.

method ie

static ie: () => Capabilities;

• {!Capabilities} A basic set of capabilities for Internet Explorer.

method keys

keys: () => IterableIterator<string>;

• {!Iterator} an iterator of the keys set.

method merge

merge: (other: Capabilities | Map<string, any> | {}) => Capabilities;

• Merges another set of capabilities into this instance.

  Parameter other

  The other set of capabilities to merge. {!Capabilities} A self reference.

method safari

static safari: () => Capabilities;

• {!Capabilities} A basic set of capabilities for Safari.

method set

set: (key: string, value: any) => Capabilities;

• Parameter key

  The capability key.

  Parameter value

  The capability value. {!Capabilities} A self reference.

  Throws

  {TypeError} If the key is not a string.

method setAcceptInsecureCerts

setAcceptInsecureCerts: (accept: boolean) => Capabilities;

• Sets whether a WebDriver session should implicitly accept self-signed, or other untrusted TLS certificates on navigation.

  Parameter accept

  whether to accept insecure certs. {!Capabilities} a self reference.

method setAlertBehavior

setAlertBehavior: (behavior: string) => Capabilities;

• Sets the default action to take with an unexpected alert before returning an error. If unspecified, WebDriver will default to UserPromptHandler.DISMISS_AND_NOTIFY.

  Parameter behavior

  The way WebDriver should respond to unhandled user prompts. {!Capabilities} A self reference.

method setBrowserName

setBrowserName: (name: string) => Capabilities;

• Sets the name of the target browser.

  Parameter name

  the browser name. {!Capabilities} a self reference.

method setBrowserVersion

setBrowserVersion: (version: string) => Capabilities;

• Sets the desired version of the target browser.

  Parameter version

  the desired version. {!Capabilities} a self reference.

method setLoggingPrefs

setLoggingPrefs: (prefs: logging.Preferences | {}) => Capabilities;

• Sets the logging preferences. Preferences may be specified as a instance, or as a map of log-type to log-level.

  Parameter prefs

  The logging preferences. {!Capabilities} A self reference.

method setPageLoadStrategy

setPageLoadStrategy: (strategy: string) => Capabilities;

• Sets the desired page loading strategy for a new WebDriver session.

  Parameter strategy

  the desired strategy. {!Capabilities} a self reference.

method setPlatform

setPlatform: (platform: string) => Capabilities;

• Sets the target platform.

  Parameter platform

  the target platform. {!Capabilities} a self reference.

method setProxy

setProxy: (proxy: ProxyConfig) => Capabilities;

• Sets the proxy configuration for this instance.

  Parameter proxy

  The desired proxy configuration. {!Capabilities} A self reference.

constructor

constructor(message: string, fn: ConditionFn<T>);

• Parameter message

  A descriptive error message. Should complete the sentence "Waiting [...]"

  Parameter fn

  The condition function to evaluate on each iteration of the wait loop.

method description

description: () => string;

• {string} A description of this condition.

constructor

constructor();

method addListener

addListener: (
    type: string,
    fn: Function,
    opt_scope?: any,
    opt_oneshot?: boolean
) => EventEmitter;

• Registers a listener.

  Parameter type

  The type of event to listen for.

  Parameter fn

  The function to invoke when the event is fired.

  Parameter opt_self

  The object in whose scope to invoke the listener.

  Parameter opt_oneshot

  Whether the listener should b (e removed after the first event is fired. {!EventEmitter} A self reference.

method emit

emit: (type: string, ...var_args: any[]) => void;

• Fires an event and calls all listeners.

  Parameter type

  The type of event to emit.

  Parameter var_args

  Any arguments to pass to each listener.

method listeners

listeners: (type: string) => any;

• Returns a mutable list of listeners for a specific type of event.

  Parameter type

  The type of event to retrieve the listeners for. {!Set<!Listener>} The registered listeners for the given event type.

method on

on: (type: string, fn: Function, opt_scope?: any) => EventEmitter;

• An alias for .

  Parameter type

  The type of event to listen for.

  Parameter fn

  The function to invoke when the event is fired.

  Parameter opt_scope

  The object in whose scope to invoke the listener. {!EventEmitter} A self reference.

method once

once: (type: string, fn: any, opt_scope?: any) => EventEmitter;

• Registers a one-time listener which will be called only the first time an event is emitted, after which it will be removed.

  Parameter type

  The type of event to listen for.

  Parameter fn

  The function to invoke when the event is fired.

  Parameter opt_scope

  The object in whose scope to invoke the listener. {!EventEmitter} A self reference.

method removeAllListeners

removeAllListeners: (opt_type?: string) => EventEmitter;

• Removes all listeners for a specific type of event. If no event is specified, all listeners across all types will be removed.

  Parameter opt_type

  The type of event to remove listeners from. {!EventEmitter} A self reference.

method removeListener

removeListener: (type: string, listenerFn: Function) => EventEmitter;

• Removes a previously registered event listener.

  Parameter type

  The type of event to unregister.

  Parameter listenerFn

  The handler function to remove. {!EventEmitter} A self reference.

method handleFile

handleFile: (driver: WebDriver, path: string) => Promise<string>;

• Handles the file specified by the given path, preparing it for use with the current browser. If the path does not refer to a valid file, it will be returned unchanged, otherwise a path suitable for use with the current browser will be returned.

  This default implementation is a no-op. Subtypes may override this function for custom tailored file handling.

  Parameter driver

  The driver for the current browser.

  Parameter path

  The path to process. {!Promise} A promise for the processed file path.

constructor

constructor(fn: Function, scope: {}, oneshot: boolean);

• Parameter fn

  The acutal listener function.

  Parameter scope

  The object in whose scope to invoke the listener.

  Parameter oneshot

  Whether this listener should only be used once.

constructor

constructor(driver: WebDriver);

• Parameter driver

  The parent driver.

method get

get: (type: string) => Promise<logging.Entry[]>;

• Fetches available log entries for the given type.

  Note that log buffers are reset after each call, meaning that available log entries correspond to those entries not yet returned for a given log type. In practice, this means that this call will return the available log entries since the last call, or from the start of the session.

  Parameter type

  The desired log type. {!Promise.<!Array.<!logging.Entry>>} A promise that will resolve to a list of log entries for the specified type.

method getAvailableLogTypes

getAvailableLogTypes: () => Promise<string[]>;

• Retrieves the log types available to this driver. {!Promise.<!Array.<!logging.Type>>} A promise that will resolve to a list of available log types.

constructor

constructor(driver: WebDriver);

• Parameter driver

  The parent driver.

method back

back: () => Promise<void>;

• Moves backwards in the browser history.

  {!Promise} A promise that will be resolved when the navigation event has completed.

method forward

forward: () => Promise<void>;

• Moves forwards in the browser history.

  {!Promise} A promise that will be resolved when the navigation event has completed.

method refresh

refresh: () => Promise<void>;

• Refreshes the current page.

  {!Promise} A promise that will be resolved when the navigation event has completed.

method to

to: (url: string) => Promise<void>;

• Navigates to a new URL.

  Parameter url

  The URL to navigate to. {!Promise} A promise that will be resolved when the URL has been loaded.

constructor

constructor(driver: WebDriver);

• Parameter driver

  The parent driver.

method addCookie

addCookie: (spec: IWebDriverOptionsCookie) => Promise<void>;

• Adds a cookie.

  __Sample Usage:__

  // Set a basic cookie. driver.manage().addCookie({name: 'foo', value: 'bar'});

  // Set a cookie that expires in 10 minutes. let expiry = new Date(Date.now() + (10 * 60 * 1000)); driver.manage().addCookie({name: 'foo', value: 'bar', expiry});

  // The cookie expiration may also be specified in seconds since epoch. driver.manage().addCookie({ name: 'foo', value: 'bar', expiry: Math.floor(Date.now() / 1000) });

  Parameter spec

  Defines the cookie to add. {!Promise} A promise that will be resolved when the cookie has been added to the page.

  Throws

  {error.InvalidArgumentError} if any of the cookie parameters are invalid.

  Throws

  {TypeError} if spec is not a cookie object.

method deleteAllCookies

deleteAllCookies: () => Promise<void>;

• Deletes all cookies visible to the current page.

  {!Promise} A promise that will be resolved when all cookies have been deleted.

method deleteCookie

deleteCookie: (name: string) => Promise<void>;

• Deletes the cookie with the given name. This command is a no-op if there is no cookie with the given name visible to the current page.

  Parameter name

  The name of the cookie to delete. {!Promise} A promise that will be resolved when the cookie has been deleted.

method getCookie

getCookie: (name: string) => Promise<IWebDriverOptionsCookie>;

• Retrieves the cookie with the given name. Returns null if there is no such cookie. The cookie will be returned as a JSON object as described by the WebDriver wire protocol.

  Parameter name

  The name of the cookie to retrieve. {!Promise<?Options.Cookie>} A promise that will be resolved with the named cookie

  Throws

  {error.NoSuchCookieError} if there is no such cookie.

method getCookies

getCookies: () => Promise<IWebDriverOptionsCookie[]>;

• Retrieves all cookies visible to the current page. Each cookie will be returned as a JSON object as described by the WebDriver wire protocol.

  {!Promise<!Array<!Options.Cookie>>} A promise that will be resolved with the cookies visible to the current browsing context.

method getTimeouts

getTimeouts: () => Promise<ITimeouts>;

• Fetches the timeouts currently configured for the current session.

  {!Promise<{script: number, pageLoad: number, implicit: number}>} A promise that will be resolved with the timeouts currently configured for the current session.

  See Also

  • #setTimeouts()

method legacyTimeout

legacyTimeout: (driver: WebDriver, type: string, ms: number) => Promise<void>;

• Parameter driver

  Parameter type

  Parameter ms

  {!Promise}

method logs

logs: () => Logs;

• {!Logs} The interface for managing driver logs.

method setTimeouts

setTimeouts: (timeouts: ITimeouts) => Promise<void>;

• Sets the timeout durations associated with the current session.

  The following timeouts are supported (all timeouts are specified in milliseconds):

  - implicit specifies the maximum amount of time to wait for an element locator to succeed when on the page. Defaults to 0 milliseconds.

  - pageLoad specifies the maximum amount of time to wait for a page to finishing loading. Defaults to 300000 milliseconds.

  - script specifies the maximum amount of time to wait for an to run. If set to null, the script timeout will be indefinite. Defaults to 30000 milliseconds.

  Parameter conf

  The desired timeout configuration. {!Promise} A promise that will be resolved when the timeouts have been set.

  Throws

  {!TypeError} if an invalid options object is provided.

  See Also

  • #getTimeouts()

  • <https://w3c.github.io/webdriver/webdriver-spec.html#dfn-set-timeouts>

method window

window: () => Window;

• {!Window} The interface for managing the current window.

constructor

constructor(findDetails: By, filters: Object[]);

• Parameter findDetails

  Parameter filters

method above

above: (locatorOrElement: Locator | WebElement) => RelativeBy;

• Look for elements above the root element passed in

  Parameter locatorOrElement

  {!RelativeBy} Return this object

method below

below: (locatorOrElement: Locator | WebElement) => RelativeBy;

• Look for elements below the root element passed in

  Parameter locatorOrElement

  {!RelativeBy} Return this object

method marshall

marshall: () => Object;

• Returns a marshalled version of the RelativeBy {!Object} Object representation of a WebElement that will be used in .

method near

near: (locatorOrElement: Locator | WebElement) => RelativeBy;

• Look for elements near the root element passed in

  Parameter locatorOrElement

  {!RelativeBy} Return this object

method toLeftOf

toLeftOf: (locatorOrElement: Locator | WebElement) => RelativeBy;

• Look for elements left the root element passed in

  Parameter locatorOrElement

  {!RelativeBy} Return this object

method toRightOf

toRightOf: (locatorOrElement: Locator | WebElement) => RelativeBy;

• Look for elements right the root element passed in

  Parameter locatorOrElement

  {!RelativeBy} Return this object

method toString

toString: () => string;

• Modifiers

  • @override

constructor

constructor(id: string, capabilities: {} | Capabilities);

• Parameter id

  The session ID.

  Parameter capabilities

  The session capabilities.

method getCapabilities

getCapabilities: () => Capabilities;

• {!Capabilities} This session's capabilities.

method getCapability

getCapability: (key: string) => any;

• Retrieves the value of a specific capability.

  Parameter key

  The capability to retrieve. {*} The capability value.

method getId

getId: () => string;

• {string} This session's ID.

method toJSON

toJSON: () => string;

• Returns the JSON representation of this object, which is just the string session ID. {string} The JSON representation of this Session.

constructor

constructor(driver: WebDriver);

• Parameter driver

  The parent driver.

method activeElement

activeElement: () => WebElementPromise;

• Locates the DOM element on the current page that corresponds to document.activeElement or document.body if the active element is not available.

  {!WebElementPromise} The active element.

method alert

alert: () => AlertPromise;

• Changes focus to the active modal dialog, such as those opened by window.alert(), window.confirm(), and window.prompt(). The returned promise will be rejected with a if there are no open alerts.

  {!AlertPromise} The open alert.

method defaultContent

defaultContent: () => Promise<void>;

• Switches focus of all future commands to the topmost frame in the current window.

  {!Promise} A promise that will be resolved when the driver has changed focus to the default content.

method frame

frame: (id: number | string | WebElement | null) => Promise<void>;

• Changes the focus of all future commands to another frame on the page. The target frame may be specified as one of the following:

  - A number that specifies a (zero-based) index into [window.frames]( https://developer.mozilla.org/en-US/docs/Web/API/Window.frames). - A WebElement reference, which correspond to a frame or iframe DOM element. - The null value, to select the topmost frame on the page. Passing null is the same as calling .

  If the specified frame can not be found, the returned promise will be rejected with a .

  Parameter id

  The frame locator. {!Promise} A promise that will be resolved when the driver has changed focus to the specified frame.

method newWindow

newWindow: (typeHint: string) => Promise<void>;

• Creates a new browser window and switches the focus for future commands of this driver to the new window.

  Parameter typeHint

  'window' or 'tab'. The created window is not guaranteed to be of the requested type; if the driver does not support the requested type, a new browser window will be created of whatever type the driver does support. {!Promise} A promise that will be resolved when the driver has changed focus to the new window.

method parentFrame

parentFrame: () => Promise<void>;

• Changes the focus of all future commands to the parent frame of the currently selected frame. This command has no effect if the driver is already focused on the top-level browsing context.

  {!Promise} A promise that will be resolved when the command has completed.

method window

window: (nameOrHandle: string) => Promise<void>;

• Changes the focus of all future commands to another window. Windows may be specified by their attribute or by its handle (as returned by WebDriver#getWindowHandles).

  If the specified window cannot be found, the returned promise will be rejected with a .

  Parameter nameOrHandle

  The name or window handle of the window to switch focus to. {!Promise} A promise that will be resolved when the driver has changed focus to the specified window.

constructor

constructor(driver: WebDriver);

method doubleTap

doubleTap: (elem: WebElement) => TouchSequence;

• Double taps an element.

  Parameter elem

  The element to double tap. {!TouchSequence} A self reference.

method flick

flick: (speed: ISpeed) => TouchSequence;

• Flick, starting anywhere on the screen, at speed xspeed and yspeed.

  Parameter speed

  The speed to flick in each direction, in pixels per second. {!TouchSequence} A self reference.

method flickElement

flickElement: (
    elem: WebElement,
    offset: IOffset,
    speed: number
) => TouchSequence;

• Flick starting at elem and moving by x and y at specified speed.

  Parameter elem

  The element where flick starts.

  Parameter offset

  The offset to flick to.

  Parameter speed

  The speed to flick at in pixels per second. {!TouchSequence} A self reference.

method longPress

longPress: (elem: WebElement) => TouchSequence;

• Long press on an element.

  Parameter elem

  The element to long press. {!TouchSequence} A self reference.

method move

move: (location: ILocation) => TouchSequence;

• Move a held to the specified location.

  Parameter location

  The location to move to. {!TouchSequence} A self reference.

method perform

perform: () => Promise<void>;

• Executes this action sequence. {!Promise} A promise that will be resolved once this sequence has completed.

method release

release: (location: ILocation) => TouchSequence;

• Release a held at the specified location.

  Parameter location

  The location to release at. {!TouchSequence} A self reference.

method scroll

scroll: (offset: IOffset) => TouchSequence;

• Scrolls the touch screen by the given offset.

  Parameter offset

  The offset to scroll to. {!TouchSequence} A self reference.

method scrollFromElement

scrollFromElement: (elem: WebElement, offset: IOffset) => TouchSequence;

• Scrolls the touch screen, starting on elem and moving by the specified offset.

  Parameter elem

  The element where scroll starts.

  Parameter offset

  The offset to scroll to. {!TouchSequence} A self reference.

method tap

tap: (elem: WebElement) => TouchSequence;

• Taps an element.

  Parameter elem

  The element to tap. {!TouchSequence} A self reference.

method tapAndHold

tapAndHold: (location: ILocation) => TouchSequence;

• Touch down at the given location.

  Parameter location

  The location to touch down at. {!TouchSequence} A self reference.

constructor

constructor(
    session: Session | Promise<Session>,
    executor: Executor,
    onQuit?: (this: void) => any
);

• Parameter session

  Either a known session or a promise that will be resolved to a session.

  Parameter executor

  The executor to use when sending commands to the browser.

  Parameter onQuit

  A function to call, if any, when the session is terminated.

method actions

actions: (options?: {
    async?: boolean | undefined;
    bridge?: boolean | undefined;
}) => Actions;

• Modifiers

  • @override

method close

close: () => Promise<void>;

• Closes the current window.

  {!Promise} A promise that will be resolved when this command has completed.

method createCDPConnection

createCDPConnection: (target: string) => Promise<any>;

• Creates a new WebSocket connection. {!Promise} A new CDP instance.

method createSession

static createSession: (...var_args: any[]) => WebDriver;

• Creates a new WebDriver session.

  This function will always return a WebDriver instance. If there is an error creating the session, such as the aforementioned SessionNotCreatedError, the driver will have a rejected promise. This rejection will propagate through any subsequent commands scheduled on the returned WebDriver instance.

  let required = Capabilities.firefox(); let driver = WebDriver.createSession(executor, {required});

  // If the createSession operation failed, then this command will also // also fail, propagating the creation failure. driver.get('http://www.google.com').catch(e => console.log(e));

  Parameter executor

  The executor to create the new session with.

  Parameter capabilities

  The desired capabilities for the new session.

  Parameter onQuit

  A callback to invoke when the newly created session is terminated. This should be used to clean up any resources associated with the session. {!WebDriver} The driver for the newly created session.

method execute

execute: (command: Command) => Promise<void>;

• Modifiers

  • @override

method executeAsyncScript

executeAsyncScript: <T>(script: string | Function, ...args: any[]) => Promise<T>;

• Executes a snippet of asynchronous JavaScript in the context of the currently selected frame or window. The script fragment will be executed as the body of an anonymous function. If the script is provided as a function object, that function will be converted to a string for injection into the target window.

  Any arguments provided in addition to the script will be included as script arguments and may be referenced using the arguments object. Arguments may be a boolean, number, string, or . Arrays and objects may also be used as script arguments as long as each item adheres to the types previously mentioned.

  Unlike executing synchronous JavaScript with , scripts executed with this function must explicitly signal they are finished by invoking the provided callback. This callback will always be injected into the executed function as the last argument, and thus may be referenced with arguments[arguments.length - 1]. The following steps will be taken for resolving this functions return value against the first argument to the script's callback function:

  - For a HTML element, the value will resolve to a WebElement - Null and undefined return values will resolve to null - Booleans, numbers, and strings will resolve as is - Functions will resolve to their string representation - For arrays and objects, each member item will be converted according to the rules above

  __Example #1:__ Performing a sleep that is synchronized with the currently selected window:

  var start = new Date().getTime(); driver.executeAsyncScript( 'window.setTimeout(arguments[arguments.length - 1], 500);'). then(function() { console.log( 'Elapsed time: ' + (new Date().getTime() - start) + ' ms'); });

  __Example #2:__ Synchronizing a test with an AJAX application:

  var button = driver.findElement(By.id('compose-button')); button.click(); driver.executeAsyncScript( 'var callback = arguments[arguments.length - 1];' + 'mailClient.getComposeWindowWidget().onload(callback);'); driver.switchTo().frame('composeWidget'); driver.findElement(By.id('to')).sendKeys('dog@example.com');

  __Example #3:__ Injecting a XMLHttpRequest and waiting for the result. In this example, the inject script is specified with a function literal. When using this format, the function is converted to a string for injection, so it should not reference any symbols not defined in the scope of the page under test.

  driver.executeAsyncScript(function() { var callback = arguments[arguments.length - 1]; var xhr = new XMLHttpRequest(); xhr.open("GET", "/resource/data.json", true); xhr.onreadystatechange = function() { if (xhr.readyState == 4) { callback(xhr.responseText); } }; xhr.send(''); }).then(function(str) { console.log(JSON.parse(str)['food']); });

  Parameter script

  The script to execute.

  Parameter args

  The arguments to pass to the script. {!IThenable} A promise that will resolve to the scripts return value. T

method executeScript

executeScript: <T>(script: string | Function, ...args: any[]) => Promise<T>;

• Modifiers

  • @override

method findElement

findElement: (locator: Locator) => WebElementPromise;

• Locates an element on the page. If the element cannot be found, a error.NoSuchElementError will be returned by the driver.

  This function should not be used to test whether an element is present on the page. Rather, you should use :

  driver.findElements(By.id('foo')) .then(found => console.log('Element found? %s', !!found.length));

  The search criteria for an element may be defined using one of the factories in the webdriver.By namespace, or as a short-hand webdriver.By.Hash object. For example, the following two statements are equivalent:

  var e1 = driver.findElement(By.id('foo')); var e2 = driver.findElement({id:'foo'});

  You may also provide a custom locator function, which takes as input this instance and returns a WebElement, or a promise that will resolve to a WebElement. If the returned promise resolves to an array of WebElements, WebDriver will use the first element. For example, to find the first visible link on a page, you could write:

  var link = driver.findElement(firstVisibleLink);

  function firstVisibleLink(driver) { var links = driver.findElements(By.tagName('a')); return promise.filter(links, function(link) { return link.isDisplayed(); }); }

  Parameter locator

  The locator to use. {!WebElementPromise} A WebElement that can be used to issue commands against the located element. If the element is not found, the element will be invalidated and all scheduled commands aborted.

method findElementInternal_

findElementInternal_: (
    locatorFn: Function,
    context: WebDriver | WebElement
) => Promise<WebElement>;

• Parameter locatorFn

  The locator function to use.

  Parameter context

  The search context. {!Promise<!WebElement>} A promise that will resolve to a list of WebElements.

method findElements

findElements: (locator: Locator) => Promise<WebElement[]>;

• Search for multiple elements on the page. Refer to the documentation on for information on element locator strategies.

  Parameter locator

  The locator to use. {!Promise<!Array<!WebElement>>} A promise that will resolve to an array of WebElements.

method findElementsInternal_

findElementsInternal_: (
    locatorFn: Function,
    context: WebDriver | WebElement
) => Promise<WebElement[]>;