diff --git a/webdriverio/index.d.ts b/webdriverio/index.d.ts
index dff87053d7..f091159263 100644
--- a/webdriverio/index.d.ts
+++ b/webdriverio/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for webdriverio 4.5.0
+// Type definitions for webdriverio 4.6
 // Project: http://www.webdriver.io/
 // Definitions by: Nick Malaguti <https://github.com/nmalaguti/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -7,238 +7,776 @@
 /// <reference types="q"/>
 
 declare namespace WebdriverIO {
+    export type Method = 'POST' | 'GET' | 'DELETE';
+
+    export interface RawResult<T> {
+        sessionId: string;
+        value: T;
+        state: 'failure' | 'success';
+        selector?: string;
+        message?: string;
+        hCode?: number;
+        class?: string;
+        error?: string;
+    }
+
+    export type ElementId = string;
+
+    export interface Element {
+        ELEMENT: ElementId;
+    }
+
+    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 Position {
+        x: number;
+        y: number;
+    }
+
+    export interface DOMRect {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    }
+
+    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 Status {
+        build?: {
+            version: string;
+            revision?: string;
+            time?: string;
+        };
+
+        os?: {
+            name: string;
+            arch?: string;
+            version?: string;
+        };
+
+        java?: {
+            version?: string;
+        };
+    }
+
+    export interface StorageItem {
+        key: string;
+        value: any;
+    }
+
+    export interface StorageItems {
+        [key: string]: any;
+    }
+
+    export interface GeoLocation {
+        latitude: number;
+        longitude: number;
+        altitude: number;
+    }
+
+    export interface CommandHistoryEntry {
+        command: string;
+        args: any[];
+    }
+
+    export type Axis = 'x' | 'y';
+
+    export type Timeouts = 'script' | 'pageLoad' | 'implicit';
+
+    export type PageLoadingStrategy = 'none' | 'eager' | 'normal';
+
+    export type LocatorStrategy = 'css selector'
+                                | 'link text'
+                                | 'partial link text'
+                                | 'tag name'
+                                | 'xpath';
+
+    export interface LogEntry {
+        timestamp: number;
+        level: string;
+        message: string;
+    }
+
+    export type LoggingPreferenceType =
+        'OFF'   | 'SEVERE' | 'WARNING' |
+        'INFO'  | 'CONFIG' | 'FINE' |
+        'FINER' | 'FINEST' | 'ALL';
+
+    export interface LoggingPreferences {
+        browser?: LoggingPreferenceType;
+        driver?: LoggingPreferenceType;
+        server?: LoggingPreferenceType;
+        client?: LoggingPreferenceType;
+    }
+
+    interface ProxyObject {
+        proxyType?: 'pac' | 'noproxy' | 'autodetect' | 'system' | 'manual';
+        proxyAutoconfigUrl?: string;
+        ftpProxy?: string;
+        ftpProxyPort?: number;
+        httpProxy?: string;
+        httpProxyPort?: number;
+        sslProxy?: string;
+        sslProxyPort?: number;
+        socksProxy?: string;
+        socksProxyPort?: number;
+        socksVersion?: string;
+        socksUsername?: string;
+        socksPassword?: string;
+    }
+
+    export interface Session {
+        id: string;
+        capabilities: DesiredCapabilities;
+    }
+
+    export interface Capabilities {
+        browserName: string;
+        acceptInsecureCerts?: boolean;
+        browserVersion?: string;
+        platformName?: string;
+        pageLoadStrategy?: PageLoadingStrategy;
+        proxy?: ProxyObject;
+        setWindowRect?: boolean;
+        timeouts?: Timeouts;
+        unhandledPromptBehavior?: string;
+    }
+
+    export interface DesiredCapabilities extends Capabilities {
+        // Read-only capabilities
+        cssSelectorsEnabled?: boolean;
+        handlesAlerts?: boolean;
+        version?: string;
+        platform?: string;
+
+        // Read-write capabilities
+        javascriptEnabled?: boolean;
+        databaseEnabled?: boolean;
+        locationContextEnabled?: boolean;
+        applicationCacheEnabled?: boolean;
+        browserConnectionEnabled?: boolean;
+        webStorageEnabled?: boolean;
+        acceptSslCerts?: boolean;
+        rotatable?: boolean;
+        nativeEvents?: boolean;
+        unexpectedAlertBehaviour?: string;
+        elementScrollBehavior?: number;
+
+        // Grid-specific
+        seleniumProtocol?: string;
+        maxInstances?: number;
+        environment?: string;
+
+        // Selenium RC (1.0) only
+        commandLineFlags?: string;
+        executablePath?: string;
+        timeoutInSeconds?: number;
+        onlyProxySeleniumTraffic?: boolean;
+        avoidProxy?: boolean;
+        proxyEverything?: boolean;
+        proxyRequired?: boolean;
+        browserSideLog?: boolean;
+        optionsSet?: boolean;
+        singleWindow?: boolean;
+        dontInjectRegex?: RegExp;
+        userJSInjection?: boolean;
+        userExtensions?: string;
+
+        // RemoteWebDriver specific
+        'webdriver.remote.sessionid'?: string;
+        'webdriver.remote.quietExceptions'?: boolean;
+
+        // Selenese-Backed-WebDriver specific
+        'selenium.server.url'?: string;
+
+        loggingPrefs?: {
+            browser?: LoggingPreferences;
+            driver?: LoggingPreferences;
+            server?: LoggingPreferences;
+            client?: LoggingPreferences;
+        };
+
+        // Firefox
+        firefox_binary?: string;
+        firefoxProfileTemplate?: string;
+        captureNetworkTraffic?: boolean;
+        addCustomRequestHeaders?: boolean;
+        trustAllSSLCertificates?: boolean;
+        changeMaxConnections?: boolean;
+        profile?: string;
+        pageLoadingStrategy?: string;
+
+        // IE specific
+        'ie.forceCreateProcessApi'?: boolean;
+        'ie.browserCommandLineSwitches'?: string;
+        'ie.usePerProcessProxy'?: boolean;
+        'ie.ensureCleanSession'?: boolean;
+        'ie.setProxyByServer'?: boolean;
+        ignoreProtectedModeSettings?: boolean;
+        ignoreZoomSetting?: boolean;
+        initialBrowserUrl?: string;
+        enablePersistentHover?: boolean;
+        enableElementCacheCleanup?: boolean;
+        requireWindowFocus?: boolean;
+        browserAttachTimeout?: number;
+        logFile?: string;
+        logLevel?: string;
+        host?: string;
+        extractPath?: string;
+        silent?: string;
+        killProcessesByName?: boolean;
+
+        // Safari specific
+        'safari.options'?: {
+            [name: string]: any;
+        };
+
+        cleanSession?: boolean;
+
+        // Chrome specific
+        chromeOptions?: {
+            args?: string[];
+            binary?: string;
+            extensions?: string[];
+
+            localState?: {
+                [name: string]: any;
+            };
+
+            detach?: boolean;
+            debuggerAddress?: string;
+            excludeSwitches?: string[];
+            minidumpPath?: string;
+
+            mobileEmulation?: {
+                [name: string]: any;
+            };
+
+            perfLoggingPrefs?: {
+                [name: string]: any;
+            };
+
+            windowTypes?: string[];
+        };
+
+        perfLoggingPrefs?: {
+            enableNetwork?: boolean;
+            enablePage?: boolean;
+            enableTimeline?: boolean;
+            tracingCategories?: boolean;
+            bufferUsageReportingInterval?: boolean;
+        };
+
+        // RC
+        honorSystemProxy?: boolean;
+        ensureCleanSession?: boolean;
+    }
+
+    export interface Cookie extends RawResult<string> {
+        name: string;
+        value: string;
+        path?: string;
+        httpOnly?: boolean;
+        expiry?: number;
+        secure: boolean;
+    }
+
+    export interface Suite {
+        file: string;
+        parent: string;
+        pending: boolean;
+        title: string;
+        type: string;
+    }
+
+    export interface Test extends Suite {
+        currentTest: string;
+        passed: boolean;
+        duration: any;
+    }
+
+    export interface Hooks {
+        onError<T>(error: Error): Promise<T> & undefined;
+
+        onPrepare<T>(
+            config: Options,
+            capabilities: DesiredCapabilities
+        ): Promise<T> & undefined;
+
+        onComplete<T>(exitCode: number): Promise<T> & undefined;
+
+        before<T>(
+            capabilities: DesiredCapabilities,
+            specs: string[]
+        ): Promise<T> & undefined;
+
+        beforeCommand<T>(
+            commandName: string,
+            args: any[]
+        ): Promise<T> & undefined;
+
+        beforeFeature<T>(feature: string): Promise<T> & undefined;
+        beforeHook<T>(): Promise<T> & undefined;
+        beforeScenario<T>(scenario: string): Promise<T> & undefined;
+
+        beforeSession<T>(
+            config: Options,
+            capabilities: DesiredCapabilities,
+            specs: string[]
+        ): Promise<T> & undefined;
+
+        beforeStep<T>(step: string): Promise<T> & undefined;
+        beforeSuite<T>(suite: Suite): Promise<T> & undefined;
+        beforeTest<T>(test: Test): Promise<T> & undefined;
+        afterHook<T>(): Promise<T> & undefined;
+
+        after<T>(
+            result: number,
+            capabilities: DesiredCapabilities,
+            specs: string[]
+        ): Promise<T> & undefined;
+
+        afterCommand<T>(
+            commandName: string,
+            args: any[],
+            result: any,
+            error?: Error
+        ): Promise<T> & undefined;
+
+        afterScenario<T>(scenario: any): Promise<T> & undefined;
+
+        afterSession<T>(
+            config: Options,
+            capabilities: DesiredCapabilities,
+            specs: string[]
+        ): Promise<T> & undefined;
+
+        afterStep<T>(stepResult: any): Promise<T> & undefined;
+        afterSuite<T>(suite: Suite): Promise<T> & undefined;
+        afterTest<T>(test: Test): Promise<T> & undefined;
+        afterFeature<T>(feature: string): Promise<T> & undefined;
+    }
+
+    export interface Options {
+        baseUrl?: string;
+        bail?: number;
+        coloredLogs?: boolean;
+        capabilities?: DesiredCapabilities[];
+        connectionRetryTimeout?: number;
+        connectionRetryCount?: number;
+        debug?: number;
+        execArgv?: string[] | null;
+        desiredCapabilities?: DesiredCapabilities;
+        exclude?: string[];
+        framework?: string;
+        hostname?: string;
+        isWDIO?: boolean;
+        protocol?: string;
+        port?: number;
+        path?: string;
+        plugins?: { [name: string]: any; };
+        reporters?: string | ((...args: any[]) => void);
+        reporterOptions?: { outputDir?: string; };
+        logLevel?: string;
+        maxInstances?: number;
+        maxInstancesPerCapability?: number;
+        maxSession?: number;
+        mochaOpts?: { [name: string]: any; };
+        jasmineNodeOpts?: { [name: string]: any; };
+        cucumberOpts?: { [name: string]: any; };
+        services?: string | ((...args: any[]) => void);
+        screenshotPath?: string;
+        specs?: string[];
+        seleniumLogs?: string;
+        suites?: { [name: string]: string[]; };
+        sync?: boolean;
+        waitforTimeout?: number;
+        waitforInterval?: number;
+        user?: string;
+        key?: string;
+    }
+
+   export interface UnknownOptions {
+     [name: string]: any;
+   }
+
+    export interface MultiRemoteOptions {
+        [name: string]: Options;
+    }
+
+    export interface Config extends Options, Hooks {}
+
+    export interface Client<T> {
+        desiredCapabilities: DesiredCapabilities;
+    }
+
+    export interface Client<T> {
+        sessionId: string;
+    }
+
+    // Options
+    export interface Client<T> {
+        options: Options;
+    }
+
+    export class Launcher {
+        constructor(file: string, data: Options);
+        run(): Promise<any>;
+    }
+
+    export class ErrorHandler {
+        constructor(type: string, msg: string | number);
+    }
+
+    export function multiremote(options: MultiRemoteOptions): Client<void>;
+    export function remote(options?: Options, modifier?: (...args: any[]) => any): Client<void>;
+
     // 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>;
+        addListener(
+            event: string,
+            listener: (...args: any[]) => void
+        ): Client<T>;
+
+        on(
+            event: string,
+           listener: (...args: any[]) => void
+        ): Client<T>;
+
+        once(
+            event: string,
+            listener: (...args: any[]) => void
+        ): Client<T>;
+
+        removeListener(
+            event: string,
+            listener: (...args: any[]) => void
+        ): Client<T>;
+
         removeAllListeners(event?: string): Client<T>;
         setMaxListeners(n: number): Client<T>;
         listeners(event: string): Client<T>;
-        emit(event: string, ...args: any[]): 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>;
+        finally(callback: (...args: any[]) => void): Client<T>;
+
+        then<P>(
+            onFulfilled?: (value: T) => P | Client<P>,
+            onRejected?: (error: any) => P | Client<P>
+        ): Client<P>;
+
+        catch<P>(
+            onRejected?: (error: any) => P | Client<P>
+        ): Client<P>;
+
         inspect(): Q.PromiseState<T>;
     }
 
