@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 authenticateAs

authenticateAs: (username: string, password: string) => Promise<void>;

• Sets the username and password in an alert prompting for credentials (such as a Basic HTTP Auth prompt). This method will implicitly the dialog.

  Parameter username

  The username to send.

  Parameter password

  The password to send. {!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(driver: WebDriver, alert: Promise<Alert>);

• Parameter driver

  The driver controlling the browser this alert is attached to.

  Parameter alert

  A thenable that will be fulfilled with the promised alert.

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.

method deleteNetworkConditions

deleteNetworkConditions: () => Promise<any>;

• Schedules a command to delete Chromium network emulation settings. {!Promise} A promise that will be resolved when network emulation settings have been deleted.

method getCastIssueMessage

getCastIssueMessage: () => Promise<string>;

• Returns an error message when there is any issue in a Cast session. {!promise.Thenable} A promise that will be resolved when the mirror command has been issued to the device.

method getCastSinks

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

• Returns the list of cast sinks (Cast devices) available to the Chrome media router.

  {!promise.Thenable} A promise that will be resolved with an array of Strings containing the friendly device names of available cast sink targets.

method getNetworkConditions

getNetworkConditions: () => Promise<any>;

• Schedules a command to get Chromium network emulation settings. {!Promise} A promise that will be resolved when network emulation settings are retrievied.

method launchApp

launchApp: (id: string) => Promise<void>;

• Schedules a command to launch Chrome App with given ID.

  Parameter id

  ID of the App to launch. {!Promise} A promise that will be resolved when app is launched.

method sendAndGetDevToolsCommand

sendAndGetDevToolsCommand: (cmd: string, params: Object) => Promise<string>;

• Sends an arbitrary devtools command to the browser and get the result.

  Parameter cmd

  The name of the command to send.

  Parameter params

  The command parameters. {!Promise} A promise that will be resolved when the command has finished.

  See Also

  • <https://chromedevtools.github.io/devtools-protocol/>

method sendDevToolsCommand

sendDevToolsCommand: (cmd: string, params: Object) => Promise<void>;

• Sends an arbitrary devtools command to the browser.

  Parameter cmd

  The name of the command to send.

  Parameter params

  The command parameters. {!Promise} A promise that will be resolved when the command has finished.

  See Also

  • <https://chromedevtools.github.io/devtools-protocol/>

method setCastSinkToUse

setCastSinkToUse: (deviceName: string) => Promise<void>;

• Selects a cast sink (Cast device) as the recipient of media router intents (connect or play).

  Parameter deviceName

  name of the target device. {!promise.Thenable} A promise that will be resolved when the target device has been selected to respond further webdriver commands.

method setDownloadPath

setDownloadPath: (path: string) => Promise<void>;

• Sends a DevTools command to change the browser's download directory.

  Parameter path

  The desired download directory. {!Promise} A promise that will be resolved when the command has finished.

  See Also

  • #sendDevToolsCommand

method setFileDetector

setFileDetector: () => void;

• This function is a no-op as file detectors are not supported by this implementation.

  Modifiers

  • @override

method setNetworkConditions

setNetworkConditions: (spec: Object) => Promise<void>;

• Schedules a command to set Chromium network emulation settings.

  __Sample Usage:__

  driver.setNetworkConditions({ offline: false, latency: 5, // Additional latency (ms). download_throughput: 500 * 1024, // Maximal aggregated download throughput. upload_throughput: 500 * 1024 // Maximal aggregated upload throughput. });

  Parameter spec

  Defines the network conditions to set {!Promise} A promise that will be resolved when network emulation settings are set.

method setPermission

setPermission: (
    name: string,
    state: 'granted' | 'denied' | 'prompt'
) => Promise<Object>;

• Set a permission state to the given value.

  Parameter name

  A name of the permission to update.

  Parameter state

  State to set permission to.

  Returns

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

  See Also

  • <https://w3c.github.io/permissions/#permission-registry> for valid names

method startCastTabMirroring

startCastTabMirroring: (deviceName: string) => Promise<void>;

• Initiates tab mirroring for the current browser tab on the specified device.

  Parameter deviceName

  name of the target device. {!promise.Thenable} A promise that will be resolved when the mirror command has been issued to the device.

method startDesktopMirroring

startDesktopMirroring: (deviceName: string) => Promise<void>;

• Initiates desktop mirroring for the current browser tab on the specified device.

  Parameter deviceName

  name of the target device. {!promise.Thenable} A promise that will be resolved when the mirror command has been issued to the device.

method stopCasting

stopCasting: (deviceName: string) => Promise<void>;

• Stops casting from media router to the specified device, if connected.

  Parameter deviceName

  name of the target device. {!promise.Thenable} A promise that will be resolved when the stop command has been issued to the device.

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.

method fn

fn: (webdriver: WebDriver) => ConditionFn<T>;

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.

constructor

constructor();

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, otherwisee 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);

• Interface for navigating back and forth in the browser history.

  This class should never be instantiated directly. Insead, obtain an instance with

  navigate()

  See Also

  • WebDriver#navigate()

method back

back: () => Promise<void>;

• Schedules a command to move backwards in the browser history. {!Promise.} A promise that will be resolved when the navigation event has completed.

method forward

forward: () => Promise<void>;

• Schedules a command to move forwards in the browser history. {!Promise.} A promise that will be resolved when the navigation event has completed.

method refresh

refresh: () => Promise<void>;

• Schedules a command to refresh the current page. {!Promise.} A promise that will be resolved when the navigation event has completed.

method to

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

• Schedules a command to navigate 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>;

• Schedules a command to add a cookie.

  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>;

• Schedules a command to delete 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>;

• Schedules a command to delete 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<IWebDriverCookie>;

• Schedules a command to retrieve 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} A promise that will be resolved with the named cookie, or if there is no such cookie.

  See Also

  • http://code.google.com/p/selenium/wiki/JsonWireProtocol#Cookie_JSON_Object

method getCookies

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

• Schedules a command to retrieve all cookies visible to the current page. Each cookie will be returned as a JSON object as described by the WebDriver wire protocol. {!Promise} A promise that will be resolved with the cookies visible to the current page.

  See Also

  • http://code.google.com/p/selenium/wiki/JsonWireProtocol#Cookie_JSON_Object

method getTimeouts

getTimeouts: () => Promise<ITimeouts>;

• The current timeouts

method logs

logs: () => Logs;

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

method setTimeouts

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

• Set current 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;

• Schedules a command retrieve the element on the current document, or if activeElement is not available. {!WebElement} The active element.

method alert

alert: () => AlertPromise;

• Schedules a command to change 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>;

• Schedules a command to switch focus of all future commands to the first frame on the page. {!Promise} A promise that will be resolved when the driver has changed focus to the default content.

method frame

frame: (id: number | 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>;

• Schedules a command to switch 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;