typings(selenium): try out new version of typings

.travis.yml

@@ -36,13 +36,13 @@ addons:
       - g++-4.8
 
 before_install:
-  - g++-4.8 --version
+  - travis_wait g++-4.8 --version
 
 before_script:
   - npm run install_testapp
   - npm run pretest
   - mkdir -p $LOGS_DIR
-  - ./scripts/travis_setup.sh
+  - travis_wait ./scripts/travis_setup.sh
 
 
 script:

lib/locators.ts

@@ -80,7 +80,7 @@ export class ProtractorBy extends WebdriverBy {
     this[name] = (...args: any[]): ProtractorLocator => {
       const locatorArguments = args;
       return {
-        findElementsOverride: (driver: WebDriver, using: WebElement, rootSelector: string):
+        findElementsOverride: async(driver: WebDriver, using: WebElement, rootSelector: string):
             Promise<WebElement[]> => {
               let findElementArguments: any[] = [script];
               for (let i = 0; i < locatorArguments.length; i++) {
@@ -89,9 +89,7 @@ export class ProtractorBy extends WebdriverBy {
               findElementArguments.push(using);
               findElementArguments.push(rootSelector);
 
-              // TODO(selenium4): clean up cast to native Promise.
-              return driver.findElements(By.js.apply(By, findElementArguments)) as
-                  Promise<WebElement[]>;
+              return await driver.findElements(By.js.apply(By, findElementArguments));
             },
         toString: (): string => {
           return 'by.' + name + '("' + Array.prototype.join.call(locatorArguments, '", "') + '")';
@@ -132,12 +130,10 @@ export class ProtractorBy extends WebdriverBy {
    */
   binding(bindingDescriptor: string): ProtractorLocator {
     return {
-      findElementsOverride: (driver: WebDriver, using: WebElement, rootSelector: string):
+      findElementsOverride: async(driver: WebDriver, using: WebElement, rootSelector: string):
           Promise<WebElement[]> => {
-            // TODO(selenium4): clean up cast to native Promise.
-            return driver.findElements(By.js(
-                       clientSideScripts.findBindings, bindingDescriptor, false, using,
-                       rootSelector)) as Promise<WebElement[]>;
+            return await driver.findElements(By.js(
+                clientSideScripts.findBindings, bindingDescriptor, false, using, rootSelector));
           },
       toString: (): string => {
         return 'by.binding("' + bindingDescriptor + '")';
@@ -166,13 +162,11 @@ export class ProtractorBy extends WebdriverBy {
    */
   exactBinding(bindingDescriptor: string): ProtractorLocator {
     return {
-      findElementsOverride: (
-          driver: WebDriver, using: WebElement, rootSelector: string): Promise<WebElement[]> => {
-        // TODO(selenium4): clean up cast to native Promise.
-        return driver.findElements(By.js(
-                   clientSideScripts.findBindings, bindingDescriptor, true, using, rootSelector)) as
-            Promise<WebElement[]>;
-      },
+      findElementsOverride: async(driver: WebDriver, using: WebElement, rootSelector: string):
+          Promise<WebElement[]> => {
+            return await driver.findElements(By.js(
+                clientSideScripts.findBindings, bindingDescriptor, true, using, rootSelector));
+          },
       toString: (): string => {
         return 'by.exactBinding("' + bindingDescriptor + '")';
       }
@@ -196,12 +190,10 @@ export class ProtractorBy extends WebdriverBy {
    */
   model(model: string): ProtractorLocator {
     return {
-      findElementsOverride: (driver: WebDriver, using: WebElement, rootSelector: string):
+      findElementsOverride: async(driver: WebDriver, using: WebElement, rootSelector: string):
           Promise<WebElement[]> => {
-            // TODO(selenium4): clean up cast to native Promise.
-            return driver.findElements(
-                       By.js(clientSideScripts.findByModel, model, using, rootSelector)) as
-                Promise<WebElement[]>;
+            return await driver.findElements(
+                By.js(clientSideScripts.findByModel, model, using, rootSelector));
           },
       toString: (): string => {
         return 'by.model("' + model + '")';
@@ -223,12 +215,10 @@ export class ProtractorBy extends WebdriverBy {
    */
   buttonText(searchText: string): ProtractorLocator {
     return {
-      findElementsOverride: (driver: WebDriver, using: WebElement, rootSelector: string):
+      findElementsOverride: async(driver: WebDriver, using: WebElement, rootSelector: string):
           Promise<WebElement[]> => {
-            // TODO(selenium4): clean up cast to native Promise.
-            return driver.findElements(By.js(
-                       clientSideScripts.findByButtonText, searchText, using, rootSelector)) as
-                Promise<WebElement[]>;
+            return driver.findElements(
+                By.js(clientSideScripts.findByButtonText, searchText, using, rootSelector));
           },
       toString: (): string => {
         return 'by.buttonText("' + searchText + '")';
@@ -250,13 +240,11 @@ export class ProtractorBy extends WebdriverBy {
    */
   partialButtonText(searchText: string): ProtractorLocator {
     return {
-      findElementsOverride: (
-          driver: WebDriver, using: WebElement, rootSelector: string): Promise<WebElement[]> => {
-        // TODO(selenium4): clean up cast to native Promise.
-        return driver.findElements(By.js(
-                   clientSideScripts.findByPartialButtonText, searchText, using, rootSelector)) as
-            Promise<WebElement[]>;
-      },
+      findElementsOverride: async(driver: WebDriver, using: WebElement, rootSelector: string):
+          Promise<WebElement[]> => {
+            return driver.findElements(
+                By.js(clientSideScripts.findByPartialButtonText, searchText, using, rootSelector));
+          },
       toString: (): string => {
         return 'by.partialButtonText("' + searchText + '")';
       }
@@ -267,36 +255,34 @@ export class ProtractorBy extends WebdriverBy {
   private byRepeaterInner(exact: boolean, repeatDescriptor: string): ProtractorLocator {
     let name = 'by.' + (exact ? 'exactR' : 'r') + 'epeater';
     return {
-      findElementsOverride: (driver: WebDriver, using: WebElement, rootSelector: string):
-          Promise<WebElement[]> => {
-            // TODO(selenium4): clean up cast to native Promise.
-            return driver.findElements(By.js(
-                       clientSideScripts.findAllRepeaterRows, repeatDescriptor, exact, using,
-                       rootSelector)) as Promise<WebElement[]>;
-          },
+      findElementsOverride: async(
+          driver: WebDriver, using: WebElement, rootSelector: string): Promise<WebElement[]> => {
+        return driver.findElements(By.js(
+            clientSideScripts.findAllRepeaterRows, repeatDescriptor, exact, using, rootSelector));
+      },
       toString: (): string => {
         return name + '("' + repeatDescriptor + '")';
       },
       row: (index: number): ProtractorLocator => {
         return {
-          findElementsOverride: (driver: WebDriver, using: WebElement, rootSelector: string):
+          findElementsOverride: async(driver: WebDriver, using: WebElement, rootSelector: string):
               Promise<WebElement[]> => {
-                return driver.findElements(By.js(
-                           clientSideScripts.findRepeaterRows, repeatDescriptor, exact, index,
-                           using, rootSelector)) as Promise<WebElement[]>;
+                return await driver.findElements(By.js(
+                    clientSideScripts.findRepeaterRows, repeatDescriptor, exact, index, using,
+                    rootSelector));
               },
           toString: (): string => {
             return name + '(' + repeatDescriptor + '").row("' + index + '")"';
           },
           column: (binding: string): ProtractorLocator => {
             return {
-              findElementsOverride: (driver: WebDriver, using: WebElement, rootSelector: string):
-                  Promise<WebElement[]> => {
-                    // TODO(selenium4): clean up cast to native Promise.
-                    return driver.findElements(By.js(
-                               clientSideScripts.findRepeaterElement, repeatDescriptor, exact,
-                               index, binding, using, rootSelector)) as Promise<WebElement[]>;
-                  },
+              findElementsOverride:
+                  async(driver: WebDriver, using: WebElement, rootSelector: string):
+                      Promise<WebElement[]> => {
+                        return driver.findElements(By.js(
+                            clientSideScripts.findRepeaterElement, repeatDescriptor, exact, index,
+                            binding, using, rootSelector));
+                      },
               toString: (): string => {
                 return name + '("' + repeatDescriptor + '").row("' + index + '").column("' +
                     binding + '")';
@@ -307,25 +293,24 @@ export class ProtractorBy extends WebdriverBy {
       },
       column: (binding: string): ProtractorLocator => {
         return {
-          findElementsOverride: (driver: WebDriver, using: WebElement, rootSelector: string):
+          findElementsOverride: async(driver: WebDriver, using: WebElement, rootSelector: string):
               Promise<WebElement[]> => {
-                // TODO(selenium4): clean up cast to native Promise.
                 return driver.findElements(By.js(
-                           clientSideScripts.findRepeaterColumn, repeatDescriptor, exact, binding,
-                           using, rootSelector)) as Promise<WebElement[]>;
+                    clientSideScripts.findRepeaterColumn, repeatDescriptor, exact, binding, using,
+                    rootSelector));
               },
           toString: (): string => {
             return name + '("' + repeatDescriptor + '").column("' + binding + '")';
           },
           row: (index: number): ProtractorLocator => {
             return {
-              findElementsOverride: (driver: WebDriver, using: WebElement, rootSelector: string):
-                  Promise<WebElement[]> => {
-                    // TODO(selenium4): clean up cast to native Promise.
-                    return driver.findElements(By.js(
-                               clientSideScripts.findRepeaterElement, repeatDescriptor, exact,
-                               index, binding, using, rootSelector)) as Promise<WebElement[]>;
-                  },
+              findElementsOverride:
+                  async(driver: WebDriver, using: WebElement, rootSelector: string):
+                      Promise<WebElement[]> => {
+                        return driver.findElements(By.js(
+                            clientSideScripts.findRepeaterElement, repeatDescriptor, exact, index,
+                            binding, using, rootSelector));
+                      },
               toString: (): string => {
                 return name + '("' + repeatDescriptor + '").column("' + binding + '").row("' +
                     index + '")';
@@ -437,12 +422,11 @@ export class ProtractorBy extends WebdriverBy {
   cssContainingText(cssSelector: string, searchText: string|RegExp): ProtractorLocator {
     searchText = (searchText instanceof RegExp) ? '__REGEXP__' + searchText.toString() : searchText;
     return {
-      findElementsOverride: (driver: WebDriver, using: WebElement, rootSelector: string):
+      findElementsOverride: async(driver: WebDriver, using: WebElement, rootSelector: string):
           Promise<WebElement[]> => {
-            // TODO(selenium4): clean up cast to native Promise.
-            return driver.findElements(By.js(
-                       clientSideScripts.findByCssContainingText, cssSelector, searchText, using,
-                       rootSelector)) as Promise<WebElement[]>;
+            return await driver.findElements(By.js(
+                clientSideScripts.findByCssContainingText, cssSelector, searchText, using,
+                rootSelector));
           },
       toString: (): string => {
         return 'by.cssContainingText("' + cssSelector + '", "' + searchText + '")';
@@ -471,12 +455,10 @@ export class ProtractorBy extends WebdriverBy {
    */
   options(optionsDescriptor: string): ProtractorLocator {
     return {
-      findElementsOverride: (driver: WebDriver, using: WebElement, rootSelector: string):
+      findElementsOverride: async(driver: WebDriver, using: WebElement, rootSelector: string):
           Promise<WebElement[]> => {
-            // TODO(selenium4): clean up cast to native Promise.
-            return driver.findElements(By.js(
-                       clientSideScripts.findByOptions, optionsDescriptor, using, rootSelector)) as
-                Promise<WebElement[]>;
+            return await driver.findElements(
+                By.js(clientSideScripts.findByOptions, optionsDescriptor, using, rootSelector));
           },
       toString: (): string => {
         return 'by.option("' + optionsDescriptor + '")';

package.json

@@ -13,7 +13,6 @@
   "author": "Julie Ralph <[email protected]>",
   "dependencies": {
     "@types/node": "^6.0.46",
-    "@types/selenium-webdriver": "^3.0.0",
     "blocking-proxy": "^1.0.0",
     "browserstack": "^1.5.1",
     "chalk": "^1.1.3",

tsconfig.json

@@ -16,6 +16,7 @@
     "website",
     "scripts",
     "exampleTypescript",
-    "spec/**/*"
+    "spec/**/*",
+    "typings"
   ]
 }

typings/chrome.d.ts

@@ -0,0 +1,362 @@
+import * as webdriver from './index';
+import * as remote from './remote';
+import * as http from './http';
+
+/**
+ * Creates a new WebDriver client for Chrome.
+ *
+ * @extends {webdriver.WebDriver}
+ */
+export class Driver extends webdriver.WebDriver {
+    /**
+     * Creates a new session with the ChromeDriver.
+     *
+     * @param {(Capabilities|Options)=} opt_config The configuration options.
+     * @param {(remote.DriverService|http.Executor)=} opt_serviceExecutor Either
+     *     a  DriverService to use for the remote end, or a preconfigured executor
+     *     for an externally managed endpoint. If neither is provided, the
+     *     {@linkplain ##getDefaultService default service} will be used by
+     *     default.
+     * @param {promise.ControlFlow=} opt_flow The control flow to use, or `null`
+     *     to use the currently active flow.
+     * @return {!Driver} A new driver instance.
+     */
+    static createSession(opt_config?: Options | webdriver.CreateSessionCapabilities, opt_service?: remote.DriverService | http.Executor, opt_flow?: webdriver.promise.ControlFlow): Driver;
+}
+
+export interface IOptionsValues {
+    args: string[];
+    binary?: string;
+    detach: boolean;
+    extensions: string[];
+    localState?: any;
+    logFile?: string;
+    prefs?: any;
+}
+
+export interface IPerfLoggingPrefs {
+    enableNetwork: boolean;
+    enablePage: boolean;
+    enableTimeline: boolean;
+    tracingCategories: string;
+    bufferUsageReportingInterval: number;
+}
+
+/**
+ * Class for managing ChromeDriver specific options.
+ */
+export class Options {
+    /**
+     * @constructor
+     */
+    constructor();
+
+    /**
+     * Extracts the ChromeDriver specific options from the given capabilities
+     * object.
+     * @param {!webdriver.Capabilities} capabilities The capabilities object.
+     * @return {!Options} The ChromeDriver options.
+     */
+    static fromCapabilities(capabilities: webdriver.Capabilities): Options;
+
+    /**
+     * Add additional command line arguments to use when launching the Chrome
+     * browser.  Each argument may be specified with or without the '--' prefix
+     * (e.g. '--foo' and 'foo'). Arguments with an associated value should be
+     * delimited by an '=': 'foo=bar'.
+     * @param {...(string|!Array.<string>)} var_args The arguments to add.
+     * @return {!Options} A self reference.
+     */
+    addArguments(...var_args: string[]): Options;
+
+    /**
+     * Configures the chromedriver to start Chrome in headless mode.
+     *
+     * > __NOTE:__ Resizing the browser window in headless mode is only supported
+     * > in Chrome 60. Users are encouraged to set an initial window size with
+     * > the {@link #windowSize windowSize({width, height})} option.
+     *
+     * @return {!Options} A self reference.
+     */
+    headless(): Options;
+
+    /**
+     * List of Chrome command line switches to exclude that ChromeDriver by default
+     * passes when starting Chrome.  Do not prefix switches with '--'.
+     *
+     * @param {...(string|!Array<string>)} var_args The switches to exclude.
+     * @return {!Options} A self reference.
+     */
+    excludeSwitches(...var_args: string[]): Options;
+
+    /**
+     * Add additional extensions to install when launching Chrome. Each extension
+     * should be specified as the path to the packed CRX file, or a Buffer for an
+     * extension.
+     * @param {...(string|!Buffer|!Array.<(string|!Buffer)>)} var_args The
+     *     extensions to add.
+     * @return {!Options} A self reference.
+     */
+    addExtensions(...var_args: any[]): Options;
+
+    /**
+     * Sets the path to the Chrome binary to use. On Mac OS X, this path should
+     * reference the actual Chrome executable, not just the application binary
+     * (e.g. '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome').
+     *
+     * The binary path be absolute or relative to the chromedriver server
+     * executable, but it must exist on the machine that will launch Chrome.
+     *
+     * @param {string} path The path to the Chrome binary to use.
+     * @return {!Options} A self reference.
+     */
+    setChromeBinaryPath(path: string): Options;
+
+    /**
+     * Sets whether to leave the started Chrome browser running if the controlling
+     * ChromeDriver service is killed before {@link webdriver.WebDriver#quit()} is
+     * called.
+     * @param {boolean} detach Whether to leave the browser running if the
+     *     chromedriver service is killed before the session.
+     * @return {!Options} A self reference.
+     */
+    detachDriver(detach: boolean): Options;
+
+    /**
+     * Sets the user preferences for Chrome's user profile. See the 'Preferences'
+     * file in Chrome's user data directory for examples.
+     * @param {!Object} prefs Dictionary of user preferences to use.
+     * @return {!Options} A self reference.
+     */
+    setUserPreferences(prefs: any): Options;
+
+    /**
+     * Sets the logging preferences for the new session.
+     * @param {!webdriver.logging.Preferences} prefs The logging preferences.
+     * @return {!Options} A self reference.
+     */
+    setLoggingPrefs(prefs: webdriver.logging.Preferences): Options;
+
+    /**
+     * Sets the performance logging preferences. Options include:
+     *
+     * - `enableNetwork`: Whether or not to collect events from Network domain.
+     * - `enablePage`: Whether or not to collect events from Page domain.
+     * - `enableTimeline`: Whether or not to collect events from Timeline domain.
+     *     Note: when tracing is enabled, Timeline domain is implicitly disabled,
+     *     unless `enableTimeline` is explicitly set to true.
+     * - `tracingCategories`: A comma-separated string of Chrome tracing categories
+     *     for which trace events should be collected. An unspecified or empty
+     *     string disables tracing.
+     * - `bufferUsageReportingInterval`: The requested number of milliseconds
+     *     between DevTools trace buffer usage events. For example, if 1000, then
+     *     once per second, DevTools will report how full the trace buffer is. If a
+     *     report indicates the buffer usage is 100%, a warning will be issued.
+     *
+     * @param {{enableNetwork: boolean,
+     *          enablePage: boolean,
+     *          enableTimeline: boolean,
+     *          tracingCategories: string,
+     *          bufferUsageReportingInterval: number}} prefs The performance
+     *     logging preferences.
+     * @return {!Options} A self reference.
+     */
+    setPerfLoggingPrefs(prefs: IPerfLoggingPrefs): Options;
+
+    /**
+     * Sets preferences for the 'Local State' file in Chrome's user data
+     * directory.
+     * @param {!Object} state Dictionary of local state preferences.
+     * @return {!Options} A self reference.
+     */
+    setLocalState(state: any): Options;
+
+    /**
+     * Sets the name of the activity hosting a Chrome-based Android WebView. This
+     * option must be set to connect to an [Android WebView](
+     * https://sites.google.com/a/chromium.org/chromedriver/getting-started/getting-started---android)
+     *
+     * @param {string} name The activity name.
+     * @return {!Options} A self reference.
+     */
+    androidActivity(name: string): Options;
+
+    /**
+     * Sets the device serial number to connect to via ADB. If not specified, the
+     * ChromeDriver will select an unused device at random. An error will be
+     * returned if all devices already have active sessions.
+     *
+     * @param {string} serial The device serial number to connect to.
+     * @return {!Options} A self reference.
+     */
+    androidDeviceSerial(serial: string): Options;
+
+    /**
+     * Configures the ChromeDriver to launch Chrome on Android via adb. This
+     * function is shorthand for
+     * {@link #androidPackage options.androidPackage('com.android.chrome')}.
+     * @return {!Options} A self reference.
+     */
+    androidChrome(): Options;
+
+    /**
+     * Sets the package name of the Chrome or WebView app.
+     *
+     * @param {?string} pkg The package to connect to, or `null` to disable Android
+     *     and switch back to using desktop Chrome.
+     * @return {!Options} A self reference.
+     */
+    androidPackage(pkg: string): Options;
+
+    /**
+     * Sets the process name of the Activity hosting the WebView (as given by `ps`).
+     * If not specified, the process name is assumed to be the same as
+     * {@link #androidPackage}.
+     *
+     * @param {string} processName The main activity name.
+     * @return {!Options} A self reference.
+     */
+    androidProcess(processName: string): Options;
+
+    /**
+     * Sets whether to connect to an already-running instead of the specified
+     * {@linkplain #androidProcess app} instead of launching the app with a clean
+     * data directory.
+     *
+     * @param {boolean} useRunning Whether to connect to a running instance.
+     * @return {!Options} A self reference.
+     */
+    androidUseRunningApp(useRunning: boolean): Options;
+
+    /**
+     * Sets the path to Chrome's log file. This path should exist on the machine
+     * that will launch Chrome.
+     * @param {string} path Path to the log file to use.
+     * @return {!Options} A self reference.
+     */
+    setChromeLogFile(path: string): Options;
+
+    /**
+         * Sets the directory to store Chrome minidumps in. This option is only
+         * supported when ChromeDriver is running on Linux.
+         * @param {string} path The directory path.
+         * @return {!Options} A self reference.
+         */
+    setChromeMinidumpPath(path: string): Options;
+
+    /**
+     * Configures Chrome to emulate a mobile device. For more information, refer
+     * to the ChromeDriver project page on [mobile emulation][em]. Configuration
+     * options include:
+     *
+     * - `deviceName`: The name of a pre-configured [emulated device][devem]
+     * - `width`: screen width, in pixels
+     * - `height`: screen height, in pixels
+     * - `pixelRatio`: screen pixel ratio
+     *
+     * __Example 1: Using a Pre-configured Device__
+     *
+     *     let options = new chrome.Options().setMobileEmulation(
+     *         {deviceName: 'Google Nexus 5'});
+     *
+     *     let driver = new chrome.Driver(options);
+     *
+     * __Example 2: Using Custom Screen Configuration__
+     *
+     *     let options = new chrome.Options().setMobileEmulation({
+     *         width: 360,
+     *         height: 640,
+     *         pixelRatio: 3.0
+     *     });
+     *
+     *     let driver = new chrome.Driver(options);
+     *
+     *
+     * [em]: https://sites.google.com/a/chromium.org/chromedriver/mobile-emulation
+     * [devem]: https://developer.chrome.com/devtools/docs/device-mode
+     *
+     * @param {?({deviceName: string}|
+     *           {width: number, height: number, pixelRatio: number})} config The
+     *     mobile emulation configuration, or `null` to disable emulation.
+     * @return {!Options} A self reference.
+     */
+    setMobileEmulation(config: any): Options;
+
+    /**
+     * Sets the proxy settings for the new session.
+     * @param {webdriver.ProxyConfig} proxy The proxy configuration to use.
+     * @return {!Options} A self reference.
+     */
+    setProxy(proxy: webdriver.ProxyConfig): Options;
+
+    /**
+     * Converts this options instance to a {@link webdriver.Capabilities} object.
+     * @param {webdriver.Capabilities=} opt_capabilities The capabilities to merge
+     *     these options into, if any.
+     * @return {!webdriver.Capabilities} The capabilities.
+     */
+    toCapabilities(opt_capabilities?: webdriver.Capabilities): webdriver.Capabilities;
+}
+
+/**
+ * Creates {@link remote.DriverService} instances that manage a ChromeDriver
+ * server.
+ */
+export class ServiceBuilder extends remote.DriverService.Builder {
+    /**
+     * @param {string=} opt_exe Path to the server executable to use. If omitted,
+     *     the builder will attempt to locate the chromedriver on the current
+     *     PATH.
+     * @throws {Error} If provided executable does not exist, or the chromedriver
+     *     cannot be found on the PATH.
+     * @constructor
+     */
+    constructor(opt_exe?: string);
+
+    /**
+     * Sets which port adb is listening to. _The ChromeDriver will connect to adb
+     * if an {@linkplain Options#androidPackage Android session} is requested, but
+     * adb **must** be started beforehand._
+     *
+     * @param {number} port Which port adb is running on.
+     * @return {!ServiceBuilder} A self reference.
+     */
+    setAdbPort(port: number): this;
+
+    /**
+     * Sets the path of the log file the driver should log to. If a log file is
+     * not specified, the driver will log to stderr.
+     * @param {string} path Path of the log file to use.
+     * @return {!ServiceBuilder} A self reference.
+     */
+    loggingTo(path: string): this;
+
+    /**
+     * Enables verbose logging.
+     * @return {!ServiceBuilder} A self reference.
+     */
+    enableVerboseLogging(): this;
+
+    /**
+     * Sets the number of threads the driver should use to manage HTTP requests.
+     * By default, the driver will use 4 threads.
+     * @param {number} n The number of threads to use.
+     * @return {!ServiceBuilder} A self reference.
+     */
+    setNumHttpThreads(n: number): this;
+}
+
+/**
+ * Returns the default ChromeDriver service. If such a service has not been
+ * configured, one will be constructed using the default configuration for
+ * a ChromeDriver executable found on the system PATH.
+ * @return {!remote.DriverService} The default ChromeDriver service.
+ */
+export function getDefaultService(): remote.DriverService;
+
+/**
+ * Sets the default service to use for new ChromeDriver instances.
+ * @param {!remote.DriverService} service The service to use.
+ * @throws {Error} If the default service is currently running.
+ */
+export function setDefaultService(service: remote.DriverService): void;

typings/edge.d.ts

@@ -0,0 +1,92 @@
+import * as webdriver from './index';
+import * as remote from './remote';
+
+export class Driver extends webdriver.WebDriver {
+    /**
+     * Creates a new browser session for Microsoft's Edge browser.
+     *
+     * @param {(capabilities.Capabilities|Options)=} opt_config The configuration
+     *     options.
+     * @param {remote.DriverService=} opt_service The session to use; will use
+     *     the {@linkplain #getDefaultService default service} by default.
+     * @param {promise.ControlFlow=} opt_flow The control flow to use, or
+     *     {@code null} to use the currently active flow.
+     * @return {!Driver} A new driver instance.
+     */
+    static createSession(opt_config?: webdriver.CreateSessionCapabilities, opt_service?: remote.DriverService, opt_flow?: webdriver.promise.ControlFlow): Driver;
+
+    /**
+     * This function is a no-op as file detectors are not supported by this
+     * implementation.
+     * @override
+     */
+    setFileDetector(): void;
+}
+
+/**
+ * Class for managing MicrosoftEdgeDriver specific options.
+ */
+export class Options {
+    /**
+     * Extracts the MicrosoftEdgeDriver specific options from the given
+     * capabilities object.
+     * @param {!capabilities.Capabilities} caps The capabilities object.
+     * @return {!Options} The MicrosoftEdgeDriver options.
+     */
+    static fromCapabilities(cap: webdriver.Capabilities): Options;
+
+    /**
+     * Sets the proxy settings for the new session.
+     * @param {capabilities.ProxyConfig} proxy The proxy configuration to use.
+     * @return {!Options} A self reference.
+     */
+    setProxy(proxy: webdriver.ProxyConfig): Options;
+
+    /**
+     * Sets the page load strategy for Edge.
+     * Supported values are 'normal', 'eager', and 'none';
+     *
+     * @param {string} pageLoadStrategy The page load strategy to use.
+     * @return {!Options} A self reference.
+     */
+    setPageLoadStrategy(pageLoadStrategy: string): Options;
+
+    /**
+     * Converts this options instance to a {@link capabilities.Capabilities}
+     * object.
+     * @param {capabilities.Capabilities=} opt_capabilities The capabilities to
+     *     merge these options into, if any.
+     * @return {!capabilities.Capabilities} The capabilities.
+     */
+    toCapabilities(opt_capabilities?: webdriver.Capabilities): webdriver.Capabilities;
+}
+
+/**
+ * Creates {@link remote.DriverService} instances that manage a
+ * MicrosoftEdgeDriver server in a child process.
+ */
+export class ServiceBuilder extends remote.DriverService.Builder {
+    /**
+     * @param {string=} opt_exe Path to the server executable to use. If omitted,
+     *   the builder will attempt to locate the MicrosoftEdgeDriver on the current
+     *   PATH.
+     * @throws {Error} If provided executable does not exist, or the
+     *   MicrosoftEdgeDriver cannot be found on the PATH.
+     */
+    constructor(opt_exe?: string);
+}
+
+/**
+ * Returns the default MicrosoftEdgeDriver service. If such a service has
+ * not been configured, one will be constructed using the default configuration
+ * for an MicrosoftEdgeDriver executable found on the system PATH.
+ * @return {!remote.DriverService} The default MicrosoftEdgeDriver service.
+ */
+export function getDefaultService(): remote.DriverService;
+
+/**
+ * Sets the default service to use for new MicrosoftEdgeDriver instances.
+ * @param {!remote.DriverService} service The service to use.
+ * @throws {Error} If the default service is currently running.
+ */
+export function setDefaultService(service: remote.DriverService): void;

typings/firefox.d.ts

@@ -0,0 +1,292 @@
+import * as webdriver from './index';
+import * as remote from './remote';
+import * as http from './http';
+
+/**
+ * Manages a Firefox subprocess configured for use with WebDriver.
+ */
+export class Binary {
+    /**
+     * @param {string=} opt_exe Path to the Firefox binary to use. If not
+     *     specified, will attempt to locate Firefox on the current system.
+     * @constructor
+     */
+    constructor(opt_exe?: string);
+
+    /**
+     * Add arguments to the command line used to start Firefox.
+     * @param {...(string|!Array.<string>)} var_args Either the arguments to add as
+     *     varargs, or the arguments as an array.
+     */
+    addArguments(...var_args: string[]): void;
+
+    /**
+     * Launches Firefox and eturns a promise that will be fulfilled when the process
+     * terminates.
+     * @param {string} profile Path to the profile directory to use.
+     * @return {!promise.Promise.<!exec.Result>} A promise for the process result.
+     * @throws {Error} If this instance has already been started.
+     */
+    launch(profile: string): webdriver.promise.Promise<any>;
+
+    /**
+     * Kills the managed Firefox process.
+     * @return {!promise.Promise} A promise for when the process has terminated.
+     */
+    kill(): webdriver.promise.Promise<void>;
+}
+
+/**
+ * Models a Firefox proifle directory for use with the FirefoxDriver. The
+ * {@code Proifle} directory uses an in-memory model until {@link #writeToDisk}
+ * is called.
+ */
+export class Profile {
+    /**
+     * @param {string=} opt_dir Path to an existing Firefox profile directory to
+     *     use a template for this profile. If not specified, a blank profile will
+     *     be used.
+     * @constructor
+     */
+    constructor(opt_dir?: string);
+
+    /**
+     * Registers an extension to be included with this profile.
+     * @param {string} extension Path to the extension to include, as either an
+     *     unpacked extension directory or the path to a xpi file.
+     */
+    addExtension(extension: string): void;
+
+    /**
+     * Sets a desired preference for this profile.
+     * @param {string} key The preference key.
+     * @param {(string|number|boolean)} value The preference value.
+     * @throws {Error} If attempting to set a frozen preference.
+     */
+    setPreference(key: string, value: string): void;
+    setPreference(key: string, value: number): void;
+    setPreference(key: string, value: boolean): void;
+
+    /**
+     * Returns the currently configured value of a profile preference. This does
+     * not include any defaults defined in the profile's template directory user.js
+     * file (if a template were specified on construction).
+     * @param {string} key The desired preference.
+     * @return {(string|number|boolean|undefined)} The current value of the
+     *     requested preference.
+     */
+    getPreference(key: string): any;
+
+    /**
+     * @return {number} The port this profile is currently configured to use, or
+     *     0 if the port will be selected at random when the profile is written
+     *     to disk.
+     */
+    getPort(): number;
+
+    /**
+     * Sets the port to use for the WebDriver extension loaded by this profile.
+     * @param {number} port The desired port, or 0 to use any free port.
+     */
+    setPort(port: number): void;
+
+    /**
+     * @return {boolean} Whether the FirefoxDriver is configured to automatically
+     *     accept untrusted SSL certificates.
+     */
+    acceptUntrustedCerts(): boolean;
+
+    /**
+     * Sets whether the FirefoxDriver should automatically accept untrusted SSL
+     * certificates.
+     * @param {boolean} value .
+     */
+    setAcceptUntrustedCerts(value: boolean): void;
+
+    /**
+     * Sets whether to assume untrusted certificates come from untrusted issuers.
+     * @param {boolean} value .
+     */
+    setAssumeUntrustedCertIssuer(value: boolean): void;
+
+    /**
+     * @return {boolean} Whether to assume untrusted certs come from untrusted
+     *     issuers.
+     */
+    assumeUntrustedCertIssuer(): boolean;
+
+    /**
+     * Sets whether to use native events with this profile.
+     * @param {boolean} enabled .
+     */
+    setNativeEventsEnabled(enabled: boolean): void;
+
+    /**
+     * Returns whether native events are enabled in this profile.
+     * @return {boolean} .
+     */
+    nativeEventsEnabled(): boolean;
+
+    /**
+     * Writes this profile to disk.
+     * @param {boolean=} opt_excludeWebDriverExt Whether to exclude the WebDriver
+     *     extension from the generated profile. Used to reduce the size of an
+     *     {@link #encode() encoded profile} since the server will always install
+     *     the extension itself.
+     * @return {!promise.Promise.<string>} A promise for the path to the new
+     *     profile directory.
+     */
+    writeToDisk(opt_excludeWebDriverExt?: boolean): webdriver.promise.Promise<string>;
+
+    /**
+     * Encodes this profile as a zipped, base64 encoded directory.
+     * @return {!promise.Promise.<string>} A promise for the encoded profile.
+     */
+    encode(): webdriver.promise.Promise<string>;
+}
+
+/**
+ * Configuration options for the FirefoxDriver.
+ */
+export class Options {
+    /**
+     * Sets the profile to use. The profile may be specified as a
+     * {@link Profile} object or as the path to an existing Firefox profile to use
+     * as a template.
+     *
+     * @param {(string|!Profile)} profile The profile to use.
+     * @return {!Options} A self reference.
+     */
+    setProfile(profile: string | any): Options;
+
+    /**
+     * Sets the binary to use. The binary may be specified as the path to a Firefox
+     * executable, or as a {@link Binary} object.
+     *
+     * @param {(string|!Binary)} binary The binary to use.
+     * @return {!Options} A self reference.
+     */
+    setBinary(binary: string | any): Options;
+
+    /**
+     * Sets the logging preferences for the new session.
+     * @param {logging.Preferences} prefs The logging preferences.
+     * @return {!Options} A self reference.
+     */
+    setLoggingPreferences(prefs: webdriver.logging.Preferences): Options;
+
+    /**
+     * Sets the proxy to use.
+     *
+     * @param {capabilities.ProxyConfig} proxy The proxy configuration to use.
+     * @return {!Options} A self reference.
+     */
+    setProxy(proxy: webdriver.ProxyConfig): Options;
+
+    /**
+     * Sets whether to use Mozilla's geckodriver to drive the browser. This option
+     * is enabled by default and required for Firefox 47+.
+     *
+     * @param {boolean} enable Whether to enable the geckodriver.
+     * @see https://github.com/mozilla/geckodriver
+     */
+    useGeckoDriver(enable: boolean): Options;
+
+    /**
+     * Converts these options to a {@link capabilities.Capabilities} instance.
+     *
+     * @return {!capabilities.Capabilities} A new capabilities object.
+     */
+    toCapabilities(): webdriver.Capabilities;
+}
+
+/**
+ * @return {string} .
+ * @throws {Error}
+ */
+export function findWires(): string;
+
+/**
+ * @param {(string|!Binary)} binary .
+ * @return {!remote.DriverService} .
+ */
+export function createWiresService(binary: string | any): remote.DriverService;
+
+/**
+ * @param {(Profile|string)} profile The profile to prepare.
+ * @param {number} port The port the FirefoxDriver should listen on.
+ * @return {!Promise<string>} a promise for the path to the profile directory.
+ */
+export function prepareProfile(profile: string | any, port: number): any;
+
+/**
+ * A WebDriver client for Firefox.
+ */
+export class Driver extends webdriver.WebDriver {
+    /**
+     * Creates a new Firefox session.
+     *
+     * @param {(Options|capabilities.Capabilities|Object)=} opt_config The
+     *    configuration options for this driver, specified as either an
+     *    {@link Options} or {@link capabilities.Capabilities}, or as a raw hash
+     *    object.
+     * @param {(http.Executor|remote.DriverService)=} opt_executor Either a
+     *   pre-configured command executor to use for communicating with an
+     *   externally managed remote end (which is assumed to already be running),
+     *   or the `DriverService` to use to start the geckodriver in a child
+     *   process.
+     *
+     *   If an executor is provided, care should e taken not to use reuse it with
+     *   other clients as its internal command mappings will be updated to support
+     *   Firefox-specific commands.
+     *
+     *   _This parameter may only be used with Mozilla's GeckoDriver._
+     *
+     * @param {promise.ControlFlow=} opt_flow The flow to
+     *     schedule commands through. Defaults to the active flow object.
+     * @throws {Error} If a custom command executor is provided and the driver is
+     *     configured to use the legacy FirefoxDriver from the Selenium project.
+     * @return {!Driver} A new driver instance.
+     */
+    static createSession(opt_config?: Options | webdriver.Capabilities, opt_executor?: http.Executor | remote.DriverService, opt_flow?: webdriver.promise.ControlFlow): Driver;
+
+    /**
+     * This function is a no-op as file detectors are not supported by this
+     * implementation.
+     * @override
+     */
+    setFileDetector(): void;
+}
+
+/**
+ * Creates {@link selenium-webdriver/remote.DriverService} instances that manage
+ * a [geckodriver](https://github.com/mozilla/geckodriver) server in a child
+ * process.
+ */
+export class ServiceBuilder extends remote.DriverService.Builder {
+    /**
+     * @param {string=} opt_exe Path to the server executable to use. If omitted,
+     *     the builder will attempt to locate the geckodriver on the system PATH.
+     */
+    constructor(opt_exe?: string);
+
+    /**
+     * Enables verbose logging.
+     *
+     * @param {boolean=} opt_trace Whether to enable trace-level logging. By
+     *     default, only debug logging is enabled.
+     * @return {!ServiceBuilder} A self reference.
+     */
+    enableVerboseLogging(opt_trace?: boolean): this;
+
+    /**
+     * Sets the path to the executable Firefox binary that the geckodriver should
+     * use. If this method is not called, this builder will attempt to locate
+     * Firefox in the default installation location for the current platform.
+     *
+     * @param {(string|!Binary)} binary Path to the executable Firefox binary to use.
+     * @return {!ServiceBuilder} A self reference.
+     * @see Binary#locate()
+     */
+    setFirefoxBinary(binary: string | Binary): this;
+}

typings/http.d.ts

@@ -0,0 +1,152 @@
+import * as webdriver from './index';
+
+/**
+ * Converts a headers map to a HTTP header block string.
+ * @param {!Map<string, string>} headers The map to convert.
+ * @return {string} The headers as a string.
+ */
+export function headersToString(headers: any): string;
+
+/**
+ * Represents a HTTP request message. This class is a 'partial' request and only
+ * defines the path on the server to send a request to. It is each client's
+ * responsibility to build the full URL for the final request.
+ * @final
+ */
+export class Request {
+    /**
+     * @param {string} method The HTTP method to use for the request.
+     * @param {string} path The path on the server to send the request to.
+     * @param {Object=} opt_data This request's non-serialized JSON payload data.
+     */
+    constructor(method: string, path: string, opt_data?: Object);
+
+    /** @override */
+    toString(): string;
+}
+
+/**
+ * Represents a HTTP response message.
+ * @final
+ */
+export class Response {
+    /**
+     * @param {number} status The response code.
+     * @param {!Object<string>} headers The response headers. All header names
+     *     will be converted to lowercase strings for consistent lookups.
+     * @param {string} body The response body.
+     */
+    constructor(status: number, headers: Object, body: string);
+
+    /** @override */
+    toString(): string;
+}
+
+export function post(path: string): any;
+export function del(path: string): any;
+export function get(path: string): any;
+export function resource(method: string, path: string): any;
+
+/**
+ * A basic HTTP client used to send messages to a remote end.
+ */
+export class HttpClient {
+    /**
+     * @param {string} serverUrl URL for the WebDriver server to send commands to.
+     * @param {http.Agent=} opt_agent The agent to use for each request.
+     *     Defaults to `http.globalAgent`.
+     * @param {?string=} opt_proxy The proxy to use for the connection to the
+     *     server. Default is to use no proxy.
+     */
+    constructor(serverUrl: string, opt_agent?: any, opt_proxy?: string);
+
+    /**
+     * Sends a request to the server. The client will automatically follow any
+     * redirects returned by the server, fulfilling the returned promise with the
+     * final response.
+     *
+     * @param {!HttpRequest} httpRequest The request to send.
+     * @return {!promise.Promise<HttpResponse>} A promise that will be fulfilled
+     *     with the server's response.
+     */
+    send(httpRequest: Request): webdriver.promise.Promise<Response>;
+}
+
+/**
+ * Sends a single HTTP request.
+ * @param {!Object} options The request options.
+ * @param {function(!HttpResponse)} onOk The function to call if the
+ *     request succeeds.
+ * @param {function(!Error)} onError The function to call if the request fails.
+ * @param {?string=} opt_data The data to send with the request.
+ * @param {?string=} opt_proxy The proxy server to use for the request.
+ */
+export function sendRequest(options: Object, onOk: any, onError: any, opt_data?: string, opt_proxy?: string): any;
+
+/**
+ * A command executor that communicates with the server using HTTP + JSON.
+ *
+ * By default, each instance of this class will use the legacy wire protocol
+ * from [Selenium project][json]. The executor will automatically switch to the
+ * [W3C wire protocol][w3c] if the remote end returns a compliant response to
+ * a new session command.
+ *
+ * [json]: https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol
+ * [w3c]: https://w3c.github.io/webdriver/webdriver-spec.html
+ *
+ * @implements {cmd.Executor}
+ */
+export class Executor {
+    /**
+     * @param {!(HttpClient|IThenable<!HttpClient>)} client The client to use for sending
+     *     requests to the server, or a promise-like object that will resolve to
+     *     to the client.
+     */
+    constructor(client: HttpClient | webdriver.promise.IThenable<HttpClient>);
+
+    /**
+     * Defines a new command for use with this executor. When a command is sent,
+     * the {@code path} will be preprocessed using the command's parameters; any
+     * path segments prefixed with ':' will be replaced by the parameter of the
+     * same name. For example, given '/person/:name' and the parameters
+     * '{name: 'Bob'}', the final command path will be '/person/Bob'.
+     *
+     * @param {string} name The command name.
+     * @param {string} method The HTTP method to use when sending this command.
+     * @param {string} path The path to send the command to, relative to
+     *     the WebDriver server's command root and of the form
+     *     '/path/:variable/segment'.
+     */
+    defineCommand(name: string, method: string, path: string): void;
+
+    /** @override */
+    execute(command: any): any;
+}
+
+/**
+ * @param {string} str .
+ * @return {?} .
+ */
+export function tryParse(str: string): any;
+
+/**
+ * Callback used to parse {@link HttpResponse} objects from a
+ * {@link HttpClient}.
+ * @param {!HttpResponse} httpResponse The HTTP response to parse.
+ * @param {boolean} w3c Whether the response should be processed using the
+ *     W3C wire protocol.
+ * @return {{value: ?}} The parsed response.
+ * @throws {WebDriverError} If the HTTP response is an error.
+ */
+export function parseHttpResponse(httpResponse: Response, w3c: boolean): any;
+
+/**
+ * Builds a fully qualified path using the given set of command parameters. Each
+ * path segment prefixed with ':' will be replaced by the value of the
+ * corresponding parameter. All parameters spliced into the path will be
+ * removed from the parameter map.
+ * @param {string} path The original resource path.
+ * @param {!Object<*>} parameters The parameters object to splice into the path.
+ * @return {string} The modified path.
+ */
+export function buildPath(path: string, parameters: Object): string;

typings/ie.d.ts

@@ -0,0 +1,208 @@
+import * as webdriver from './index';
+
+/**
+ * A WebDriver client for Microsoft's Internet Explorer.
+ */
+export class Driver extends webdriver.WebDriver {
+    /**
+     * Creates a new session for Microsoft's Internet Explorer.
+     *
+     * @param {(capabilities.Capabilities|Options)=} opt_config The configuration
+     *     options.
+     * @param {promise.ControlFlow=} opt_flow The control flow to use,
+     *     or {@code null} to use the currently active flow.
+     * @return {!Driver} A new driver instance.
+     */
+    static createSession(opt_config?: webdriver.Capabilities | Options, opt_flow?: webdriver.promise.ControlFlow): Driver;
+
+    /**
+     * This function is a no-op as file detectors are not supported by this
+     * implementation.
+     * @override
+     */
+    setFileDetector(): void;
+}
+
+/**
+ * Class for managing IEDriver specific options.
+ */
+export class Options {
+    constructor();
+
+    /**
+     * Extracts the IEDriver specific options from the given capabilities
+     * object.
+     * @param {!capabilities.Capabilities} caps The capabilities object.
+     * @return {!Options} The IEDriver options.
+     */
+    static fromCapabilities(caps: webdriver.Capabilities): Options;
+
+    /**
+     * Whether to disable the protected mode settings check when the session is
+     * created. Disbling this setting may lead to significant instability as the
+     * browser may become unresponsive/hang. Only 'best effort' support is provided
+     * when using this capability.
+     *
+     * For more information, refer to the IEDriver's
+     * [required system configuration](http://goo.gl/eH0Yi3).
+     *
+     * @param {boolean} ignoreSettings Whether to ignore protected mode settings.
+     * @return {!Options} A self reference.
+     */
+    introduceFlakinessByIgnoringProtectedModeSettings(ignoreSettings: boolean): Options;
+
+    /**
+     * Indicates whether to skip the check that the browser's zoom level is set to
+     * 100%.
+     *
+     * @param {boolean} ignore Whether to ignore the browser's zoom level settings.
+     * @return {!Options} A self reference.
+     */
+    ignoreZoomSetting(ignore: boolean): Options;
+
+    /**
+     * Sets the initial URL loaded when IE starts. This is intended to be used with
+     * {@link #ignoreProtectedModeSettings} to allow the user to initialize IE in
+     * the proper Protected Mode zone. Setting this option may cause browser
+     * instability or flaky and unresponsive code. Only 'best effort' support is
+     * provided when using this option.
+     *
+     * @param {string} url The initial browser URL.
+     * @return {!Options} A self reference.
+     */
+    initialBrowserUrl(url: string): Options;
+
+    /**
+     * Configures whether to enable persistent mouse hovering (true by default).
+     * Persistent hovering is achieved by continuously firing mouse over events at
+     * the last location the mouse cursor has been moved to.
+     *
+     * @param {boolean} enable Whether to enable persistent hovering.
+     * @return {!Options} A self reference.
+     */
+    enablePersistentHover(enable: boolean): Options;
+
+    /**
+     * Configures whether the driver should attempt to remove obsolete
+     * {@linkplain webdriver.WebElement WebElements} from its internal cache on
+     * page navigation (true by default). Disabling this option will cause the
+     * driver to run with a larger memory footprint.
+     *
+     * @param {boolean} enable Whether to enable element reference cleanup.
+     * @return {!Options} A self reference.
+     */
+    enableElementCacheCleanup(enable: boolean): Options;
+
+    /**
+     * Configures whether to require the IE window to have input focus before
+     * performing any user interactions (i.e. mouse or keyboard events). This
+     * option is disabled by default, but delivers much more accurate interaction
+     * events when enabled.
+     *
+     * @param {boolean} require Whether to require window focus.
+     * @return {!Options} A self reference.
+     */
+    requireWindowFocus(require: boolean): Options;
+
+    /**
+     * Configures the timeout, in milliseconds, that the driver will attempt to
+     * located and attach to a newly opened instance of Internet Explorer. The
+     * default is zero, which indicates waiting indefinitely.
+     *
+     * @param {number} timeout How long to wait for IE.
+     * @return {!Options} A self reference.
+     */
+    browserAttachTimeout(timeout: number): Options;
+
+    /**
+     * Configures whether to launch Internet Explorer using the CreateProcess API.
+     * If this option is not specified, IE is launched using IELaunchURL, if
+     * available. For IE 8 and above, this option requires the TabProcGrowth
+     * registry value to be set to 0.
+     *
+     * @param {boolean} force Whether to use the CreateProcess API.
+     * @return {!Options} A self reference.
+     */
+    forceCreateProcessApi(force: boolean): Options;
+
+    /**
+     * Specifies command-line switches to use when launching Internet Explorer.
+     * This is only valid when used with {@link #forceCreateProcessApi}.
+     *
+     * @param {...(string|!Array.<string>)} var_args The arguments to add.
+     * @return {!Options} A self reference.
+     */
+    addArguments(...var_args: string[]): Options;
+
+    /**
+     * Configures whether proxies should be configured on a per-process basis. If
+     * not set, setting a {@linkplain #setProxy proxy} will configure the system
+     * proxy. The default behavior is to use the system proxy.
+     *
+     * @param {boolean} enable Whether to enable per-process proxy settings.
+     * @return {!Options} A self reference.
+     */
+    usePerProcessProxy(enable: boolean): Options;
+
+    /**
+     * Configures whether to clear the cache, cookies, history, and saved form data
+     * before starting the browser. _Using this capability will clear session data
+     * for all running instances of Internet Explorer, including those started
+     * manually._
+     *
+     * @param {boolean} cleanSession Whether to clear all session data on startup.
+     * @return {!Options} A self reference.
+     */
+    ensureCleanSession(cleanSession: boolean): Options;
+
+    /**
+     * Sets the path to the log file the driver should log to.
+     * @param {string} file The log file path.
+     * @return {!Options} A self reference.
+     */
+    setLogFile(file: string): Options;
+
+    /**
+     * Sets the IEDriverServer's logging {@linkplain Level level}.
+     * @param {Level} level The logging level.
+     * @return {!Options} A self reference.
+     */
+    setLogLevel(level: webdriver.logging.Level): Options;
+
+    /**
+     * Sets the IP address of the driver's host adapter.
+     * @param {string} host The IP address to use.
+     * @return {!Options} A self reference.
+     */
+    setHost(host: string): Options;
+
+    /**
+     * Sets the path of the temporary data directory to use.
+     * @param {string} path The log file path.
+     * @return {!Options} A self reference.
+     */
+    setExtractPath(path: string): Options;
+
+    /**
+     * Sets whether the driver should start in silent mode.
+     * @param {boolean} silent Whether to run in silent mode.
+     * @return {!Options} A self reference.
+     */
+    silent(silent: boolean): Options;
+
+    /**
+     * Sets the proxy settings for the new session.
+     * @param {capabilities.ProxyConfig} proxy The proxy configuration to use.
+     * @return {!Options} A self reference.
+     */
+    setProxy(proxy: webdriver.ProxyConfig): Options;
+
+    /**
+     * Converts this options instance to a {@link capabilities.Capabilities}
+     * object.
+     * @param {capabilities.Capabilities=} opt_capabilities The capabilities to
+     *     merge these options into, if any.
+     * @return {!capabilities.Capabilities} The capabilities.
+     */
+    toCapabilities(opt_capabilities?: webdriver.Capabilities): webdriver.Capabilities;
+}

typings/opera.d.ts

@@ -0,0 +1,176 @@
+import * as webdriver from './index';
+import * as remote from './remote';
+
+/**
+ * Creates {@link remote.DriverService} instances that manages an
+ * [OperaDriver](https://github.com/operasoftware/operachromiumdriver)
+ * server in a child process.
+ */
+export class ServiceBuilder {
+    /**
+     * @param {string=} opt_exe Path to the server executable to use. If omitted,
+     *     the builder will attempt to locate the operadriver on the current
+     *     PATH.
+     * @throws {Error} If provided executable does not exist, or the operadriver
+     *     cannot be found on the PATH.
+     */
+    constructor(opt_exe?: string);
+
+    /**
+     * Sets the port to start the OperaDriver on.
+     * @param {number} port The port to use, or 0 for any free port.
+     * @return {!ServiceBuilder} A self reference.
+     * @throws {Error} If the port is invalid.
+     */
+    usingPort(port: number): ServiceBuilder;
+
+    /**
+     * Sets the path of the log file the driver should log to. If a log file is
+     * not specified, the driver will log to stderr.
+     * @param {string} path Path of the log file to use.
+     * @return {!ServiceBuilder} A self reference.
+     */
+    loggingTo(path: string): ServiceBuilder;
+
+    /**
+     * Enables verbose logging.
+     * @return {!ServiceBuilder} A self reference.
+     */
+    enableVerboseLogging(): ServiceBuilder;
+
+    /**
+     * Silence sthe drivers output.
+     * @return {!ServiceBuilder} A self reference.
+     */
+    silent(): ServiceBuilder;
+
+    /**
+     * Defines the stdio configuration for the driver service. See
+     * {@code child_process.spawn} for more information.
+     * @param {(string|!Array<string|number|!stream.Stream|null|undefined>)}
+     *     config The configuration to use.
+     * @return {!ServiceBuilder} A self reference.
+     */
+    setStdio(config: string | Array<string | number | any>): ServiceBuilder;
+
+    /**
+     * Defines the environment to start the server under. This settings will be
+     * inherited by every browser session started by the server.
+     * @param {!Object.<string, string>} env The environment to use.
+     * @return {!ServiceBuilder} A self reference.
+     */
+    withEnvironment(env: Object): ServiceBuilder;
+
+    /**
+     * Creates a new DriverService using this instance's current configuration.
+     * @return {!remote.DriverService} A new driver service using this instance's
+     *     current configuration.
+     * @throws {Error} If the driver exectuable was not specified and a default
+     *     could not be found on the current PATH.
+     */
+    build(): remote.DriverService;
+}
+
+/**
+ * Sets the default service to use for new OperaDriver instances.
+ * @param {!remote.DriverService} service The service to use.
+ * @throws {Error} If the default service is currently running.
+ */
+export function setDefaultService(service: remote.DriverService): any;
+
+/**
+ * Returns the default OperaDriver service. If such a service has not been
+ * configured, one will be constructed using the default configuration for
+ * a OperaDriver executable found on the system PATH.
+ * @return {!remote.DriverService} The default OperaDriver service.
+ */
+export function getDefaultService(): remote.DriverService;
+
+/**
+ * Class for managing {@linkplain Driver OperaDriver} specific options.
+ */
+export class Options {
+    /**
+     * Extracts the OperaDriver specific options from the given capabilities
+     * object.
+     * @param {!capabilities.Capabilities} caps The capabilities object.
+     * @return {!Options} The OperaDriver options.
+     */
+    static fromCapabilities(caps: webdriver.Capabilities): Options;
+
+    /**
+     * Add additional command line arguments to use when launching the Opera
+     * browser.  Each argument may be specified with or without the '--' prefix
+     * (e.g. '--foo' and 'foo'). Arguments with an associated value should be
+     * delimited by an '=': 'foo=bar'.
+     * @param {...(string|!Array.<string>)} var_args The arguments to add.
+     * @return {!Options} A self reference.
+     */
+    addArguments(...var_args: string[]): Options;
+
+    /**
+     * Add additional extensions to install when launching Opera. Each extension
+     * should be specified as the path to the packed CRX file, or a Buffer for an
+     * extension.
+     * @param {...(string|!Buffer|!Array.<(string|!Buffer)>)} var_args The
+     *     extensions to add.
+     * @return {!Options} A self reference.
+     */
+    addExtensions(...var_args: any[]): Options;
+
+    /**
+     * Sets the path to the Opera binary to use. On Mac OS X, this path should
+     * reference the actual Opera executable, not just the application binary. The
+     * binary path be absolute or relative to the operadriver server executable, but
+     * it must exist on the machine that will launch Opera.
+     *
+     * @param {string} path The path to the Opera binary to use.
+     * @return {!Options} A self reference.
+     */
+    setOperaBinaryPath(path: string): Options;
+
+    /**
+     * Sets the logging preferences for the new session.
+     * @param {!./lib/logging.Preferences} prefs The logging preferences.
+     * @return {!Options} A self reference.
+     */
+    setLoggingPrefs(prefs: webdriver.logging.Preferences): Options;
+
+    /**
+     * Sets the proxy settings for the new session.
+     * @param {capabilities.ProxyConfig} proxy The proxy configuration to use.
+     * @return {!Options} A self reference.
+     */
+    setProxy(proxy: webdriver.ProxyConfig): Options;
+
+    /**
+     * Converts this options instance to a {@link capabilities.Capabilities}
+     *     object.
+     * @param {capabilities.Capabilities=} opt_capabilities The capabilities to
+     *     merge these options into, if any.
+     * @return {!capabilities.Capabilities} The capabilities.
+     */
+    toCapabilities(opt_capabilities?: webdriver.Capabilities): webdriver.Capabilities;
+}
+
+export class Driver extends webdriver.WebDriver {
+    /**
+     * Creates a new session for Opera.
+     *
+     * @param {(capabilities.Capabilities|Options)=} opt_config The configuration
+     *     options.
+     * @param {remote.DriverService=} opt_service The session to use; will use
+     *     the {@link getDefaultService default service} by default.
+     * @param {promise.ControlFlow=} opt_flow The control flow to use,
+     *     or {@code null} to use the currently active flow.
+     * @return {!Driver} A new driver instance.
+     */
+    static createSession(opt_config?: webdriver.Capabilities | Options, opt_service?: remote.DriverService, opt_flow?: webdriver.promise.ControlFlow): Driver;
+
+    /**
+     * This function is a no-op as file detectors are not supported by this
+     * implementation.
+     * @override
+     */
+    setFileDetector(): void;
+}

typings/remote.d.ts

@@ -0,0 +1,242 @@
+import * as webdriver from './index';
+
+/**
+ * A record object that defines the configuration options for a DriverService
+ * instance.
+ *
+ * @record
+ */
+export interface ServiceOptions { }
+
+/**
+ * Manages the life and death of a native executable WebDriver server.
+ *
+ * It is expected that the driver server implements the
+ * https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol.
+ * Furthermore, the managed server should support multiple concurrent sessions,
+ * so that this class may be reused for multiple clients.
+ */
+export class DriverService {
+    /**
+     * @param {string} executable Path to the executable to run.
+     * @param {!ServiceOptions} options Configuration options for the service.
+     */
+    constructor(executable: string, options: ServiceOptions);
+
+    /**
+     * @return {!promise.Promise<string>} A promise that resolves to
+     *    the server's address.
+     * @throws {Error} If the server has not been started.
+     */
+    address(): webdriver.promise.Promise<string>;
+
+    /**
+     * Returns whether the underlying process is still running. This does not take
+     * into account whether the process is in the process of shutting down.
+     * @return {boolean} Whether the underlying service process is running.
+     */
+    isRunning(): boolean;
+
+    /**
+     * Starts the server if it is not already running.
+     * @param {number=} opt_timeoutMs How long to wait, in milliseconds, for the
+     *     server to start accepting requests. Defaults to 30 seconds.
+     * @return {!promise.Promise<string>} A promise that will resolve
+     *     to the server's base URL when it has started accepting requests. If the
+     *     timeout expires before the server has started, the promise will be
+     *     rejected.
+     */
+    start(opt_timeoutMs?: number): webdriver.promise.Promise<string>;
+
+    /**
+     * Stops the service if it is not currently running. This function will kill
+     * the server immediately. To synchronize with the active control flow, use
+     * {@link #stop()}.
+     * @return {!promise.Promise} A promise that will be resolved when
+     *     the server has been stopped.
+     */
+    kill(): webdriver.promise.Promise<any>;
+
+    /**
+     * Schedules a task in the current control flow to stop the server if it is
+     * currently running.
+     * @return {!promise.Promise} A promise that will be resolved when
+     *     the server has been stopped.
+     */
+    stop(): webdriver.promise.Promise<any>;
+}
+
+export namespace DriverService {
+    /**
+     * Creates {@link DriverService} objects that manage a WebDriver server in a
+     * child process.
+     */
+    class Builder {
+        /**
+         * @param {string} exe Path to the executable to use. This executable must
+         *     accept the `--port` flag for defining the port to start the server on.
+         * @throws {Error} If the provided executable path does not exist.
+         */
+        constructor(exe: string);
+
+        /**
+         * Define additional command line arguments to use when starting the server.
+         *
+         * @param {...CommandLineFlag} var_args The arguments to include.
+         * @return {!THIS} A self reference.
+         * @this {THIS}
+         * @template THIS
+         */
+        addArguments(...var_args: string[]): this;
+
+        /**
+         * Sets the host name to access the server on. If specified, the
+         * {@linkplain #setLoopback() loopback} setting will be ignored.
+         *
+         * @param {string} hostname
+         * @return {!DriverService.Builder} A self reference.
+         */
+        setHostname(hostname: string): this;
+
+        /**
+         * Sets whether the service should be accessed at this host's loopback
+         * address.
+         *
+         * @param {boolean} loopback
+         * @return {!DriverService.Builder} A self reference.
+         */
+        setLoopback(loopback: boolean): this;
+
+        /**
+         * Sets the base path for WebDriver REST commands (e.g. "/wd/hub").
+         * By default, the driver will accept commands relative to "/".
+         *
+         * @param {?string} basePath The base path to use, or `null` to use the
+         *     default.
+         * @return {!DriverService.Builder} A self reference.
+         */
+        setPath(basePath: string | null): this;
+
+        /**
+         * Sets the port to start the server on.
+         *
+         * @param {number} port The port to use, or 0 for any free port.
+         * @return {!DriverService.Builder} A self reference.
+         * @throws {Error} If an invalid port is specified.
+         */
+        setPort(port: number): this;
+
+        /**
+         * Defines the environment to start the server under. This setting will be
+         * inherited by every browser session started by the server. By default, the
+         * server will inherit the enviroment of the current process.
+         *
+         * @param {(Map<string, string>|Object<string, string>|null)} env The desired
+         *     environment to use, or `null` if the server should inherit the
+         *     current environment.
+         * @return {!DriverService.Builder} A self reference.
+         */
+        setEnvironment(env: Map<string, string> | {[name: string]: string} | null): this;
+
+        /**
+         * IO configuration for the spawned server process. For more information,
+         * refer to the documentation of `child_process.spawn`.
+         *
+         * @param {StdIoOptions} config The desired IO configuration.
+         * @return {!DriverService.Builder} A self reference.
+         * @see https://nodejs.org/dist/latest-v4.x/docs/api/child_process.html#child_process_options_stdio
+         */
+        setStdio(config: any): this;
+
+        /**
+         * Creates a new DriverService using this instance's current configuration.
+         *
+         * @return {!DriverService} A new driver service.
+         */
+        build(): DriverService;
+    }
+}
+
+/**
+ * Manages the life and death of the
+ * <a href="http://selenium-release.storage.googleapis.com/index.html">
+ * standalone Selenium server</a>.
+ */
+export class SeleniumServer extends DriverService {
+    /**
+     * @param {string} jar Path to the Selenium server jar.
+     * @param {SeleniumServer.Options=} opt_options Configuration options for the
+     *     server.
+     * @throws {Error} If the path to the Selenium jar is not specified or if an
+     *     invalid port is specified.
+     **/
+    constructor(jar: string, opt_options?: SeleniumServer.Options);
+}
+
+export namespace SeleniumServer {
+    /**
+     * Options for the Selenium server
+     */
+    interface Options {
+        /** Whether the server should only be accessed on this host's loopback address.*/
+        loopback?: boolean;
+
+        /** The port to start the server on (must be > 0). If the port is provided
+        as a promise, the service will wait for the promise to resolve before starting. */
+        port?: number|webdriver.promise.IThenable<number>;
+
+        /** The arguments to pass to the service. If a promise is provided, the
+        service will wait for it to resolve before starting. */
+        args?: string[]|webdriver.promise.IThenable<string[]>;
+
+        /** The arguments to pass to the JVM. If a promise is provided, the service
+        will wait for it to resolve before starting. */
+        jvmArgs?: string[]|webdriver.promise.IThenable<string[]>;
+
+        /** The environment variables that should be visible to the server process.
+        Defaults to inheriting the current process's environment.*/
+        env?: {[key: string]: string};
+
+        /** IO configuration for the spawned server process. For more information,
+        refer to the documentation of `child_process.spawn`*/
+        stdio?: string|Array<string|number>;
+    }
+}
+
+/**
+ * A {@link webdriver.FileDetector} that may be used when running
+ * against a remote
+ * [Selenium server](http://selenium-release.storage.googleapis.com/index.html).
+ *
+ * When a file path on the local machine running this script is entered with
+ * {@link webdriver.WebElement#sendKeys WebElement#sendKeys}, this file detector
+ * will transfer the specified file to the Selenium server's host; the sendKeys
+ * command will be updated to use the transfered file's path.
+ *
+ * __Note:__ This class depends on a non-standard command supported on the
+ * Java Selenium server. The file detector will fail if used with a server that
+ * only supports standard WebDriver commands (such as the ChromeDriver).
+ *
+ * @final
+ */
+export class FileDetector extends webdriver.FileDetector {
+    /**
+     * @constructor
+     **/
+    constructor();
+
+    /**
+     * Prepares a `file` for use with the remote browser. If the provided path
+     * does not reference a normal file (i.e. it does not exist or is a
+     * directory), then the promise returned by this method will be resolved with
+     * the original file path. Otherwise, this method will upload the file to the
+     * remote server, which will return the file's path on the remote system so
+     * it may be referenced in subsequent commands.
+     *
+     * @param {!webdriver.WebDriver} driver The driver for the current browser.
+     * @param {string} file The path of the file to process.
+     * @return {!webdriver.promise.Promise<string>} A promise for the processed
+     *     file path.
+     */
+    handleFile(driver: webdriver.WebDriver, file: string): webdriver.promise.Promise<string>;
+}

typings/safari.d.ts

@@ -0,0 +1,91 @@
+import * as webdriver from './index';
+
+export class Server { }
+
+/**
+ * @return {!Promise<string>} A promise that will resolve with the path
+ *     to Safari on the current system.
+ */
+export function findSafariExecutable(): any;
+
+/**
+ * @param {string} serverUrl The URL to connect to.
+ * @return {!Promise<string>} A promise for the path to a file that Safari can
+ *     open on start-up to trigger a new connection to the WebSocket server.
+ */
+export function createConnectFile(serverUrl: string): any;
+
+/**
+ * Deletes all session data files if so desired.
+ * @param {!Object} desiredCapabilities .
+ * @return {!Array<promise.Promise>} A list of promises for the deleted files.
+ */
+export function cleanSession(desiredCapabilities: webdriver.Capabilities): any[];
+
+/** @return {string} . */
+export function getRandomString(): string;
+
+/**
+ * @implements {command.Executor}
+ */
+export class CommandExecutor {
+}
+
+/**
+ * Configuration options specific to the {@link Driver SafariDriver}.
+ */
+export class Options {
+    /**
+     * Extracts the SafariDriver specific options from the given capabilities
+     * object.
+     * @param {!Capabilities} capabilities The capabilities object.
+     * @return {!Options} The ChromeDriver options.
+     */
+    static fromCapabilities(capabilities: webdriver.Capabilities): Options;
+
+    /**
+     * Sets whether to force Safari to start with a clean session. Enabling this
+     * option will cause all global browser data to be deleted.
+     * @param {boolean} clean Whether to make sure the session has no cookies,
+     *     cache entries, local storage, or databases.
+     * @return {!Options} A self reference.
+     */
+    setCleanSession(clean: boolean): Options;
+
+    /**
+     * Sets the logging preferences for the new session.
+     * @param {!./lib/logging.Preferences} prefs The logging preferences.
+     * @return {!Options} A self reference.
+     */
+    setLoggingPrefs(prefs: webdriver.logging.Preferences): Options;
+
+    /**
+     * Converts this options instance to a {@link Capabilities} object.
+     * @param {Capabilities=} opt_capabilities The capabilities to
+     *     merge these options into, if any.
+     * @return {!Capabilities} The capabilities.
+     */
+    toCapabilities(opt_capabilities?: webdriver.Capabilities): webdriver.Capabilities;
+}
+
+/**
+ * A WebDriver client for Safari. This class should never be instantiated
+ * directly; instead, use the {@linkplain ./builder.Builder Builder}:
+ *
+ *     var driver = new Builder()
+ *         .forBrowser('safari')
+ *         .build();
+ *
+ */
+export class Driver extends webdriver.WebDriver {
+    /**
+     * Creates a new Safari session.
+     *
+     * @param {(Options|Capabilities)=} opt_config The configuration
+     *     options for the new session.
+     * @param {promise.ControlFlow=} opt_flow The control flow to create
+     *     the driver under.
+     * @return {!Driver} A new driver instance.
+     */
+    static createSession(opt_config?: Options | webdriver.Capabilities, opt_flow?: webdriver.promise.ControlFlow): Driver;
+}

typings/testing.d.ts

@@ -0,0 +1,106 @@
+import { promise } from './index';
+import * as Testing from './testing';
+
+export const describe: {
+    /**
+    * Registers a new test suite.
+    * @param name The suite name.
+    * @param fn The suite function, or {@code undefined} to define a pending test suite.
+    */
+    (name: string, fn: Function): void;
+
+    /**
+     * An alias for {@link #describe()} that marks the suite as exclusive,
+     * suppressing all other test suites.
+     * @param {string} name The suite name.
+     * @param {function()=} opt_fn The suite function, or `undefined` to define
+     *     a pending test suite.
+     */
+    only(name: string, fn: Function): void;
+
+    /**
+     * Defines a suppressed test suite.
+     * @param name The suite name.
+     * @param fn The suite function, or {@code undefined} to define a pending test suite.
+     */
+    skip(name: string, fn: Function): void;
+};
+
+/**
+ * Defines a suppressed test suite.
+ * @param name The suite name.
+ * @param fn The suite function, or {@code undefined} to define a pending test suite.
+ */
+export function xdescribe(name: string, fn: Function): void;
+
+/**
+ * Register a function to call after the current suite finishes.
+ * @param fn
+ */
+export function after(fn: Function): void;
+
+/**
+ * Register a function to call after each test in a suite.
+ * @param fn
+ */
+export function afterEach(fn: Function): void;
+
+/**
+ * Register a function to call before the current suite starts.
+ * @param fn
+ */
+export function before(fn: Function): void;
+
+/**
+ * Register a function to call before each test in a suite.
+ * @param fn
+ */
+export function beforeEach(fn: Function): void;
+
+export const it: {
+    /**
+     * Add a test to the current suite.
+     * @param name The test name.
+     * @param fn The test function, or {@code undefined} to define a pending test case.
+     */
+    (name: string, fn: Function): void;
+
+    /**
+     * An alias for {@link #it()} that flags the test as the only one that should
+     * be run within the current suite.
+     * @param {string} name The test name.
+     * @param {function()=} opt_fn The test function, or `undefined` to define
+     *     a pending test case.
+     */
+    only(name: string, fn: Function): void;
+
+    /**
+     * Adds a test to the current suite while suppressing it so it is not run.
+     * @param name The test name.
+     * @param fn The test function, or {@code undefined} to define a pending test case.
+     */
+    skip(name: string, fn: Function): void;
+}
+
+/**
+ * Adds a test to the current suite while suppressing it so it is not run.
+ * @param name The test name.
+ * @param fn The test function, or {@code undefined} to define a pending test case.
+ */
+export function xit(name: string, fn: Function): void;
+
+/**
+ * @return {!promise.ControlFlow} the control flow instance used by this module
+ *     to coordinate test actions.
+ */
+export function controlFlow(): promise.ControlFlow;
+
+/**
+ * Ignores the test chained to this function if the provided predicate returns
+ * true.
+ * @param {function(): boolean} predicateFn A predicate to call to determine
+ *     if the test should be suppressed. This function MUST be synchronous.
+ * @return {!Object} An object with wrapped versions of {@link #it()} and
+ *     {@link #describe()} that ignore tests as indicated by the predicate.
+ */
+export function ignore(predicateFn: () => boolean): typeof Testing;