-    // Action
     export interface Client<T> {
         addValue(
             selector: string,
             value: string | number
-        ): Client<void>;
-        addValue(value: string | number): Client<void>;
+        ): Client<RawResult<null>> & RawResult<null>;
+
+        addValue(value: string | number): Client<RawResult<null>> & RawResult<null>;
+
         addValue<P>(
             selector: string,
             value: string | number,
         ): Client<P>;
+
         addValue<P>(value: string | number): Client<P>;
 
-        clearElement(selector?: string): Client<void>;
+        clearElement(selector?: string): Client<RawResult<null>> & RawResult<null>;
         clearElement<P>(selector?: string): Client<P>;
 
-        click(selector?: string): Client<void>;
+        click(selector?: string): Client<RawResult<null>> & RawResult<null>;
         click<P>(selector?: string): Client<P>;
 
-        doubleClick(selector?: string): Client<void>;
+        doubleClick(selector?: string): Client<RawResult<null>> & RawResult<null>;
         doubleClick<P>(selector?: string): Client<P>;
 
         dragAndDrop(
             sourceElem: string,
             destinationElem: string
-        ): Client<void>;
-        dragAndDrop(destinationElem: string): Client<void>;
+        ): Client<RawResult<null>> & RawResult<null>;
+
         dragAndDrop<P>(
             sourceElem: string,
             destinationElem: string
         ): Client<P>;
+
+        dragAndDrop(destinationElem: string): Client<RawResult<null>> & RawResult<null>;
         dragAndDrop<P>(destinationElem: string): Client<P>;
 
-        leftClick(selector?: string): Client<void>;
+        leftClick(selector?: string): Client<RawResult<null>> & RawResult<null>;
+
+        leftClick(
+            selector: string,
+            xoffset?: number,
+            yoffset?: number
+        ): Client<RawResult<null>> & RawResult<null>;
+
+        leftClick(
+            xoffset?: number,
+            yoffset?: number
+        ): Client<void> & undefined;
+
         leftClick<P>(selector?: string): Client<P>;
 
-        middleClick(selector?: string): Client<void>;
+        leftClick<P>(
+            selector: string,
+            xoffset?: number,
+            yoffset?: number
+        ): Client<P>;
+
+        leftClick<P>(
+            xoffset?: number,
+            yoffset?: number
+        ): Client<P>;
+
+        middleClick(selector?: string): Client<RawResult<null>> & RawResult<null>;
+
+        middleClick(
+            selector: string,
+            xoffset?: number,
+            yoffset?: number
+        ): Client<RawResult<null>> & RawResult<null>;
+
+        middleClick(
+            xoffset?: number,
+            yoffset?: number
+        ): Client<RawResult<null>> & RawResult<null>;
+
         middleClick<P>(selector?: string): Client<P>;
 
