diff --git a/webdriverio/webdriverio-tests.ts b/webdriverio/webdriverio-tests.ts
new file mode 100644
index 000000000..205a2c6a6
--- /dev/null
+++ b/webdriverio/webdriverio-tests.ts
@@ -0,0 +1,128 @@
+/// <reference path="webdriverio.d.ts" />
+/// <reference path="../mocha/mocha.d.ts" />
+/// <reference path="../chai/chai.d.ts" />
+
+import {assert} from "chai";
+
+describe("webdriver.io page", function() {
+
+    it("should have the right title - the good old callback way", function(done) {
+
+        browser
+            .url("/")
+            .getTitle(function(err, title) {
+                assert.equal(err, undefined);
+                assert.equal(title, "WebdriverIO - Selenium 2.0 javascript bindings for nodejs");
+            })
+            .call(done);
+
+    });
+
+    it("should have the right title - the promise way", function() {
+
+        return browser
+            .url("/")
+            .getTitle().then(function(title) {
+                assert.equal(title, "WebdriverIO - Selenium 2.0 javascript bindings for nodejs");
+            });
+
+    });
+});
+
+import * as webdriverio from "webdriverio";
+
+describe("my webdriverio tests", function(){
+
+    this.timeout(99999999);
+    var client: webdriverio.Client<void>;
+
+    before(function(done){
+        client = webdriverio.remote({ desiredCapabilities: {browserName: "phantomjs"} });
+        client.init(done);
+    });
+
+    it("Github test",function(done) {
+        client
+            .url("https://github.com/")
+            .getElementSize(".header-logo-wordmark", function(err: any, result: webdriverio.Size) {
+                assert.equal(undefined, err);
+                assert.strictEqual(result.height, 26);
+                assert.strictEqual(result.width, 89);
+            })
+            .getTitle(function(err: any, title: string) {
+                assert.equal(undefined, err);
+                assert.strictEqual(title,"GitHub · Where software is built");
+            })
+            .getCssProperty("a[href='/plans']", "color", function(err: any, result: webdriverio.CssProperty){
+                assert.equal(undefined, err);
+                assert.strictEqual(result.value, "rgba(64,120,192,1)");
+            })
+            .call(done);
+    });
+
+    after(function(done) {
+        client.end(done);
+    });
+});
+
+var matrix = webdriverio.multiremote({
+        browserA: {
+            desiredCapabilities: {
+                browserName: "chrome",
+                chromeOptions: {
+                    args: [
+                        "use-fake-device-for-media-stream",
+                        "use-fake-ui-for-media-stream",
+                    ]
+                }
+            }
+        },
+        browserB: {
+            desiredCapabilities: {
+                browserName: "chrome",
+                chromeOptions: {
+                    args: [
+                        "use-fake-device-for-media-stream",
+                        "use-fake-ui-for-media-stream",
+                    ]
+                }
+            }
+        }
+    });
+
+var channel = Math.round(Math.random() * 100000000000);
+
+matrix
+    .init()
+    .url("https://apprtc.appspot.com/r/" + channel)
+    .click("#confirm-join-button")
+    .pause(5000)
+    .end();
+
+var options = {
+    desiredCapabilities: {
+        browserName: "chrome"
+    }
+};
+
+webdriverio
+    .remote(options)
+    .init()
+    .url("https://news.ycombinator.com/")
+    .selectorExecute("//div", function(inputs: HTMLElement[], message: string) {
+        return inputs.length + " " + message;
+    }, "divs on the page")
+    .then(function(res){
+        console.log(res);
+    })
+    .end();
+
+webdriverio
+    .remote(options)
+    .init()
+    .url("http://www.google.com/")
+    .waitForVisible("//input[@type='submit']", 5000)
+    .then(function(visible){
+        console.log(visible); //Should return true
+    })
+    .end();
diff --git a/webdriverio/webdriverio.d.ts b/webdriverio/webdriverio.d.ts
new file mode 100644
index 000000000..c123c47c8
--- /dev/null
+++ b/webdriverio/webdriverio.d.ts
@@ -0,0 +1,1064 @@
+// Type definitions for webdriverio 3.3.0
+// Project: http://www.webdriver.io/
+// Definitions by: Nick Malaguti <https://github.com/nmalaguti/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts"/>
+/// <reference path="../q/Q.d.ts"/>
+
+declare namespace WebdriverIO {
+    // EventEmitter
+    export interface Client<T> {
+        addListener(event: string, listener: Function): Client<T>;
+        on(event: string, listener: Function): Client<T>;
+        once(event: string, listener: Function): Client<T>;
+        removeListener(event: string, listener: Function): Client<T>;
+        removeAllListeners(event?: string): Client<T>;
+        setMaxListeners(n: number): Client<T>;
+        listeners(event: string): Client<T>;
+        emit(event: string, ...args: any[]): Client<T>;
+    }
+
+    // Promise
+    export interface Client<T> {
+        call(callback: () => any): Client<void>;
+        finally(callback: () => any): Client<T>;
+        then<P>(onFulfilled?: (value: T) => P | Client<P>, onRejected?: (err: any) => P | Client<P>): Client<P>;
+        catch<P>(onRejected?: (err: any) => P | Client<P>): Client<P>;
+        inspect(): Q.PromiseState<T>;
+    }
+
+    // Action
+    export interface Client<T> {
+        addValue(selector: string, value: string | number): Client<void>;
+        addValue<P>(
+            selector: string,
+            value: string | number,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        clearElement(selector: string): Client<void>;
+        clearElement<P>(
+            selector: string,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        click(selector: string): Client<void>;
+        click<P>(
+            selector: string,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        doubleClick(selector: string): Client<void>;
+        doubleClick<P>(
+            selector: string,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        dragAndDrop(sourceElem: string, destinationElem: string): Client<void>;
+        dragAndDrop<P>(
+            sourceElem: string,
+            destinationElem: string, callback: (err: any) => P
+        ): Client<P>;
+
+        leftClick(selector: string): Client<void>;
+        leftClick<P>(
+            selector: string,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        middleClick(selector: string): Client<void>;
+        middleClick<P>(
+            selector: string,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        moveToObject(selector: string): Client<void>;
+        moveToObject(selector: string, xoffset: number, yoffset: number): Client<void>;
+        moveToObject<P>(
+            selector: string,
+            callback: (err: any) => P
+        ): Client<P>;
+        moveToObject<P>(
+            selector: string,
+            xoffset: number,
+            yoffset: number,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        rightClick(selector: string): Client<void>;
+        rightClick<P>(
+            selector: string,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        selectByIndex(selectElem: string, index: number): Client<void>;
+        selectByIndex<P>(
+            selectElem: string,
+            index: number,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        selectByValue(selectElem: string, value: string): Client<void>;
+        selectByValue<P>(
+            selectElem: string,
+            value: string,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        selectByVisibleText(selectElem: string, text: string): Client<void>;
+        selectByVisibleText<P>(
+            selectElem: string,
+            text: string,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        selectorExecute<P>(
+            selectors: string | string[],
+            script: (elements: HTMLElement | HTMLElement[], ...args: any[]) => P,
+            ...args: any[]
+        ): Client<P>;
+
+        selectorExecuteAsync<P>(
+            selectors: string | string[],
+            script: (elements: HTMLElement | HTMLElement[], ...args: any[]) => P,
+            ...args: any[]
+        ): Client<P>;
+
+        setValue(selector: string, values: number | string | Array<string>): Client<void>;
+        setValue<P>(
+            selector: string,
+            values: number | string | Array<string>,
+            callback: (err: any) => P
+        ): Client<void>;
+
+        submitForm(selector: string): Client<void>;
+        submitForm<P>(
+            selector: string,
+            callback: (err: any) => P
+        ): Client<void>;
+    }
+
+    // Appium
+    export interface Client<T> {
+        // backgroundApp
+        // closeApp
+        // context
+        // contexts
+        // deviceKeyEvent
+        // getAppStrings
+        // getCurrentDeviceActivity
+        // getNetworkConnection
+        // hideDeviceKeyboard
+        // installAppOnDevice
+        // isAppInstalledOnDevice
+        // launchApp
+        // lock
+        // openNotifications
+        // performMultiAction
+        // performTouchAction
+        // pullFileFromDevice
+        // pushFileToDevice
+        // removeAppFromDevice
+        // resetApp
+        // rotate
+        // setImmediateValueInApp
+        // setNetworkConnection
+        // shake
+        // toggleAirplaneModeOnDevice
+        // toggleDataOnDevice
+        // toggleLocationServicesOnDevice
+        // toggleWiFiOnDevice
+    }
+
+    export interface Cookie {
+        name: string;
+        value: string;
+    }
+
+    // Cookie
+    export interface Client<T> {
+        deleteCookie(name?: string): Client<void>;
+        deleteCookie<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+        deleteCookie<P>(
+            name: string,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        getCookie(): Client<Cookie[]>;
+        getCookie(name: string): Client<Cookie>;
+        getCookie<P>(
+            callback: (err: any, cookies: Cookie[]) => P
+        ): Client<P>;
+        getCookie<P>(
+            name: string,
+            callback: (err: any, cookie: Cookie) => P
+        ): Client<P>;
+
+        setCookie(cookie: Cookie): Client<void>;
+        setCookie<P>(
+            cookie: Cookie,
+            callback: (err: any) => P
+        ): Client<P>;
+    }
+
+    // Mobile
+    export interface Client<T> {
+        // flick
+        // flickDown
+        // flickLeft
+        // flickRight
+        // flickUp
+        // getGeoLocation
+        // getOrientation
+        // hold
+        // release
+        // setGeoLocation
+        // setOrientation
+        // touch
+    }
+
+    export interface CssProperty {
+        property: string;
+        value: string;
+        parsed: ParsedCssProperty;
+    }
+
+    export interface ParsedCssProperty {
+        type: string;
+        string: string;
+        quote: string;
+        unit: string;
+        value: string | number | string[] | number[];
+    }
+
+    export interface Size {
+        width: number;
+        height: number;
+    }
+
+    export interface Location {
+        x: number;
+        y: number;
+    }
+
+    // Property
+    export interface Client<T> {
+        getAttribute(selector: string, attributeName: string): Client<string | string[]>;
+        getAttribute<P>(
+            selector: string,
+            attributeName: string,
+            callback: (err: any, attribute: string | string[]) => P
+        ): Client<P>;
+
+        getCssProperty(selector: string, cssProperty: string): Client<CssProperty | CssProperty[]>;
+        getCssProperty<P>(
+            selector: string,
+            cssProperty: string,
+            callback: (err: any, cssProperty: CssProperty | CssProperty[]) => P
+        ): Client<P>;
+
+        getElementSize(selector: string): Client<Size | Size[]>;
+        getElementSize(selector: string, dimension: string): Client<number | number[]>;
+        getElementSize<P>(
+            selector: string,
+            callback: (err: any, size: Size | Size[]) => P
+        ): Client<P>;
+        getElementSize<P>(
+            selector: string,
+            dimension: string,
+            callback: (err: any, elementSize: number | number[]) => P
+        ): Client<P>;
+
+        getHTML(selector: string, includeSelectorTag?: boolean): Client<string | string[]>;
+        getHTML<P>(
+            selector: string,
+            callback: (err: any, html: string | string[]) => P
+        ): Client<P>;
+        getHTML<P>(
+            selector: string,
+            includeSelectorTag: boolean,
+            callback: (err: any, html: string | string[]) => P
+        ): Client<P>;
+
+        getLocation(selector: string): Client<Size>;
+        getLocation(selector: string, axis: string): Client<number>;
+        getLocation<P>(
+            selector: string,
+            callback: (err: any, size: Size) => P
+        ): Client<P>;
+        getLocation<P>(
+            selector: string,
+            axis: string,
+            callback: (err: any, location: number) => P
+        ): Client<P>;
+
+        getLocationInView(selector: string): Client<Size | Size[]>;
+        getLocationInView(selector: string, axis: string): Client<number | number[]>;
+        getLocationInView<P>(
+            selector: string,
+            callback: (err: any, size: Size | Size[]) => P
+        ): Client<P>;
+        getLocationInView<P>(
+            selector: string,
+            axis: string,
+            callback: (err: any, location: number | number[]) => P
+        ): Client<P>;
+
+        getSource(): Client<string>;
+        getSource<P>(callback: (err: any, source: string) => P): Client<P>;
+
+        getTagName(selector: string): Client<string | string[]>;
+        getTagName<P>(
+            selector: string,
+            callback: (err: any, tagName: string | string[]) => P
+        ): Client<P>;
+
+        getText(selector: string): Client<string | string[]>;
+        getText<P>(
+            selector: string,
+            callback: (err: any, text: string | string[]) => P
+        ): Client<P>;
+
+        getTitle(): Client<string>;
+        getTitle<P>(
+            callback: (err: any, title: string) => P
+        ): Client<P>;
+
+        getUrl(): Client<string>;
+        getUrl<P>(
+            callback: (err: any, title: string) => P
+        ): Client<P>;
+
+        getValue(selector: string): Client<string | string[]>;
+        getValue<P>(
+            selector: string,
+            callback: (err: any, value: string | string[]) => P
+        ): Client<P>;
+    }
+
+    export interface LogEntry {
+        timestamp: number;
+        level: string;
+        message: string;
+    }
+
+    export enum ApplicationCacheStatus {
+        UNCACHED = 0,
+        IDLE = 1,
+        CHECKING = 2,
+        DOWNLOADING = 3,
+        UPDATE_READY = 4,
+        OBSOLETE = 5
+    }
+
+    export enum Button {
+        left = 0,
+        middle = 1,
+        right = 2
+    }
+
+    export interface StorageItem {
+        key: string;
+        value: any;
+    }
+
+    export interface Location {
+        latitude: number;
+        longitude: number;
+        altitude: number;
+    }
+
+    export interface Session {
+        id: string;
+        capabilities: any;
+    }
+
+    export interface RawResult<T> {
+        value: T;
+    }
+
+    // Navigation
+    export interface Client<T> {
+        back(): Client<void>;
+        back<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+
+        forward(): Client<void>;
+        forward<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+
+        refresh(): Client<void>;
+        refresh<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+
+        url(): Client<RawResult<string>>;
+        url(url: string): Client<void>;
+        url<P>(
+            callback: (err: any, result: RawResult<string>) => P
+        ): Client<P>;
+        url<P>(
+            url: string,
+            callback: (err: any) => P
+        ): Client<P>;
+    }
+
+    // Advanced input
+    export interface Client<T> {
+        // you probably want to use the click and drag and drop commands instead
+        buttonDown(button?: string | Button): Client<void>;
+        buttonDown<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+        buttonDown<P>(
+            button: string | Button,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        // you probably want to use the click and drag and drop commands instead
+        buttonPress(button?: string | Button): Client<void>;
+        buttonPress<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+        buttonPress<P>(
+            button: string | Button,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        // you probably want to use the click and drag and drop commands instead
+        buttonUp(button?: string | Button): Client<void>;
+        buttonUp<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+        buttonUp(button?: string | Button): Client<void>;
+        buttonUp<P>(
+            button: string | Button,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        // you probably want to use the click and drag and drop commands instead
+        doDoubleClick(): Client<void>;
+        doDoubleClick<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+
+        // you probably want to use addValue and setValue instead
+        keys(value: string | string[]): Client<void>;
+        keys<P>(
+            value: string | string[],
+            callback: (err: any) => P
+        ): Client<P>;
+
+        // you probably want to use the moveToObject command instead
+        moveTo(id: ElementId, xoffset?: number, yoffset?: number): Client<void>;
+        moveTo(xoffset?: number, yoffset?: number): Client<void>;
+        moveTo<P>(
+            id: ElementId,
+            callback: (err: any) => P
+        ): Client<P>;
+        moveTo<P>(
+            id: ElementId,
+            xoffset: number,
+            callback: (err: any) => P
+        ): Client<P>;
+        moveTo<P>(
+            id: ElementId,
+            xoffset: number,
+            yoffset: number,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        // touchClick
+        // touchDoubleClick
+        // touchDown
+        // touchFlick
+        // touchLongClick
+        // touchMove
+        // touchScroll
+        // touchUp
+    }
+
+    // Useful Protocol
+    export interface Client<T> {
+        alertAccept(): Client<void>;
+        alertAccept<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+
+        alertDismiss(): Client<void>;
+        alertDismiss<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+
+        alertText(text?: string): Client<string>;
+        alertText<P>(
+            callback: (err: any, text: string) => P
+        ): Client<P>;
+        alertText<P>(
+            text: string,
+            callback: (err: any, text: string) => P
+        ): Client<P>;
+
+        frame(id: any): Client<void>;
+        frame<P>(
+            id: any,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        frameParent(): Client<void>;
+        frameParent<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+
+        init(capabilities?: DesiredCapabilities): Client<void>;
+        init<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+        init<P>(
+            capabilities: DesiredCapabilities,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        log(type: string): Client<RawResult<LogEntry[]>>;
+        log<P>(
+            type: string,
+            callback: (err: any, result: RawResult<LogEntry[]>) => P
+        ): Client<P>;
+
+        logTypes(): Client<RawResult<string[]>>;
+        logTypes<P>(
+            callback: (err: any, result: RawResult<string[]>) => P
+        ): Client<P>;
+
+        session(action?: string, sessionId?: string): Client<RawResult<any>>;
+        session<P>(
+            callback: (err: any, result: RawResult<any>) => P
+        ): Client<P>;
+        session<P>(
+            action: string,
+            callback: (err: any, result: RawResult<any>) => P
+        ): Client<P>;
+        session<P>(
+            action: string,
+            sessionId: string,
+            callback: (err: any, result: RawResult<any>) => P
+        ): Client<P>;
+
+        sessions(): Client<RawResult<Session[]>>;
+        sessions<P>(
+            callback: (err: any, sessions: RawResult<Session[]>) => P
+        ): Client<P>;
+
+        // timeouts
+        // timeoutsAsyncScript
+        // timeoutsImplicitWait
+
+        // window
+        // windowHandle
+        // windowHandleMaximize
+        // windowHandlePosition
+        // windowHandleSize
+        // windowHandles
+    }
+
+    export type ElementId = string;
+
+    export interface Element {
+        ELEMENT: ElementId;
+    }
+
+    // Element
+    export interface Client<T> {
+        element(selector: string): Client<RawResult<Element>>;
+        element<P>(
+            selector: string,
+            callback: (err: any, result: RawResult<Element>) => P
+        ): Client<P>;
+
+        elementActive(): Client<RawResult<Element>>;
+        elementActive<P>(
+            callback: (err: any, element: Element) => P
+        ): Client<P>;
+
+        elementIdAttribute(id: ElementId, attributeName: string): Client<RawResult<string>>;
+        elementIdAttribute<P>(
+            id: ElementId,
+            attributeName: string,
+            callback: (err: any, result: RawResult<string>) => P
+        ): Client<P>;
+
+        elementIdClear(id: ElementId): Client<void>;
+        elementIdClear<P>(
+            id: ElementId,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        elementIdClick(id: ElementId): Client<void>;
+        elementIdClick<P>(
+            id: ElementId,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        elementIdCssProperty(id: ElementId, propertyName: string): Client<RawResult<string>>;
+        elementIdCssProperty<P>(
+            id: ElementId,
+            propertyName: string,
+            callback: (err: any, result: RawResult<string>) => P
+        ): Client<P>;
+
+        elementIdDisplayed(id: ElementId): Client<RawResult<boolean>>;
+        elementIdDisplayed<P>(
+            id: ElementId,
+            callback: (err: any, result: RawResult<boolean>) => P
+        ): Client<P>;
+
+        elementIdElement(id: ElementId, selector: string): Client<RawResult<Element>>;
+        elementIdElement<P>(
+            id: ElementId,
+            selector: string,
+            callback: (err: any, result: RawResult<Element>) => P
+        ): Client<P>;
+
+        elementIdElements(id: ElementId, selector: string): Client<RawResult<Element[]>>;
+        elementIdElements<P>(
+            id: ElementId,
+            selector: string,
+            callback: (err: any, result: RawResult<Element[]>) => P
+        ): Client<P>;
+
+        elementIdEnabled(id: ElementId): Client<RawResult<boolean>>;
+        elementIdEnabled<P>(
+            id: ElementId,
+            callback: (err: any, result: RawResult<boolean>) => P
+        ): Client<P>;
+
+        elementIdLocation(id: ElementId): Client<RawResult<Location>>;
+        elementIdLocation<P>(
+            id: ElementId,
+            callback: (err: any, result: RawResult<Location>) => P
+        ): Client<P>;
+
+        elementIdLocationInView(id: ElementId): Client<RawResult<Location>>;
+        elementIdLocationInView<P>(
+            id: ElementId,
+            callback: (err: any, result: RawResult<Location>) => P
+        ): Client<P>;
+
+        elementIdName(id: ElementId): Client<RawResult<string>>;
+        elementIdName<P>(
+            id: ElementId,
+            callback: (err: any, result: RawResult<string>) => P
+        ): Client<P>;
+
+        elementIdSelected(id: ElementId): Client<RawResult<boolean>>;
+        elementIdSelected<P>(
+            id: ElementId,
+            callback: (err: any, result: RawResult<boolean>) => P
+        ): Client<P>;
+
+        elementIdSize(id: ElementId): Client<RawResult<Size>>;
+        elementIdSize<P>(
+            id: ElementId,
+            callback: (err: any, result: RawResult<Size>) => P
+        ): Client<P>;
+
+        elementIdText(id: ElementId): Client<RawResult<string>>;
+        elementIdText<P>(
+            id: ElementId,
+            callback: (err: any, result: RawResult<string>) => P
+        ): Client<P>;
+
+        elementIdValue(id: ElementId, values: string | string[]): Client<RawResult<void>>;
+        elementIdValue<P>(
+            id: ElementId,
+            values: string | string[],
+            callback: (err: any, result: RawResult<void>) => P
+        ): Client<P>;
+
+        elements(selector: string): Client<RawResult<Element[]>>;
+        elements<P>(
+            selector: string,
+            callback: (err: any, result: RawResult<Element[]>) => P
+        ): Client<P>;
+    }
+
+    // Unuseful Protocol
+    export interface Client<T> {
+        // applicationCacheStatus
+        // cookie
+
+        // use selectorExecute instead
+        execute(script: string | Function, ...args: any[]): Client<RawResult<any>>;
+
+        // use selectorExecuteAsync instead
+        executeAsync(script: string | Function, ...args: any[]): Client<RawResult<any>>;
+
+        // file
+        // imeActivate
+        // imeActivated
+        // imeActiveEngine
+        // imeAvailableEngines
+        // imeDeactivated
+        // localStorage
+        // localStorageSize
+        // location
+        // orientation
+        // screenshot
+        // sessionStorage
+        // sessionStorageSize
+        // source
+        // status
+
+        // use submitForm instead
+        submit(id: ElementId): Client<void>;
+        submit<P>(
+            id: ElementId,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        // title
+    }
+
+    // State
+    export interface Client<T> {
+        isEnabled(selector: string): Client<boolean>;
+        isEnabled<P>(
+            selector: string,
+            callback: (err: any, isEnabled: boolean) => P
+        ): Client<P>;
+
+        isExisting(selector: string): Client<boolean>;
+        isExisting<P>(
+            selector: string,
+            callback: (err: any, isExisting: boolean) => P
+        ): Client<P>;
+
+        isSelected(selector: string): Client<boolean>;
+        isSelected<P>(
+            selector: string,
+            callback: (err: any, isSelected: boolean) => P
+        ): Client<P>;
+
+        isVisible(selector: string): Client<boolean>;
+        isVisible<P>(
+            selector: string,
+            callback: (err: any, isVisible: boolean) => P
+        ): Client<P>;
+
+        isVisibleWithinViewport(selector: string): Client<boolean>;
+        isVisibleWithinViewport<P>(
+            selector: string,
+            callback: (err: any, isVisible: boolean) => P
+        ): Client<P>;
+    }
+
+    export interface CommandHistoryEntry {
+        command: string;
+        args: any[];
+    }
+
+    // Utility
+    export interface Client<T> {
+        addCommand(commandName: string, customMethod: Function, overwrite?: boolean): Client<void>;
+        addCommand<P>(
+            commandName: string,
+            customMethod: Function,
+            callback: (err: any) => P
+        ): Client<P>;
+        addCommand<P>(
+            commandName: string,
+            customMethod: Function,
+            overwrite: boolean,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        chooseFile(selector: string, localPath: string): Client<void>;
+        chooseFile<P>(
+            selector: string,
+            localPath: string,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        debug(): Client<void>;
+        debug<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+
+        end(): Client<void>;
+        end<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+
+        endAll(): Client<void>;
+        endAll<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+
+        getCommandHistory(): Client<CommandHistoryEntry[]>;
+        getCommandHistory<P>(
+            callback: (err: any, history: CommandHistoryEntry[]) => P
+        ): Client<P>;
+
+        pause(milliseconds: number): Client<void>;
+        pause<P>(milliseconds: number, callback: (err: any) => P): Client<P>;
+
+        saveScreenshot(filename?: string): Client<Buffer>;
+        saveScreenshot<P>(
+            callback: (err: any, screenshot: Buffer) => P
+        ): Client<P>;
+        saveScreenshot<P>(
+            filename: string,
+            callback: (err: any, screenshot: Buffer) => P
+        ): Client<P>;
+
+        scroll(selector: string): Client<void>;
+        scroll(selector: string, xoffset: number, yoffset: number): Client<void>;
+        scroll(xoffset: number, yoffset: number): Client<void>;
+        scroll<P>(
+            selector: string,
+            callback: (err: any) => P
+        ): Client<P>;
+        scroll<P>(
+            selector: string,
+            xoffset: number,
+            yoffset: number,
+            callback: (err: any) => P
+        ): Client<P>;
+        scroll<P>(
+            xoffset: number,
+            yoffset: number,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        uploadFile(localPath: string): Client<void>;
+        uploadFile<P>(
+            localPath: string,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        waitForEnabled(selector: string, milliseconds?: number, reverse?: boolean): Client<boolean>;
+        waitForEnabled<P>(
+            selector: string,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitForEnabled<P>(
+            selector: string,
+            milliseconds: number,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitForEnabled<P>(
+            selector: string,
+            milliseconds: number,
+            reverse: boolean,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+
+        waitForExist(selector: string, milliseconds?: number, reverse?: boolean): Client<boolean>;
+        waitForExist<P>(
+            selector: string,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitForExist<P>(
+            selector: string,
+            milliseconds: number,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitForExist<P>(
+            selector: string,
+            milliseconds: number,
+            reverse: boolean,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+
+        waitForSelected(selector: string, milliseconds?: number, reverse?: boolean): Client<boolean>;
+        waitForSelected<P>(
+            selector: string,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitForSelected<P>(
+            selector: string,
+            milliseconds: number,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitForSelected<P>(
+            selector: string,
+            milliseconds: number,
+            reverse: boolean,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+
+        waitForText(selector: string, milliseconds?: number, reverse?: boolean): Client<boolean>;
+        waitForText<P>(
+            selector: string,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitForText<P>(
+            selector: string,
+            milliseconds: number,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitForText<P>(
+            selector: string,
+            milliseconds: number,
+            reverse: boolean,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+
+        waitForValue(selector: string, milliseconds?: number, reverse?: boolean): Client<boolean>;
+        waitForValue<P>(
+            selector: string,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitForValue<P>(
+            selector: string,
+            milliseconds: number,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitForValue<P>(
+            selector: string,
+            milliseconds: number,
+            reverse: boolean,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+
+        waitForVisible(selector: string, milliseconds?: number, reverse?: boolean): Client<boolean>;
+        waitForVisible<P>(
+            selector: string,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitForVisible<P>(
+            selector: string,
+            milliseconds: number,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitForVisible<P>(
+            selector: string,
+            milliseconds: number,
+            reverse: boolean,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+
+        waitUntil(
+            condition: () => boolean | Q.IPromise<boolean>,
+            timeout?: number,
+            interval?: number
+        ): Client<boolean>;
+        waitUntil<P>(
+            condition: () => boolean | Q.IPromise<boolean>,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitUntil<P>(
+            condition: () => boolean | Q.IPromise<boolean>,
+            timeout: number,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+        waitUntil<P>(
+            condition: () => boolean | Q.IPromise<boolean>,
+            timeout: number,
+            interval: number,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
+    }
+
+    // Window
+    export interface Client<T> {
+        close(windowHandle?: string): Client<void>;
+        close<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+        close<P>(
+            windowHandle: string,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        getCurrentTabId(): Client<string>;
+        getCurrentTabId<P>(
+            callback: (err: any, tabId: string) => P
+        ): Client<P>;
+
+        getTabIds(): Client<string[]>;
+        getTabIds<P>(
+            callback: (err: any, tabIds: string[]) => P
+        ): Client<P>;
+
+        getViewportSize(): Client<Size>;
+        getViewportSize(dimension: string): Client<number>;
+        getViewportSize<P>(
+            callback: (err: any, size: Size) => P
+        ): Client<P>;
+        getViewportSize<P>(
+            dimension: string,
+            callback: (err: any, viewportSize: number) => P
+        ): Client<P>;
+
+        newWindow(url: string, windowName: string, windowFeatures: string): Client<string>;
+        newWindow<P>(
+            url: string,
+            windowName: string,
+            windowFeatures: string,
+            callback: (err: any, windowId: string) => P
+        ): Client<P>;
+
+        setViewportSize(size: Size, type: boolean): Client<void>;
+        setViewportSize<P>(
+            size: Size,
+            type: boolean,
+            callback: (err: any) => P
+        ): Client<P>;
+
+        switchTab(windowHandle?: string): Client<void>;
+        switchTab<P>(
+            callback: (err: any) => P
+        ): Client<P>;
+        switchTab<P>(
+            windowHandle: string,
+            callback: (err: any) => P
+        ): Client<P>;
+    }
+
+    export interface Options {
+        protocol: string;
+        waitforTimeout: number;
+        coloredLogs: boolean;
+        logLevel: string;
+        baseUrl: string;
+        desiredCapabilities: DesiredCapabilities;
+        screenshotPath: string;
+    }
+
+    // Options
+    export interface Client<T> {
+        options: Options;
+    }
+
+    export type DesiredCapabilities = any;
+
+    export interface RemoteOptions {
+        protocol?: string;
+        waitforTimeout?: number;
+        waitforInterval?: number;
+        coloredLogs?: boolean;
+        logLevel?: string;
+        baseUrl?: string;
+        desiredCapabilities?: DesiredCapabilities;
+    }
+
+    export interface MultiremoteOptions {
+        [key: string]: RemoteOptions;
+    }
+
+    export function remote(options?: RemoteOptions | string): Client<void>;
+
+    export function multiremote(options?: MultiremoteOptions): Client<void>;
+}
+
+declare var browser: WebdriverIO.Client<void>;
+
+declare module "webdriverio" {
+    export = WebdriverIO;
+}