-        moveToObject(selector?: string): Client<void>;
-        moveToObject(
+        middleClick<P>(
             selector: string,
-            xoffset: number,
-            yoffset: number
-        ): Client<void>;
-        moveToObject(
-            xoffset: number,
-            yoffset: number
-        ): Client<void>;
-        moveToObject<P>(selector?: string): Client<P>;
-        moveToObject<P>(
-            selector: string,
-            xoffset: number,
-            yoffset: number
-        ): Client<P>;
-        moveToObject<P>(
-            xoffset: number,
-            yoffset: number
+            xoffset?: number,
+            yoffset?: number
         ): Client<P>;
 
-        rightClick(selector?: string): Client<void>;
+        middleClick<P>(
+            xoffset?: number,
+            yoffset?: number
+        ): Client<P>;
+
+        moveToObject(selector?: string): Client<RawResult<null>> & RawResult<null>;
+
+        moveToObject(
+            selector: string,
+            xoffset?: number,
+            yoffset?: number
+        ): Client<RawResult<null>> & RawResult<null>;
+
+        moveToObject(
+            xoffset?: number,
+            yoffset?: number
+        ): Client<RawResult<null>> & RawResult<null>;
+
+        moveToObject<P>(selector?: string): Client<P>;
+
+        moveToObject<P>(
+            selector: string,
+            xoffset?: number,
+            yoffset?: number
+        ): Client<P>;
+
+        moveToObject<P>(
+            xoffset?: number,
+            yoffset?: number
+        ): Client<P>;
+
+        rightClick(selector?: string): Client<RawResult<null>> & RawResult<null>;
+
+        rightClick(
+            selector: string,
+            xoffset?: number,
+            yoffset?: number
+        ): Client<RawResult<null>> & RawResult<null>;
+
+        rightClick(
+            xoffset?: number,
+            yoffset?: number
+        ): Client<RawResult<null>> & RawResult<null>;
+
         rightClick<P>(selector?: string): Client<P>;
 
-        selectByAttribute(
+        rightClick<P>(
             selector: string,
-            attribute: string,
-            value: string
-        ): Client<void>;
-        selectByAttribute(
-            attribute: string,
-            value: string
-        ): Client<void>;
-        selectByAttribute<P>(
-            selector: string,
-            attribute: string,
-            value: string
+            xoffset?: number,
+            yoffset?: number
         ): Client<P>;
+
+        rightClick<P>(
+            xoffset?: number,
+            yoffset?: number
+        ): Client<P>;
+
+        selectByAttribute(
+            selector: string,
+            attribute: string,
+            value: string | number
+        ): Client<RawResult<null>> & RawResult<null>;
+
+        selectByAttribute(
+            attribute: string,
+            value: string | number
+        ): Client<RawResult<null>> & RawResult<null>;
+
+        selectByAttribute<P>(
+            selector: string,
+            attribute: string,
+            value: string | number
+        ): Client<P>;
+
         selectByAttribute<P>(
             attribute: string,
-            value: string
+            value: string | number
         ): Client<P>;
 
         selectByIndex(
             selectElem: string,
             index: number
-        ): Client<void>;
-        selectByIndex(index: number): Client<void>;
+        ): Client<RawResult<null>> & RawResult<null>;
+
+        selectByIndex(index: number): Client<RawResult<null>> & RawResult<null>;
+
         selectByIndex<P>(
             selectElem: string,
             index: number
         ): Client<P>;
+
         selectByIndex<P>(index: number): Client<P>;
 
         selectByValue(
             selectElem: string,
             value: string
-        ): Client<void>;
-        selectByValue(value: string): Client<void>;
+        ): Client<RawResult<null>> & RawResult<null>;
+
+        selectByValue(value: string): Client<RawResult<null>> & RawResult<null>;
+
         selectByValue<P>(
             selectElem: string,
             value: string
         ): Client<P>;
+
         selectByValue<P>(value: string): Client<P>;
 
         selectByVisibleText(
             selectElem: string,
             text: string
-        ): Client<void>;
-        selectByVisibleText(text: string): Client<void>;
+        ): Client<RawResult<null>> & RawResult<null>;
+
+        selectByVisibleText(text: string): Client<RawResult<null>> & RawResult<null>;
+
         selectByVisibleText<P>(
             selectElem: string,
             text: string
         ): Client<P>;
-        selectByVisibleText<P>(text: string): Client<P>;
+
+        selectByVisibleText<P>(text: string): Client<RawResult<null>> & RawResult<null>;
 
         selectorExecute<P>(
             selectors: string | string[],
             script: (elements: HTMLElement | HTMLElement[], ...args: any[]) => P,
             ...args: any[]
-        ): Client<P>;
+        ): Client<P> & any;
+
+        selectorExecute<P>(
+            selectors: string | string[],
+            script: (elements: HTMLElement | HTMLElement[], ...args: any[]) => P,
+            ...args: any[]
+        ): Client<P> & any;
 
         selectorExecuteAsync<P>(
             selectors: string | string[],
             script: (elements: HTMLElement | HTMLElement[], ...args: any[]) => P,
             ...args: any[]
-        ): Client<P>;
+        ): Client<P> & any;
 
         setValue(
             selector: string,
-            values: number | string | Array<string>
-        ): Client<void>;
+            values: number | string | string[]
+        ): Client<RawResult<null>> & RawResult<null>;
+
         setValue(
-            values: number | string | Array<string>
-        ): Client<void>;
+            values: number | string | string[]
+        ): Client<RawResult<null>> & RawResult<null>;
+
         setValue<P>(
             selector: string,
-            values: number | string | Array<string>
-        ): Client<void>;
-        setValue<P>(
-            values: number | string | Array<string>
-        ): Client<void>;
+            values: number | string | string[]
+        ): Client<void> & undefined;
 
-        submitForm(selector?: string): Client<void>;
+        setValue<P>(
+            values: number | string | string[]
+        ): Client<void> & undefined;
+
+        submitForm(selector?: string): Client<RawResult<null>> & RawResult<null>;
         submitForm<P>(selector?: string): Client<P>;
     }
 
-    // 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(name?: string): Client<RawResult<null>> & RawResult<null>;
         deleteCookie<P>(name?: string): Client<P>;
 
-        getCookie(): Client<Cookie[]>;
-        getCookie(name: string): Client<Cookie>;
+        getCookie(): Client<Cookie[]> & Cookie[];
+        getCookie(name: string): Client<Cookie> & Cookie;
         getCookie<P>(name?: string): Client<P>;
 
-        setCookie(cookie: Cookie): Client<void>;
+        setCookie(cookie: Cookie): Client<RawResult<null>> & RawResult<null>;
         setCookie<P>(cookie: Cookie): Client<P>;
     }
 
+    // Grid
     export interface Client<T> {
-        session(
-            action?: string,
-            sessionId?: string
-        ): Client<RawResult<any>>;
-        session<P>(): Client<P>;
-
-        getGridNodeDetails(): Client<Object>;
+        getGridNodeDetails(): Client<UnknownOptions> & UnknownOptions;
         getGridNodeDetails<P>(): Client<P>;
 
-        gridProxyDetails(): Client<Object>;
-        gridProxyDetails<P>(): Client <P>;
+        gridProxyDetails(): Client<UnknownOptions> & UnknownOptions;
+        gridProxyDetails<P>(): Client<P>;
 
-        gridTestSession(): Client<Object>;
-        gridProxyDetails<P>(): Client <P>;
+        gridTestSession(): Client<UnknownOptions> & UnknownOptions;
+        gridTestSession<P>(): Client<P>;
     }
 
     // Mobile
@@ -274,16 +812,32 @@ declare namespace WebdriverIO {
         release(selector: string): Client<T>;
         removeApp(bundleId: string): Client<T>;
         reset(): Client<T>;
-        rotate(x: number, y: number, duration?: number, radius?: number, rotation?: number, touchCount?: number): Client<T>;
-        setGeoLocation(location: { latitude: number, longitude: number, altitude: number }): Client<T>;
-        setImmediateValue(id: string, value: string | Array<string>): Client<T>;
+
+        rotate(
+            x: number,
+            y: number,
+            duration?: number,
+            radius?: number,
+            rotation?: number,
+            touchCount?: number
+        ): Client<T>;
+
+        setGeoLocation(location: GeoLocation): Client<T>;
+        setImmediateValue(id: string, value: string | string[]): Client<T>;
         setNetworkConnection(flags: 0 | 1 | 2 | 4 | 6): Client<T>;
         setOrientation(setTo: 'landscape' | 'portrait'): Client<T>;
         settings(settings?: { [key: string]: string }): Client<T>;
         shake(): Client<T>;
         startActivity(appPackage: string, activity: string): Client<T>;
         strings(language: string): Client<T>;
-        swipe(selector?: string, xOffset?: number, yOffset?: number, speed?: number): Client<T>;
+
+        swipe(
+            selector?: string,
+            xOffset?: number,
+            yOffset?: number,
+            speed?: number
+        ): Client<T>;
+
         swipeDown(selector: string, speed?: number): Client<T>;
         swipeLeft(selector: string, speed?: number): Client<T>;
         swipeRight(selector: string, speed?: number): Client<T>;
@@ -300,304 +854,184 @@ declare namespace WebdriverIO {
         unlock(): Client<T>;
     }
 
-    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;
+        ): Client<string> & Client<null> & string & null;
+
         getAttribute(
             selector: string,
             attributeName: string
-        ): Client<string[]> & string[];
-        getAttribute(attributeName: string): Client<string> & string;
-        getAttribute(attributeName: string): Client<string[]> & string[];
+        ): Client<string[]> & Client<null[]> & string[] & null[];
+
+        getAttribute(attributeName: string): Client<string> & Client<null> & string & null;
+        getAttribute(attributeName: string): Client<string[]> & Client<null[]> & string[] & null[];
+
         getAttribute<P>(
             selector: string,
             attributeName: string
         ): Client<P>;
+
         getAttribute<P>(attributeName: string): Client<P>;
 
         getCssProperty(
             selector: string,
             cssProperty: string
-        ): CssProperty;
+        ): Client<CssProperty> & CssProperty;
+
         getCssProperty(
             selector: string,
             cssProperty: string
-        ): CssProperty[];
-        getCssProperty(cssProperty: string): CssProperty;
-        getCssProperty(cssProperty: string): CssProperty[];
+        ): Client<CssProperty[]> & CssProperty[];
+
+        getCssProperty(cssProperty: string): Client<CssProperty> & CssProperty;
+        getCssProperty(cssProperty: string): Client<CssProperty[]> & CssProperty[];
+
         getCssProperty<P>(
             selector: string,
             cssProperty: string
         ): Client<P>;
+
         getCssProperty<P>(cssProperty: string): Client<P>;
 
         getElementSize(selector: string): Client<Size> & Size;
+        getElementSize(): Client<Size> & Size;
+
         getElementSize(selector: string): Client<Size[]> & Size[];
-        getElementSize(): Client<Size|Size[]> & Size|Size[];
+        getElementSize(): Client<Size[]> & Size[];
+
         getElementSize(
             selector: string,
-            dimension: string
-        ): number;
+            dimension?: string
+        ): Client<number> & number;
+
         getElementSize(
             selector: string,
-            dimension: string
-        ): number[];
-        getElementSize(dimension: string): number ;
-        getElementSize(dimension: string): number[];
+            dimension?: string
+        ): Client<number[]> & number[];
+
+        getElementSize(dimension?: string): Client<number> & number;
+        getElementSize(dimension?: string): Client<number[]> & number[];
+
         getElementSize<P>(selector?: string): Client<P>;
+        getElementSize<P>(dimension?: string): Client<P>;
+
         getElementSize<P>(
             selector: string,
-            dimension: string
+            dimension?: string
         ): Client<P>;
-        getElementSize<P>(dimension: string): Client<P>;
 
         getHTML(
             selector: string,
             includeSelectorTag?: boolean
-        ): string;
+        ): Client<string> & string;
+
         getHTML(
             selector: string,
             includeSelectorTag?: boolean
-        ): string[];
-        getHTML(includeSelectorTag?: boolean): string;
-        getHTML(includeSelectorTag?: boolean): string[];
+        ): Client<string[]> & string[];
+
+        getHTML(includeSelectorTag?: boolean): Client<string> & string;
+        getHTML(includeSelectorTag?: boolean): Client<string[]> & string[];
         getHTML<P>(selector?: string): Client<P>;
+
         getHTML<P>(
             selector: string,
-            includeSelectorTag: boolean
+            includeSelectorTag?: boolean
         ): Client<P>;
-        getHTML<P>(includeSelectorTag: boolean): Client<P>;
 
-        getLocation(axis: Axis): number;
-        getLocation<P>(axis: Axis): Client<P>;
-        getLocation(selector?: string): Location;
+        getHTML<P>(includeSelectorTag?: boolean): Client<P>;
+
+        getLocation(axis?: Axis): Client<number> & number;
+        getLocation<P>(axis?: Axis): Client<P>;
+        getLocation(selector?: string): Client<Position> & Position;
         getLocation<P>(selector?: string): Client<P>;
-        getLocation(selector: string, axis: Axis): number;
-        getLocation<P>(selector: string, axis: Axis): Client<P>;
+        getLocation(selector: string, axis?: Axis): Client<number> & number;
+        getLocation<P>(selector: string, axis?: Axis): Client<P>;
 
-        getLocationInView(axis: Axis): number;
-        getLocationInView(axis: Axis): number[];
-        getLocationInView<P>(axis: Axis): Client<P>;
-        getLocationInView(selector?: string): Location;
-        getLocationInView(selector?: string): Location[];
+        getLocationInView(axis?: Axis): Client<number> & number;
+        getLocationInView(axis?: Axis): Client<number[]> & number[];
+        getLocationInView<P>(axis?: Axis): Client<P>;
+        getLocationInView(selector?: string): Client<Position> & Position;
+        getLocationInView(selector?: string): Client<Position[]> & Position[];
         getLocationInView<P>(selector?: string): Client<P>;
-        getLocationInView(selector: string, axis: Axis): number;
-        getLocationInView(selector: string, axis: Axis): number[];
-        getLocationInView<P>(selector: string, axis: Axis): Client<P>;
+        getLocationInView(selector: string, axis?: Axis): Client<number> & number;
+        getLocationInView(selector: string, axis?: Axis): Client<number[]> & number[];
+        getLocationInView<P>(selector: string, axis?: Axis): Client<P>;
 
-        getSource(): Client<string>;
+        getSource(): Client<string> & string;
         getSource<P>(): Client<P>;
 
-        getTagName(selector?: string): string | string[];
+        getTagName(selector?: string): Client<string> & string;
+        getTagName(selector?: string): Client<string[]> & string[];
         getTagName<P>(selector?: string): Client<P>;
 
-        getText(selector?: string): string | string[];
+        getText(selector?: string): Client<string> & string;
+        getText(selector?: string): Client<string[]> & string[];
         getText<P>(selector?: string): Client<P>;
 
-        getTitle(): Client<string>;
+        getTitle(): Client<string> & string;
         getTitle<P>(): Client<P>;
 
-        getUrl(): Client<string>;
+        getUrl(): Client<string> & string;
         getUrl<P>(): Client<P>;
 
-        getValue(selector?: string): string | string[];
+        getValue(selector?: string): Client<string> & string;
+        getValue(selector?: string): Client<string[]> & string[];
         getValue<P>(selector?: string): 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 GeoLocation {
-        latitude: number;
-        longitude: number;
-        altitude: number;
-    }
-
-    export interface Session {
-        id: string;
-        capabilities: any;
-    }
-
-    export interface RawResult<T> {
-        value: T;
-        error: string;
-    }
-
-    // Navigation
+    // Protocol
     export interface Client<T> {
-        back(): Client<void>;
-        back<P>(): Client<P>;
-
-        forward(): Client<void>;
-        forward<P>(): Client<P>;
-
-        refresh(): Client<void>;
-        refresh<P>(): Client<P>;
-
-        url(): Client<RawResult<string>> & RawResult<string>;
-        url(url: string): Client<void>;
-        url<P>(url?: string): 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>(button?: string | Button): Client<P>;
-
-        // you probably want to use the click and drag and drop commands instead
-        buttonPress(button?: string | Button): Client<void>;
-        buttonPress<P>(button?: string | Button): Client<P>;
-
-        // you probably want to use the click and drag and drop commands instead
-        buttonUp(button?: string | Button): Client<void>;
-        buttonUp<P>(button?: string | Button): Client<P>;
-
-        // you probably want to use the click and drag and drop commands instead
-        doDoubleClick(): Client<void>;
-        doDoubleClick<P>(): Client<P>;
-
-        // you probably want to use addValue and setValue instead
-        keys(value: string | string[]): Client<void>;
-        keys<P>(value: string | string[]): 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): Client<P>;
-        moveTo<P>(
-            id: ElementId,
-            xoffset: number,
-            yoffset?: number
-        ): Client<P>;
-
-        // touchClick
-        // touchDoubleClick
-        // touchDown
-        // touchFlick
-        // touchLongClick
-        // touchMove
-        // touchScroll
-        // touchUp
-    }
-
-    // Useful Protocol
-    export interface Client<T> {
-        alertAccept(): Client<void>;
+        alertAccept(): Client<RawResult<null>>;
         alertAccept<P>(): Client<P>;
 
-        alertDismiss(): Client<void>;
+        alertDismiss(): Client<RawResult<null>>;
         alertDismiss<P>(): Client<P>;
 
-        alertText(text?: string): Client<string>;
-        alertText<P>(): Client<P>;
-        alertText<P>(text: string): Client<P>;
+        alertText(): Client<string> | string;
+        alertText(text: string): Client<null> | null;
+        alertText<P>(text?: string): Client<P>;
 
-        frame(id: any): Client<void>;
-        frame<P>(id: any): Client<P>;
+        /** @deprecated */
+        applicationCacheStatus(): Client<RawResult<ApplicationCacheStatus>> & RawResult<ApplicationCacheStatus> & never;
 
-        frameParent(): Client<void>;
-        frameParent<P>(): Client<P>;
+        /** @deprecated */
+        applicationCacheStatus<P>(): Client<P>;
 
-        init(capabilities?: DesiredCapabilities): Client<void>;
-        init<P>(capabilities?: DesiredCapabilities): Client<P>;
+        back(): Client<RawResult<null>>;
+        back<P>(): Client<P>;
 
-        log(type: string): Client<RawResult<LogEntry[]>>;
-        log<P>(type: string): Client<P>;
+        /** @deprecated in favour of Actions.pointerDown */
+        buttonDown(button?: string | Button): Client<RawResult<null>> & RawResult<null> & never;
 
-        logTypes(): Client<RawResult<string[]>> & RawResult<string[]>;
-        logTypes<P>(): Client<P>;
+        /** @deprecated in favour of Actions.pointerDown */
+        buttonDown<P>(button?: string | Button): Client<P>;
 
-        session(
-            action?: string,
-            sessionId?: string
-        ): Client<RawResult<any>> & RawResult<any>;
-        session<P>(action?: string): Client<P>;
-        session<P>(
-            action: string,
-            sessionId: string
-        ): Client<P>;
+        /** @deprecated in favour of Actions.pointerDown */
+        buttonPress(button?: string | Button): Client<RawResult<null>> & RawResult<null> & never;
 
-        sessions(): Client<RawResult<Session[]>>;
-        sessions<P>(): Client<P>;
+        /** @deprecated in favour of Actions.pointerDown */
+        buttonPress<P>(button?: string | Button): Client<P>;
 
-        timeouts<P>(type: string, ms: number): Client<P>;
-        timeoutsAsyncScript<P>(ms: number): Client<P>;
-        timeoutsImplicitWait<P>(ms: number): Client<P>;
+        buttonUp(button?: string | Button): Client<RawResult<null>> & RawResult<null>;
+        buttonUp<P>(button?: string | Button): Client<P>;
 
-        // window
-        // windowHandle
-        // windowHandleMaximize
-        // windowHandlePosition
-        // windowHandleSize
-        // windowHandles
-    }
+        cookie(): Client<RawResult<Cookie[]>> & RawResult<Cookie[]>;
 
-    export type ElementId = string;
+        cookie(
+            method: Method,
+            key?: Cookie | string
+        ): Client<RawResult<Cookie[]>> & RawResult<Cookie[]>;
 
-    export interface Element {
-        ELEMENT: ElementId;
-    }
+        /** @deprecated in favour of Actions.pointerDown(0) + Actions.pointerMove */
+        doDoubleClick(): Client<RawResult<null>> & RawResult<null> & never;
+
+        /** @deprecated in favour of Actions.pointerDown(0) + Actions.pointerMove */
+        doDoubleClick<P>(): Client<P>;
 
-    // Element
-    export interface Client<T> {
         element(selector: string): Client<RawResult<Element>> & RawResult<Element>;
         element<P>(selector: string): Client<P>;
 
@@ -608,33 +1042,39 @@ declare namespace WebdriverIO {
             id: ElementId,
             attributeName: string
         ): Client<RawResult<string>> & RawResult<string>;
+
         elementIdAttribute<P>(
             id: ElementId,
             attributeName: string
         ): Client<P>;
 
-        elementIdClear(id: ElementId): Client<void>;
+        elementIdClear(id: ElementId): Client<RawResult<null>> & RawResult<null>;
         elementIdClear<P>(id: ElementId): Client<P>;
 
-        elementIdClick(id: ElementId): Client<void>;
+        elementIdClick(id: ElementId): Client<RawResult<null>> & RawResult<null>;
         elementIdClick<P>(id: ElementId): Client<P>;
 
         elementIdCssProperty(
             id: ElementId,
             propertyName: string
         ): Client<RawResult<string>> & RawResult<string>;
+
         elementIdCssProperty<P>(
             id: ElementId,
             propertyName: string
         ): Client<P>;
 
-        elementIdDisplayed(id: ElementId): Client<RawResult<boolean>> & RawResult<boolean>;
+        /** @deprecated */
+        elementIdDisplayed(id: ElementId): Client<RawResult<boolean>> & RawResult<boolean> & never;
+
+        /** @deprecated */
         elementIdDisplayed<P>(id: ElementId): Client<P>;
 
         elementIdElement(
             id: ElementId,
             selector: string
         ): Client<RawResult<Element>> & RawResult<Element>;
+
         elementIdElement<P>(
             id: ElementId,
             selector: string
@@ -644,6 +1084,7 @@ declare namespace WebdriverIO {
             id: ElementId,
             selector: string
         ): Client<RawResult<Element[]>> & RawResult<Element[]>;
+
         elementIdElements<P>(
             id: ElementId,
             selector: string
@@ -652,19 +1093,31 @@ declare namespace WebdriverIO {
         elementIdEnabled(id: ElementId): Client<RawResult<boolean>> & RawResult<boolean>;
         elementIdEnabled<P>(id: ElementId): Client<P>;
 
-        elementIdLocation(id: ElementId): Client<RawResult<Location>> & RawResult<Location>;
+        /** @deprecated in favour of elementIdRect */
+        elementIdLocation(id: ElementId): Client<RawResult<Position>> & RawResult<Position> & never;
+
+        /** @deprecated in favour of elementIdRect */
         elementIdLocation<P>(id: ElementId): Client<P>;
 
-        elementIdLocationInView(id: ElementId): Client<RawResult<Location>> & RawResult<Location>;
-        elementIdLocationInView<P>(id: ElementId): Client<P>;
+        /** @deprecated in favour of elementIdRect */
+        elementIdLocationInView(id: ElementId): Client<RawResult<Position>> & RawResult<Position> & never;
 
-        elementIdName(id: ElementId): RawResult<string>;
+         /** @deprecated in favour of elementIdRect */
+       elementIdLocationInView<P>(id: ElementId): Client<P>;
+
+        elementIdName(id: ElementId): Client<RawResult<string>> & RawResult<string>;
         elementIdName<P>(id: ElementId): Client<P>;
 
+        elementIdRect(id: ElementId): Client<RawResult<DOMRect>> & RawResult<DOMRect>;
+        elementIdRect<P>(id: ElementId): Client<P>;
+
         elementIdSelected(id: ElementId): Client<RawResult<boolean>> & RawResult<boolean>;
         elementIdSelected<P>(id: ElementId): Client<P>;
 
-        elementIdSize(id: ElementId): Client<RawResult<Size>> & RawResult<Size>;
+         /** @deprecated in favour of elementIdRect */
+        elementIdSize(id: ElementId): Client<RawResult<Size>> & RawResult<Size> & never;
+
+         /** @deprecated in favour of elementIdRect */
         elementIdSize<P>(id: ElementId): Client<P>;
 
         elementIdText(id: ElementId): Client<RawResult<string>> & RawResult<string>;
@@ -673,7 +1126,8 @@ declare namespace WebdriverIO {
         elementIdValue(
             id: ElementId,
             values: string | string[]
-        ): Client<RawResult<void>>;
+        ): Client<RawResult<null>> & RawResult<null>;
+
         elementIdValue<P>(
             id: ElementId,
             values: string | string[]
@@ -681,87 +1135,447 @@ declare namespace WebdriverIO {
 
         elements(selector: string): Client<RawResult<Element[]>> & RawResult<Element[]>;
         elements<P>(selector: string): Client<P>;
-    }
 
-    // Unuseful Protocol
-    export interface Client<T> {
-        // applicationCacheStatus
-        // cookie
+        execute(
+            script: string | ((...args: any[]) => void),
+            ...args: any[]
+        ): Client<RawResult<any>> & RawResult<any>;
 
-        // use selectorExecute instead
-        execute(script: string | Function, ...args: any[]): Client<RawResult<any>> & RawResult<any>;
+        executeAsync(
+            script: string | ((...args: any[]) => void),
+            ...args: any[]
+        ): Client<RawResult<any>> & RawResult<any>;
 
-        // use selectorExecuteAsync instead
-        executeAsync(script: string | Function, ...args: any[]): Client<RawResult<any>> & RawResult<any>;
+         /** @deprecated */
+        file(date: string): Client<RawResult<null>> & never;
 
-        // file
-        // imeActivate
-        // imeActivated
-        // imeActiveEngine
-        // imeAvailableEngines
-        // imeDeactivated
-        // localStorage
-        // localStorageSize
-        // location
-        // orientation
-        // screenshot
-        // sessionStorage
-        // sessionStorageSize
-        // source
-        // status
+         /** @deprecated */
+        file<P>(date: string): Client<P> & never;
 
-        // use submitForm instead
-        submit(id: ElementId): Client<void>;
+        forward(): Client<RawResult<null>> & RawResult<null>;
+        forward<P>(): Client<P>;
+
+        frame(id: any): Client<RawResult<null>> & RawResult<null>;
+        frame<P>(id: any): Client<P>;
+
+        frameParent(): Client<RawResult<null>> & RawResult<null>;
+        frameParent<P>(): Client<P>;
+
+         /** @deprecated */
+        imeActivate(engine: string): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated */
+        imeActivate<P>(engine: string): Client<P> & never;
+
+         /** @deprecated */
+        imeActivated(): Client<RawResult<boolean>> & RawResult<boolean> & never;
+
+         /** @deprecated */
+        imeActivated<P>(): Client<P>;
+
+         /** @deprecated */
+        imeActiveEngine(): Client<RawResult<string>> & string & never;
+
+         /** @deprecated */
+        imeActiveEngine<P>(): Client<P>;
+
+         /** @deprecated */
+        imeAvailableEngines(): Client<RawResult<string[]>> & RawResult<string[]> & never;
+
+         /** @deprecated */
+        imeAvailableEngines<P>(): Client<P>;
+
+         /** @deprecated */
+        imeDeactivated(): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated */
+        imeDeactivated<P>(): Client<P>;
+
+        init(capabilities?: DesiredCapabilities): Client<RawResult<null>> & RawResult<null>;
+        init<P>(capabilities?: DesiredCapabilities): Client<P>;
+
+         /** @deprecated in favour of Actions.keyDown */
+        keys(value: string | string[]): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated in favour of Actions.keyDown */
+        keys<P>(value: string | string[]): Client<P>;
+
+         /** @deprecated */
+        localStorage(): Client<RawResult<StorageItems[]>> & RawResult<StorageItems[]>;
+
+         /** @deprecated */
+        localStorage<P>(): Client<P>;
+
+         /** @deprecated */
+        localStorage(
+            method: Method,
+            key?: string
+        ): Client<RawResult<StorageItems[]>> & RawResult<StorageItems[]> & never;
+
+         /** @deprecated */
+        localStorage(
+            method: Method,
+            key?: string
+        ): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated */
+        localStorage<P>(
+            method: Method,
+            key?: string | StorageItems
+        ): Client<P>;
+
+         /** @deprecated */
+        localStorageSize(): Client<RawResult<number>> & RawResult<number> & never;
+
+         /** @deprecated */
+        localStorageSize<P>(): Client<P>;
+
+         /** @deprecated in favour of elementIdRect */
+        location(type: GeoLocation): Client<RawResult<number>> & RawResult<number> & never;
+
+         /** @deprecated in favour of elementIdRect */
+        location<P>(type: GeoLocation): Client<P>;
+
+         /** @deprecated */
+        log(type: LoggingPreferences): Client<RawResult<LogEntry[]>> & never;
+
+         /** @deprecated */
+        log<P>(type: LoggingPreferences): Client<P>;
+
+         /** @deprecated */
+        logTypes(): Client<RawResult<LoggingPreferences[]>> & RawResult<LoggingPreferences[]> & never;
+
+         /** @deprecated */
+        logTypes<P>(): Client<P>;
+
+         /** @deprecated in favour of Actions.pointerMove */
+        moveTo(
+            id: ElementId,
+            xoffset: number,
+            yoffset: number
+        ): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated in favour of Actions.pointerMove */
+        moveTo(
+            xoffset: number,
+            yoffset: number
+        ): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated in favour of Actions.pointerMove */
+        moveTo<P>(id: ElementId): Client<P>;
+
+         /** @deprecated in favour of Actions.pointerMove */
+        moveTo<P>(
+            id: ElementId,
+            xoffset: number,
+            yoffset: number
+        ): Client<P>;
+
+        refresh(): Client<RawResult<null>> & RawResult<null>;
+        refresh<P>(): Client<P>;
+
+        screenshot(): Client<RawResult<string>> & RawResult<string>;
+
+        session<P>(): Client<P>;
+
+        session(
+            action?: Method,
+            sessionId?: string
+        ): Client<RawResult<DesiredCapabilities>> & RawResult<DesiredCapabilities>;
+
+        session<P>(action?: Method): Client<P>;
+
+        session<P>(
+            action?: Method,
+            sessionId?: string
+        ): Client<P> & null;
+
+         /** @deprecated */
+        sessions(): Client<RawResult<Session[]>> & RawResult<Session[]> & never;
+
+         /** @deprecated */
+        sessions<P>(): Client<P>;
+
+         /** @deprecated */
+        sessionStorage(): Client<RawResult<StorageItems>> & RawResult<StorageItems> & never;
+
+         /** @deprecated */
+        sessionStorage<P>(): Client<P>;
+
+         /** @deprecated */
+        sessionStorage(method: Method): Client<RawResult<string[]>> & RawResult<string[]> & never;
+
+         /** @deprecated */
+        sessionStorage(method: Method): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated */
+        sessionStorage<P>(method: Method): Client<P>;
+
+         /** @deprecated */
+        sessionStorage(
+            method: Method,
+            key: string
+        ): Client<RawResult<string[]>> & RawResult<string[]> & never;
+
+         /** @deprecated */
+        sessionStorage(
+            method: Method,
+            key: string
+        ): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated */
+        sessionStorage<P>(
+            method: Method,
+            key: string
+        ): Client<P>;
+
+         /** @deprecated */
+        sessionStorage(
+            method: Method,
+            key: StorageItems
+        ): Client<RawResult<null>> & RawResult<null>;
+
+         /** @deprecated */
+        sessionStorage<P>(
+            method: Method,
+            key: StorageItems
+        ): Client<P>;
+
+         /** @deprecated */
+        sessionStorageSize(): Client<RawResult<number>> & RawResult<number> & never;
+
+         /** @deprecated */
+        sessionStorageSize<P>(): Client<P>;
+
+        source(): Client<RawResult<string>> & RawResult<string>;
+        source<P>(): Client<P>;
+
+        status(): Client<RawResult<Status>> & RawResult<Status>;
+        status(): Client<string>;
+
+         /** @deprecated */
+        submit(id: ElementId): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated */
         submit<P>(id: ElementId): Client<P>;
 
-        // title
+        timeouts<P>(type: Timeouts, ms: number): Client<RawResult<null>> & RawResult<null>;
+
+         /** @deprecated in favour of timeouts */
+        timeoutsAsyncScript(ms: number): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated in favour of timeouts */
+        timeoutsAsyncScript<P>(ms: number): Client<P>;
+
+         /** @deprecated in favour of timeouts */
+        timeoutsImplicitWait(ms: number): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated in favour of timeouts */
+        timeoutsImplicitWait<P>(ms: number): Client<P>;
+
+        url(): Client<RawResult<string>> & RawResult<string>;
+        url(url: string): Client<RawResult<null>> & RawResult<null>;
+        url<P>(url?: string): Client<P>;
+
+        title(): Client<RawResult<string>> & RawResult<string>;
+        title<P>(): Client<P>;
+
+         /** @deprecated in favour of Actions.pointerDown */
+        touchClick(id: ElementId): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated in favour of Actions.pointerDown */
+        touchClick<P>(id: ElementId): Client<P>;
+
+         /** @deprecated in favour of Actions.pointerDown */
+        touchDown(
+            xoffset: number,
+            yoffset: number
+        ): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated in favour of Actions.pointerDown */
+        touchDown<P>(
+            xoffset: number,
+            yoffset: number
+        ): Client<P>;
+
+         /** @deprecated in favour of Actions.perform */
+        touchFlick(
+            id: ElementId,
+            xoffset: number,
+            yoffset: number,
+            speed: number
+        ): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated in favour of Actions.perform */
+        touchFlick<P>(
+            id: ElementId,
+            xoffset: number,
+            yoffset: number,
+            speed: number
+        ): Client<P>;
+
+         /** @deprecated in favour of Actions.perform */
+        touchLongClick(id: ElementId): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated in favour of Actions.perform */
+        touchLongClick<P>(id: ElementId): Client<P>;
+
+         /** @deprecated in favour of Actions.pointerMove */
+        touchMove(
+            xoffset: number,
+            yoffset: number
+        ): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated in favour of Actions.pointerMove */
+        touchMove<P>(
+            xoffset: number,
+            yoffset: number
+        ): Client<P>;
+
+         /** @deprecated in favour of Actions.perform */
+        touchScroll(
+            id: ElementId,
+            xoffset: number,
+            yoffset: number,
+        ): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated in favour of Actions.perform */
+        touchScroll<P>(
+            id: ElementId,
+            xoffset: number,
+            yoffset: number,
+        ): Client<P>;
+
+         /** @deprecated in favour of Actions.pointerUp */
+        touchUp(
+            xoffset: number,
+            yoffset: number,
+        ): Client<RawResult<null>> & RawResult<null> & never;
+
+         /** @deprecated in favour of Actions.pointerUp */
+        touchUp<P>(
+            xoffset: number,
+            yoffset: number,
+        ): Client<P>;
+
+        window(windowHandle?: string): Client<RawResult<null>> & RawResult<null>;
+        window<P>(windowHandle?: string): Client<P>;
+
+        windowHandle(): Client<RawResult<string>> & RawResult<string>;
+        windowHandle<P>(): Client<P>;
+
+        windowHandleFullscreen(): Client<RawResult<null>> & RawResult<null>;
+        windowHandleFullscreen<P>(): Client<P>;
+
+        windowHandleMaximize(): Client<RawResult<string>> & RawResult<string>;
+        windowHandleMaximize<P>(): Client<P>;
+
+         /** @deprecated in favour of /session/{session id}/window/rect */
+        windowHandlePosition(
+            windowHandle?: string,
+            position?: Position
+        ): Client<RawResult<Position>> & RawResult<Position> & never;
+
+         /** @deprecated in favour of /session/{session id}/window/rect */
+        windowHandlePosition(
+            position: Position
+        ): Client<RawResult<Position>> & RawResult<Position> & never;
+
+         /** @deprecated in favour of /session/{session id}/window/rect */
+        windowHandlePosition<P>(
+            windowHandle?: string,
+            position?: Position
+        ): Client<P>;
+
+         /** @deprecated in favour of /session/{session id}/window/rect */
+        windowHandlePosition<P>(
+            position: Position
+        ): Client<P>;
+
+         /** @deprecated in favour of /session/{session id}/window/rect */
+        windowHandleSize(
+            windowHandle?: string,
+            dimension?: Size
+        ): Client<RawResult<Size>> & RawResult<Size> & never;
+
+         /** @deprecated in favour of /session/{session id}/window/rect */
+        windowHandleSize(
+            dimension: Size
+        ): Client<RawResult<Size>> & RawResult<Size> & never;
+
+         /** @deprecated in favour of /session/{session id}/window/rect */
+        windowHandleSize<P>(
+            windowHandle?: string,
+            dimension?: Size
+        ): Client<P>;
+
+         /** @deprecated in favour of /session/{session id}/window/rect */
+        windowHandleSize<P>(
+            dimension?: Size
+        ): Client<P>;
+
+         /** @deprecated */
+        windowHandles(): Client<RawResult<string[]>> & RawResult<string[]> & never;
+
+         /** @deprecated */
+        windowHandles<P>(): Client<P> & never;
     }
 
     // State
     export interface Client<T> {
-        isEnabled(selector?: string): Client<boolean>;
+        hasFocus(selector?: string): Client<boolean> & boolean;
+        hasFocus<P>(selector?: string): Client<P>;
+
+        isEnabled(selector?: string): Client<boolean> & boolean;
         isEnabled<P>(selector?: string): Client<P>;
 
-        isExisting(selector?: string): Client<boolean>;
+        isExisting(selector?: string): Client<boolean> & boolean;
         isExisting<P>(selector?: string): Client<P>;
 
-        isSelected(selector?: string): Client<boolean>;
+        isSelected(selector?: string): Client<boolean> & boolean;
         isSelected<P>(selector?: string): Client<P>;
 
-        isVisible(selector?: string): Client<boolean>;
+        isVisible(selector?: string): Client<boolean> & boolean;
         isVisible<P>(selector?: string): Client<P>;
 
-        isVisibleWithinViewport(selector?: string): Client<boolean>;
+        isVisibleWithinViewport(selector?: string): Client<boolean> & boolean;
         isVisibleWithinViewport<P>(selector?: string): Client<P>;
     }
 
-    export interface CommandHistoryEntry {
-        command: string;
-        args: any[];
-    }
-
     // Utility
     export interface Client<T> {
+        $(selector: string): Client<RawResult<Element>> & RawResult<Element>;
+        $<P>(selector: string): Client<P>;
+
+        $$(selector: string): Client<RawResult<Element[]>> & RawResult<Element[]>;
+        $$<P>(selector: string): Client<P>;
+
         addCommand(
             commandName: string,
-            customMethod: Function,
+            customMethod: (...args: any[]) => void,
             overwrite?: boolean
-        ): Client<void>;
+        ): Client<void> & undefined;
+
         addCommand<P>(
             commandName: string,
-            customMethod: Function,
+            customMethod: (...args: any[]) => void,
             overwrite?: boolean
         ): Client<P>;
 
+        call<P>(callback: () => void): Client<P> & any;
+
         chooseFile(
             selector: string,
             localPath: string
-        ): Client<void>;
+        ): Client<void> & undefined;
+
         chooseFile(localPath: string): Client<void>;
+
         chooseFile<P>(
             selector: string,
             localPath: string
         ): Client<P>;
+
         chooseFile<P>(localPath: string): Client<P>;
 
         debug(): Client<void>;
@@ -773,199 +1587,242 @@ declare namespace WebdriverIO {
         endAll(): Client<void>;
         endAll<P>(): Client<P>;
 
-        getCommandHistory(): Client<CommandHistoryEntry[]>;
+        getCommandHistory(): Client<CommandHistoryEntry[]> & CommandHistoryEntry[];
         getCommandHistory<P>(): Client<P>;
 
         pause(milliseconds: number): Client<void>;
         pause<P>(milliseconds: number): Client<P>;
 
-        saveScreenshot(filename?: string): Client<Buffer>;
+        reload(): Client<string[]> & string[];
+        reload<P>(): Client<P>;
+
+        saveScreenshot(filename?: string): Client<Buffer> & Buffer;
         saveScreenshot<P>(filename?: string): Client<P>;
 
-        scroll(selector?: string): Client<void>;
+        scroll(selector?: string): Client<RawResult<null>> & RawResult<null>;
+
         scroll(
             selector: string,
             xoffset: number,
             yoffset: number
-        ): Client<void>;
+        ): Client<RawResult<null>> & RawResult<null>;
+
         scroll(
             xoffset: number,
             yoffset: number
-        ): Client<void>;
+        ): Client<RawResult<null>> & RawResult<null>;
+
         scroll<P>(selector?: string): Client<P>;
+
         scroll<P>(
             selector: string,
             xoffset: number,
             yoffset: number
         ): Client<P>;
+
         scroll<P>(
             xoffset: number,
             yoffset: number
         ): Client<P>;
 
-        uploadFile(localPath: string): Client<void>;
+        uploadFile(localPath: string): Client<RawResult<string>> & RawResult<string>;
         uploadFile<P>(localPath: string): Client<P>;
 
         waitForEnabled(
             selector: string,
             milliseconds?: number,
             reverse?: boolean
-        ): Client<boolean>;
+        ): Client<boolean> & boolean;
+
         waitForEnabled(
             milliseconds?: number,
             reverse?: boolean
-        ): Client<boolean>;
+        ): Client<boolean> & boolean;
+
         waitForEnabled<P>(selector?: string): Client<P>;
+
         waitForEnabled<P>(
             selector: string,
-            milliseconds: number,
+            milliseconds?: number,
         ): Client<P>;
-        waitForEnabled<P>(milliseconds: number): Client<P>;
+
+        waitForEnabled<P>(milliseconds?: number): Client<P>;
+
         waitForEnabled<P>(
             selector: string,
-            milliseconds: number,
-            reverse: boolean
+            milliseconds?: number,
+            reverse?: boolean
         ): Client<P>;
+
         waitForEnabled<P>(
-            milliseconds: number,
-            reverse: boolean
+            milliseconds?: number,
+            reverse?: boolean
         ): Client<P>;
 
         waitForExist(
             selector: string,
             milliseconds?: number,
             reverse?: boolean
-        ): Client<boolean>;
+        ): Client<boolean> & boolean;
+
         waitForExist(
             milliseconds?: number,
             reverse?: boolean
-        ): Client<boolean>;
+        ): Client<boolean> & boolean;
+
         waitForExist<P>(selector?: string): Client<P>;
+
         waitForExist<P>(
             selector: string,
-            milliseconds: number
+            milliseconds?: number
         ): Client<P>;
+
         waitForExist<P>(milliseconds: number): Client<P>;
+
         waitForExist<P>(
             selector: string,
-            milliseconds: number,
-            reverse: boolean
+            milliseconds?: number,
+            reverse?: boolean
         ): Client<P>;
+
         waitForExist<P>(
             milliseconds: number,
-            reverse: boolean
+            reverse?: boolean
         ): Client<P>;
 
         waitForSelected(
             selector: string,
             milliseconds?: number,
             reverse?: boolean
-        ): Client<boolean>;
+        ): Client<boolean> & boolean;
+
         waitForSelected(
             milliseconds?: number,
             reverse?: boolean
-        ): Client<boolean>;
+        ): Client<boolean> & boolean;
+
         waitForSelected<P>(selector?: string): Client<P>;
+
         waitForSelected<P>(
             selector: string,
-            milliseconds: number
+            milliseconds?: number
         ): Client<P>;
+
         waitForSelected<P>(milliseconds: number): Client<P>;
+
         waitForSelected<P>(
             selector: string,
-            milliseconds: number,
-            reverse: boolean
+            milliseconds?: number,
+            reverse?: boolean
         ): Client<P>;
+
         waitForSelected<P>(
-            milliseconds: number,
-            reverse: boolean
+            milliseconds?: number,
+            reverse?: boolean
         ): Client<P>;
 
         waitForText(
             selector: string,
             milliseconds?: number,
             reverse?: boolean
-        ): Client<boolean>;
+        ): Client<boolean> & boolean;
+
         waitForText(
             milliseconds?: number,
             reverse?: boolean
-        ): Client<boolean>;
+        ): Client<boolean> & boolean;
+
         waitForText<P>(selector?: string): Client<P>;
+
         waitForText<P>(
             selector: string,
-            milliseconds: number
+            milliseconds?: number
         ): Client<P>;
-        waitForText<P>(milliseconds: number): Client<P>;
+
+        waitForText<P>(milliseconds?: number): Client<P>;
+
         waitForText<P>(
             selector: string,
-            milliseconds: number,
-            reverse: boolean
+            milliseconds?: number,
+            reverse?: boolean
         ): Client<P>;
+
         waitForText<P>(
-            milliseconds: number,
-            reverse: boolean
+            milliseconds?: number,
+            reverse?: boolean
         ): Client<P>;
 
         waitForValue(
             selector: string,
             milliseconds?: number,
             reverse?: boolean
-        ): Client<boolean>;
+        ): Client<boolean> & boolean;
+
         waitForValue(
             milliseconds?: number,
             reverse?: boolean
-        ): Client<boolean>;
+        ): Client<boolean> & boolean;
+
         waitForValue<P>(selector?: string): Client<P>;
+
         waitForValue<P>(
             selector: string,
-            milliseconds: number
+            milliseconds?: number
         ): Client<P>;
-        waitForValue<P>(milliseconds: number): Client<P>;
+
+        waitForValue<P>(milliseconds?: number): Client<P>;
+
         waitForValue<P>(
             selector: string,
-            milliseconds: number,
-            reverse: boolean,
-
+            milliseconds?: number,
+            reverse?: boolean,
         ): Client<P>;
-        waitForValue<P>(
-            milliseconds: number,
-            reverse: boolean,
 
+        waitForValue<P>(
+            milliseconds?: number,
+            reverse?: boolean,
         ): Client<P>;
 
         waitForVisible(
             selector: string,
             milliseconds?: number,
             reverse?: boolean
-        ): Client<boolean>;
+        ): Client<boolean> & boolean;
+
         waitForVisible(
             milliseconds?: number,
             reverse?: boolean
-        ): Client<boolean>;
+        ): Client<boolean> & boolean;
+
         waitForVisible<P>(selector?: string): Client<P>;
+
         waitForVisible<P>(
             selector: string,
-            milliseconds: number
+            milliseconds?: number
         ): Client<P>;
-        waitForVisible<P>(milliseconds: number): Client<P>;
+
+        waitForVisible<P>(milliseconds?: number): Client<P>;
+
         waitForVisible<P>(
             selector: string,
-            milliseconds: number,
-            reverse: boolean
+            milliseconds?: number,
+            reverse?: boolean
         ): Client<P>;
+
         waitForVisible<P>(
-            milliseconds: number,
-            reverse: boolean
+            milliseconds?: number,
+            reverse?: boolean
         ): Client<P>;
 
         waitUntil(
-            condition: () => boolean | Q.IPromise<boolean>,
+            condition: () => boolean | Q.IPromise<boolean> | Client<RawResult<any>> & RawResult<any>,
             timeout?: number,
             timeoutMsg?: string,
             interval?: number
-        ): Client<boolean>;
+        ): Client<boolean> & any;
+
         waitUntil<P>(
-            condition: () => boolean | Q.IPromise<boolean>,
+            condition: () => boolean | Q.IPromise<boolean> | Client<RawResult<any>> & RawResult<any>,
             timeout?: number,
             timeoutMsg?: string,
             interval?: number
@@ -974,26 +1831,25 @@ declare namespace WebdriverIO {
 
     // Window
     export interface Client<T> {
-
-
-        close(windowHandle?: string): Client<void>;
+        close(windowHandle?: string): Client<RawResult<null>> & RawResult<null>;
         close<P>(windowHandle?: string): Client<P>;
 
-        getCurrentTabId(): Client<string>;
+        getCurrentTabId(): Client<string> & string;
         getCurrentTabId<P>(): Client<P>;
 
-        getTabIds(): Client<string[]>;
+        getTabIds(): Client<string[]> & string[];
         getTabIds<P>(): Client<P>;
 
         getViewportSize(): Client<Size> & Size;
-        getViewportSize(dimension: string): Client<number>;
+        getViewportSize(dimension: string): Client<number> & number;
         getViewportSize<P>(dimension?: string): Client<P>;
 
         newWindow(
             url: string,
             windowName: string,
             windowFeatures: string
-        ): Client<string>;
+        ): Client<RawResult<null>> & RawResult<null>;
+
         newWindow<P>(
             url: string,
             windowName: string,
@@ -1002,53 +1858,19 @@ declare namespace WebdriverIO {
 
         setViewportSize(
             size: Size,
-            type: boolean
-        ): Client<void>;
+            type?: boolean
+        ): Client<void> & undefined;
+
         setViewportSize<P>(
             size: Size,
-            type: boolean
+            type?: boolean
         ): Client<P>;
 
-        switchTab(windowHandle?: string): Client<void>;
+        switchTab(windowHandle?: string): Client<RawResult<null>> & RawResult<null>;
         switchTab<P>(windowHandle?: string): Client<P>;
     }
 
-    export type Axis = "x" | "y";
-
-    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>;
+    export var VERSION: string;
 }
 
 declare var browser: WebdriverIO.Client<void>;
@@ -1056,4 +1878,3 @@ declare var browser: WebdriverIO.Client<void>;
 declare module "webdriverio" {
     export = WebdriverIO;
 }
-
diff --git a/webdriverio/webdriverio-tests.ts b/webdriverio/webdriverio-tests.ts
index dc204b2052..826e2f1811 100644
--- a/webdriverio/webdriverio-tests.ts
+++ b/webdriverio/webdriverio-tests.ts
@@ -1,6 +1,5 @@
 
 /// <reference types="mocha" />
-/// <reference types="chai" />
 
 import {assert} from "chai";
 
@@ -34,12 +33,12 @@ 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);
+    before(function() {
+        client = webdriverio.remote({ desiredCapabilities: { browserName: "phantomjs" } });
+        client.init();
     });
 
-    it("Github test",function() {
+    it("Github test", function() {
         client.url("https://github.com/");
 
         var elementSize = client.getElementSize(".header-logo-wordmark");
@@ -111,7 +110,7 @@ webdriverio
     .selectorExecute("//div", function(inputs: HTMLElement[], message: string) {
         return inputs.length + " " + message;
     }, "divs on the page")
-    .then(function(res){
+    .then(function(res: string) {
         console.log(res);
     })
     .end();