From 77298da2afae4624489273a3fd9dd95fd04bfd1f Mon Sep 17 00:00:00 2001
From: Fredrik Smedberg <fredrik.smedberg@thomascook.se>
Date: Fri, 9 Dec 2016 16:36:23 +0100
Subject: [PATCH] Makes the type definitions compatible with WebdriverIO 4.4.0.
 Merged my changes (removed all callbacks) with WillLuce pull request #12416.

---
 webdriverio/index.d.ts | 467 ++++++++++++++++++++++++-----------------
 1 file changed, 277 insertions(+), 190 deletions(-)

diff --git a/webdriverio/index.d.ts b/webdriverio/index.d.ts
index 44a0e6ea57..5734bc3990 100644
--- a/webdriverio/index.d.ts
+++ b/webdriverio/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for webdriverio 4.0.4
+// Type definitions for webdriverio 4.4.0
 // Project: http://www.webdriver.io/
 // Definitions by: Nick Malaguti <https://github.com/nmalaguti/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -30,96 +30,116 @@ declare namespace WebdriverIO {
 
     // Action
     export interface Client<T> {
-        addValue(selector: string, value: string | number): Client<void>;
+        addValue(
+            selector: string,
+            value: string | number
+        ): Client<void>;
+        addValue(value: string | number): Client<void>;
         addValue<P>(
             selector: string,
             value: string | number,
-            callback: (err: any) => P
         ): Client<P>;
+        addValue<P>(value: string | number): Client<P>;
 
         clearElement(selector: string): Client<void>;
-        clearElement<P>(
-            selector: string,
-            callback: (err: any) => P
-        ): Client<P>;
+        clearElement(): Client<void>;
+        clearElement<P>(selector: string): Client<P>;
+        clearElement<P>(): Client<P>;
 
         click(selector: string): Client<void>;
-        click<P>(
-            selector: string,
-            callback: (err: any) => P
-        ): Client<P>;
+        click(): Client<void>;
+        click<P>(selector: string): Client<P>;
+        click<P>(): Client<P>;
 
         doubleClick(selector: string): Client<void>;
-        doubleClick<P>(
-            selector: string,
-            callback: (err: any) => P
-        ): Client<P>;
+        doubleClick(): Client<void>;
+        doubleClick<P>(selector: string): Client<P>;
+        doubleClick<P>(): Client<P>;
 
-        dragAndDrop(sourceElem: string, destinationElem: string): Client<void>;
+        dragAndDrop(
+            sourceElem: string,
+            destinationElem: string
+        ): Client<void>;
+        dragAndDrop(destinationElem: string): Client<void>;
         dragAndDrop<P>(
             sourceElem: string,
-            destinationElem: string, callback: (err: any) => P
+            destinationElem: string
         ): Client<P>;
+        dragAndDrop<P>(destinationElem: string): Client<P>;
 
         leftClick(selector: string): Client<void>;
-        leftClick<P>(
-            selector: string,
-            callback: (err: any) => P
-        ): Client<P>;
+        leftClick(): Client<void>;
+        leftClick<P>(selector: string): Client<P>;
+        leftClick<P>(): Client<P>;
 
         middleClick(selector: string): Client<void>;
-        middleClick<P>(
-            selector: string,
-            callback: (err: any) => P
-        ): Client<P>;
+        middleClick(): Client<void>;
+        middleClick<P>(selector: string): Client<P>;
+        middleClick<P>(): Client<P>;
 
         moveToObject(selector: string): Client<void>;
-        moveToObject(selector: string, xoffset: number, yoffset: number): Client<void>;
-        moveToObject<P>(
+        moveToObject(): Client<void>;
+        moveToObject(
             selector: string,
-            callback: (err: any) => P
-        ): Client<P>;
+            xoffset: number,
+            yoffset: number
+        ): Client<void>;
+        moveToObject(
+            xoffset: number,
+            yoffset: number
+        ): Client<void>;
+        moveToObject<P>(selector: string): Client<P>;
+        moveToObject<P>(): Client<P>;
         moveToObject<P>(
             selector: string,
             xoffset: number,
-            yoffset: number,
-            callback: (err: any) => P
+            yoffset: number
+        ): Client<P>;
+        moveToObject<P>(
+            xoffset: number,
+            yoffset: number
         ): Client<P>;
 
         rightClick(selector: string): Client<void>;
-        rightClick<P>(
-            selector: string,
-            callback: (err: any) => P
-        ): Client<P>;
+        rightClick(): Client<void>;
+        rightClick<P>(selector: string): Client<P>;
+        rightClick<P>(): Client<P>;
 
         selectByAttribute(selector: string, attribute: string, value: string): Client<void>;
+        selectByAttribute(attribute: string, value: string): Client<void>;
         selectByAttribute<P>(
             selector: string,
             attribute: string,
-            value: string,
-            callback: (err: any) => P
+            value: string
+        ): Client<P>;
+        selectByAttribute<P>(
+            attribute: string,
+            value: string
         ): Client<P>;
 
         selectByIndex(selectElem: string, index: number): Client<void>;
+        selectByIndex(index: number): Client<void>;
         selectByIndex<P>(
             selectElem: string,
-            index: number,
-            callback: (err: any) => P
+            index: number
         ): Client<P>;
+        selectByIndex<P>(index: number): Client<P>;
 
         selectByValue(selectElem: string, value: string): Client<void>;
+        selectByValue(value: string): Client<void>;
         selectByValue<P>(
             selectElem: string,
-            value: string,
-            callback: (err: any) => P
+            value: string
         ): Client<P>;
+        selectByValue<P>(value: string): Client<P>;
 
         selectByVisibleText(selectElem: string, text: string): Client<void>;
+        selectByVisibleText(text: string): Client<void>;
         selectByVisibleText<P>(
             selectElem: string,
-            text: string,
-            callback: (err: any) => P
+            text: string
         ): Client<P>;
+        selectByVisibleText<P>(text: string): Client<P>;
 
         selectorExecute<P>(
             selectors: string | string[],
@@ -134,17 +154,17 @@ declare namespace WebdriverIO {
         ): Client<P>;
 
         setValue(selector: string, values: number | string | Array<string>): Client<void>;
+        setValue(values: number | string | Array<string>): Client<void>;
         setValue<P>(
             selector: string,
-            values: number | string | Array<string>,
-            callback: (err: any) => P
+            values: number | string | Array<string>
         ): Client<void>;
+        setValue<P>(values: number | string | Array<string>): Client<void>;
 
         submitForm(selector: string): Client<void>;
-        submitForm<P>(
-            selector: string,
-            callback: (err: any) => P
-        ): Client<void>;
+        submitForm(): Client<void>;
+        submitForm<P>(selector: string): Client<void>;
+        submitForm<P>(): Client<void>;
     }
 
     // Appium
@@ -187,13 +207,8 @@ declare namespace WebdriverIO {
     // 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>;
+        deleteCookie<P>(): Client<P>;
+        deleteCookie<P>(name: string): Client<P>;
 
         getCookie(): Client<Cookie[]>;
         getCookie(name: string): Client<Cookie>;
@@ -206,10 +221,7 @@ declare namespace WebdriverIO {
         ): Client<P>;
 
         setCookie(cookie: Cookie): Client<void>;
-        setCookie<P>(
-            cookie: Cookie,
-            callback: (err: any) => P
-        ): Client<P>;
+        setCookie<P>(cookie: Cookie): Client<P>;
     }
 
     export interface Client<T> {
@@ -277,80 +289,133 @@ declare namespace WebdriverIO {
     // Property
     export interface Client<T> {
         getAttribute(selector: string, attributeName: string): Client<string | string[]>;
+        getAttribute(attributeName: string): Client<string | string[]>;
         getAttribute<P>(
             selector: string,
             attributeName: string,
             callback: (err: any, attribute: string | string[]) => P
         ): Client<P>;
+        getAttribute<P>(
+            attributeName: string,
+            callback: (err: any, attribute: string | string[]) => P
+        ): Client<P>;
 
         getCssProperty(selector: string, cssProperty: string): Client<CssProperty | CssProperty[]>;
+        getCssProperty(cssProperty: string): Client<CssProperty | CssProperty[]>;
         getCssProperty<P>(
             selector: string,
             cssProperty: string,
             callback: (err: any, cssProperty: CssProperty | CssProperty[]) => P
         ): Client<P>;
+        getCssProperty<P>(
+            cssProperty: string,
+            callback: (err: any, cssProperty: CssProperty | CssProperty[]) => P
+        ): Client<P>;
 
         getElementSize(selector: string): Client<Size | Size[]>;
+        getElementSize(): Client<Size | Size[]>;
         getElementSize(selector: string, dimension: string): Client<number | number[]>;
+        getElementSize(dimension: string): Client<number | number[]>;
         getElementSize<P>(
             selector: string,
             callback: (err: any, size: Size | Size[]) => P
         ): Client<P>;
+        getElementSize<P>(
+            callback: (err: any, size: Size | Size[]) => P
+        ): Client<P>;
         getElementSize<P>(
             selector: string,
             dimension: string,
             callback: (err: any, elementSize: number | number[]) => P
         ): Client<P>;
+        getElementSize<P>(
+            dimension: string,
+            callback: (err: any, elementSize: number | number[]) => P
+        ): Client<P>;
 
         getHTML(selector: string, includeSelectorTag?: boolean): Client<string | string[]>;
+        getHTML(includeSelectorTag?: boolean): Client<string | string[]>;
         getHTML<P>(
             selector: string,
             callback: (err: any, html: string | string[]) => P
         ): Client<P>;
+        getHTML<P>(
+            callback: (err: any, html: string | string[]) => P
+        ): Client<P>;
         getHTML<P>(
             selector: string,
             includeSelectorTag: boolean,
             callback: (err: any, html: string | string[]) => P
         ): Client<P>;
+        getHTML<P>(
+            includeSelectorTag: boolean,
+            callback: (err: any, html: string | string[]) => P
+        ): Client<P>;
 
-        getLocation(selector: string): Client<Location>;
+        getLocation(selector: string): Client<Size>;
+        getLocation(): Client<Size>;
         getLocation(selector: string, axis: string): Client<number>;
+        getLocation(axis: string): Client<number>;
         getLocation<P>(
             selector: string,
-            callback: (err: any, location: Location) => P
+            callback: (err: any, size: Size) => P
+        ): Client<P>;
+        getLocation<P>(
+            callback: (err: any, size: Size) => P
         ): Client<P>;
         getLocation<P>(
             selector: string,
             axis: string,
             callback: (err: any, location: number) => P
         ): Client<P>;
+        getLocation<P>(
+            axis: string,
+            callback: (err: any, location: number) => P
+        ): Client<P>;
 
-        getLocationInView(selector: string): Client<Location | Location[]>;
+        getLocationInView(selector: string): Client<Size | Size[]>;
+        getLocationInView(): Client<Size | Size[]>;
         getLocationInView(selector: string, axis: string): Client<number | number[]>;
+        getLocationInView(axis: string): Client<number | number[]>;
         getLocationInView<P>(
             selector: string,
-            callback: (err: any, location: Location | Location[]) => P
+            callback: (err: any, size: Size | Size[]) => P
+        ): Client<P>;
+        getLocationInView<P>(
+            callback: (err: any, size: Size | Size[]) => P
         ): Client<P>;
         getLocationInView<P>(
             selector: string,
             axis: string,
             callback: (err: any, location: number | number[]) => P
         ): Client<P>;
+        getLocationInView<P>(
+            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(): Client<string | string[]>;
         getTagName<P>(
             selector: string,
             callback: (err: any, tagName: string | string[]) => P
         ): Client<P>;
+        getTagName<P>(
+            callback: (err: any, tagName: string | string[]) => P
+        ): Client<P>;
 
         getText(selector: string): Client<string | string[]>;
+        getText(): Client<string | string[]>;
         getText<P>(
             selector: string,
             callback: (err: any, text: string | string[]) => P
         ): Client<P>;
+        getText<P>(
+            callback: (err: any, text: string | string[]) => P
+        ): Client<P>;
 
         getTitle(): Client<string>;
         getTitle<P>(
@@ -363,10 +428,14 @@ declare namespace WebdriverIO {
         ): Client<P>;
 
         getValue(selector: string): Client<string | string[]>;
+        getValue(): Client<string | string[]>;
         getValue<P>(
             selector: string,
             callback: (err: any, value: string | string[]) => P
         ): Client<P>;
+        getValue<P>(
+            callback: (err: any, value: string | string[]) => P
+        ): Client<P>;
     }
 
     export interface LogEntry {
@@ -395,7 +464,7 @@ declare namespace WebdriverIO {
         value: any;
     }
 
-    export interface GeoLocation {
+    export interface Location {
         latitude: number;
         longitude: number;
         altitude: number;
@@ -413,94 +482,60 @@ declare namespace WebdriverIO {
     // Navigation
     export interface Client<T> {
         back(): Client<void>;
-        back<P>(
-            callback: (err: any) => P
-        ): Client<P>;
+        back<P>(): Client<P>;
 
         forward(): Client<void>;
-        forward<P>(
-            callback: (err: any) => P
-        ): Client<P>;
+        forward<P>(): Client<P>;
 
         refresh(): Client<void>;
-        refresh<P>(
-            callback: (err: any) => P
-        ): Client<P>;
+        refresh<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>;
+        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>(
-            callback: (err: any) => P
-        ): Client<P>;
-        buttonDown<P>(
-            button: string | Button,
-            callback: (err: any) => P
-        ): Client<P>;
+        buttonDown<P>(): Client<P>;
+        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>(
-            callback: (err: any) => P
-        ): Client<P>;
-        buttonPress<P>(
-            button: string | Button,
-            callback: (err: any) => P
-        ): Client<P>;
+        buttonPress<P>(): Client<P>;
+        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>(
-            callback: (err: any) => P
-        ): Client<P>;
+        buttonUp<P>(): Client<P>;
         buttonUp(button?: string | Button): Client<void>;
-        buttonUp<P>(
-            button: string | Button,
-            callback: (err: any) => P
-        ): Client<P>;
+        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>(
-            callback: (err: any) => P
-        ): Client<P>;
+        doDoubleClick<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>;
+        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,
-            callback: (err: any) => P
+            xoffset: number
         ): 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
+            yoffset: number
         ): Client<P>;
 
         // touchClick
@@ -516,14 +551,10 @@ declare namespace WebdriverIO {
     // Useful Protocol
     export interface Client<T> {
         alertAccept(): Client<void>;
-        alertAccept<P>(
-            callback: (err: any) => P
-        ): Client<P>;
+        alertAccept<P>(): Client<P>;
 
         alertDismiss(): Client<void>;
-        alertDismiss<P>(
-            callback: (err: any) => P
-        ): Client<P>;
+        alertDismiss<P>(): Client<P>;
 
         alertText(text?: string): Client<string>;
         alertText<P>(
@@ -535,24 +566,14 @@ declare namespace WebdriverIO {
         ): Client<P>;
 
         frame(id: any): Client<void>;
-        frame<P>(
-            id: any,
-            callback: (err: any) => P
-        ): Client<P>;
+        frame<P>(id: any): Client<P>;
 
         frameParent(): Client<void>;
-        frameParent<P>(
-            callback: (err: any) => P
-        ): Client<P>;
+        frameParent<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>;
+        init<P>(): Client<P>;
+        init<P>(capabilities: DesiredCapabilities): Client<P>;
 
         log(type: string): Client<RawResult<LogEntry[]>>;
         log<P>(
@@ -623,16 +644,10 @@ declare namespace WebdriverIO {
         ): Client<P>;
 
         elementIdClear(id: ElementId): Client<void>;
-        elementIdClear<P>(
-            id: ElementId,
-            callback: (err: any) => P
-        ): Client<P>;
+        elementIdClear<P>(id: ElementId): Client<P>;
 
         elementIdClick(id: ElementId): Client<void>;
-        elementIdClick<P>(
-            id: ElementId,
-            callback: (err: any) => P
-        ): Client<P>;
+        elementIdClick<P>(id: ElementId): Client<P>;
 
         elementIdCssProperty(id: ElementId, propertyName: string): Client<RawResult<string>>;
         elementIdCssProperty<P>(
@@ -746,10 +761,7 @@ declare namespace WebdriverIO {
 
         // use submitForm instead
         submit(id: ElementId): Client<void>;
-        submit<P>(
-            id: ElementId,
-            callback: (err: any) => P
-        ): Client<P>;
+        submit<P>(id: ElementId): Client<P>;
 
         // title
     }
@@ -757,34 +769,54 @@ declare namespace WebdriverIO {
     // State
     export interface Client<T> {
         isEnabled(selector: string): Client<boolean>;
+        isEnabled(): Client<boolean>;
         isEnabled<P>(
             selector: string,
             callback: (err: any, isEnabled: boolean) => P
         ): Client<P>;
+        isEnabled<P>(
+            callback: (err: any, isEnabled: boolean) => P
+        ): Client<P>;
 
         isExisting(selector: string): Client<boolean>;
+        isExisting(): Client<boolean>;
         isExisting<P>(
             selector: string,
             callback: (err: any, isExisting: boolean) => P
         ): Client<P>;
+        isExisting<P>(
+            callback: (err: any, isExisting: boolean) => P
+        ): Client<P>;
 
         isSelected(selector: string): Client<boolean>;
+        isSelected(): Client<boolean>;
         isSelected<P>(
             selector: string,
             callback: (err: any, isSelected: boolean) => P
         ): Client<P>;
+        isSelected<P>(
+            callback: (err: any, isSelected: boolean) => P
+        ): Client<P>;
 
         isVisible(selector: string): Client<boolean>;
+        isVisible(): Client<boolean>;
         isVisible<P>(
             selector: string,
             callback: (err: any, isVisible: boolean) => P
         ): Client<P>;
+        isVisible<P>(
+            callback: (err: any, isVisible: boolean) => P
+        ): Client<P>;
 
         isVisibleWithinViewport(selector: string): Client<boolean>;
+        isVisibleWithinViewport(): Client<boolean>;
         isVisibleWithinViewport<P>(
             selector: string,
             callback: (err: any, isVisible: boolean) => P
         ): Client<P>;
+        isVisibleWithinViewport<P>(
+            callback: (err: any, isVisible: boolean) => P
+        ): Client<P>;
     }
 
     export interface CommandHistoryEntry {
@@ -797,37 +829,30 @@ declare namespace WebdriverIO {
         addCommand(commandName: string, customMethod: Function, overwrite?: boolean): Client<void>;
         addCommand<P>(
             commandName: string,
-            customMethod: Function,
-            callback: (err: any) => P
+            customMethod: Function
         ): Client<P>;
         addCommand<P>(
             commandName: string,
             customMethod: Function,
-            overwrite: boolean,
-            callback: (err: any) => P
+            overwrite: boolean
         ): Client<P>;
 
         chooseFile(selector: string, localPath: string): Client<void>;
+        chooseFile(localPath: string): Client<void>;
         chooseFile<P>(
             selector: string,
-            localPath: string,
-            callback: (err: any) => P
+            localPath: string
         ): Client<P>;
+        chooseFile<P>(localPath: string): Client<P>;
 
         debug(): Client<void>;
-        debug<P>(
-            callback: (err: any) => P
-        ): Client<P>;
+        debug<P>(): Client<P>;
 
         end(): Client<void>;
-        end<P>(
-            callback: (err: any) => P
-        ): Client<P>;
+        end<P>(): Client<P>;
 
         endAll(): Client<void>;
-        endAll<P>(
-            callback: (err: any) => P
-        ): Client<P>;
+        endAll<P>(): Client<P>;
 
         getCommandHistory(): Client<CommandHistoryEntry[]>;
         getCommandHistory<P>(
@@ -835,7 +860,7 @@ declare namespace WebdriverIO {
         ): Client<P>;
 
         pause(milliseconds: number): Client<void>;
-        pause<P>(milliseconds: number, callback: (err: any) => P): Client<P>;
+        pause<P>(milliseconds: number): Client<P>;
 
         saveScreenshot(filename?: string): Client<Buffer>;
         saveScreenshot<P>(
@@ -847,131 +872,203 @@ declare namespace WebdriverIO {
         ): Client<P>;
 
         scroll(selector: string): Client<void>;
+        scroll(): 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): Client<P>;
+        scroll<P>(): Client<P>;
         scroll<P>(
             selector: string,
             xoffset: number,
-            yoffset: number,
-            callback: (err: any) => P
+            yoffset: number
         ): Client<P>;
         scroll<P>(
             xoffset: number,
-            yoffset: number,
-            callback: (err: any) => P
+            yoffset: number
         ): Client<P>;
 
         uploadFile(localPath: string): Client<void>;
-        uploadFile<P>(
-            localPath: string,
-            callback: (err: any) => P
-        ): Client<P>;
+        uploadFile<P>(localPath: string): Client<P>;
 
         waitForEnabled(selector: string, milliseconds?: number, reverse?: boolean): Client<boolean>;
+        waitForEnabled(milliseconds?: number, reverse?: boolean): Client<boolean>;
         waitForEnabled<P>(
             selector: string,
             callback: (err: any, enabled: boolean) => P
         ): Client<P>;
+        waitForEnabled<P>(
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
         waitForEnabled<P>(
             selector: string,
             milliseconds: number,
             callback: (err: any, enabled: boolean) => P
         ): Client<P>;
+        waitForEnabled<P>(
+            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>;
+        waitForEnabled<P>(
+            milliseconds: number,
+            reverse: boolean,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
 
         waitForExist(selector: string, milliseconds?: number, reverse?: boolean): Client<boolean>;
+        waitForExist(milliseconds?: number, reverse?: boolean): Client<boolean>;
         waitForExist<P>(
             selector: string,
             callback: (err: any, enabled: boolean) => P
         ): Client<P>;
+        waitForExist<P>(
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
         waitForExist<P>(
             selector: string,
             milliseconds: number,
             callback: (err: any, enabled: boolean) => P
         ): Client<P>;
+        waitForExist<P>(
+            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>;
+        waitForExist<P>(
+            milliseconds: number,
+            reverse: boolean,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
 
         waitForSelected(selector: string, milliseconds?: number, reverse?: boolean): Client<boolean>;
+        waitForSelected(milliseconds?: number, reverse?: boolean): Client<boolean>;
         waitForSelected<P>(
             selector: string,
             callback: (err: any, enabled: boolean) => P
         ): Client<P>;
+        waitForSelected<P>(
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
         waitForSelected<P>(
             selector: string,
             milliseconds: number,
             callback: (err: any, enabled: boolean) => P
         ): Client<P>;
+        waitForSelected<P>(
+            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>;
+        waitForSelected<P>(
+            milliseconds: number,
+            reverse: boolean,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
 
         waitForText(selector: string, milliseconds?: number, reverse?: boolean): Client<boolean>;
+        waitForText(milliseconds?: number, reverse?: boolean): Client<boolean>;
         waitForText<P>(
             selector: string,
             callback: (err: any, enabled: boolean) => P
         ): Client<P>;
+        waitForText<P>(
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
         waitForText<P>(
             selector: string,
             milliseconds: number,
             callback: (err: any, enabled: boolean) => P
         ): Client<P>;
+        waitForText<P>(
+            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>;
+        waitForText<P>(
+            milliseconds: number,
+            reverse: boolean,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
 
         waitForValue(selector: string, milliseconds?: number, reverse?: boolean): Client<boolean>;
+        waitForValue(milliseconds?: number, reverse?: boolean): Client<boolean>;
         waitForValue<P>(
             selector: string,
             callback: (err: any, enabled: boolean) => P
         ): Client<P>;
+        waitForValue<P>(
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
         waitForValue<P>(
             selector: string,
             milliseconds: number,
             callback: (err: any, enabled: boolean) => P
         ): Client<P>;
+        waitForValue<P>(
+            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>;
+        waitForValue<P>(
+            milliseconds: number,
+            reverse: boolean,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
 
         waitForVisible(selector: string, milliseconds?: number, reverse?: boolean): Client<boolean>;
+        waitForVisible(milliseconds?: number, reverse?: boolean): Client<boolean>;
         waitForVisible<P>(
             selector: string,
             callback: (err: any, enabled: boolean) => P
         ): Client<P>;
+        waitForVisible<P>(
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
         waitForVisible<P>(
             selector: string,
             milliseconds: number,
             callback: (err: any, enabled: boolean) => P
         ): Client<P>;
+        waitForVisible<P>(
+            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>;
+        waitForVisible<P>(
+            milliseconds: number,
+            reverse: boolean,
+            callback: (err: any, enabled: boolean) => P
+        ): Client<P>;
 
         waitUntil(
             condition: () => boolean | Q.IPromise<boolean>,
@@ -991,13 +1088,8 @@ declare namespace WebdriverIO {
     // 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>;
+        close<P>(): Client<P>;
+        close<P>(windowHandle: string): Client<P>;
 
         getCurrentTabId(): Client<string>;
         getCurrentTabId<P>(
@@ -1030,18 +1122,12 @@ declare namespace WebdriverIO {
         setViewportSize(size: Size, type: boolean): Client<void>;
         setViewportSize<P>(
             size: Size,
-            type: boolean,
-            callback: (err: any) => P
+            type: boolean
         ): 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>;
+        switchTab<P>(): Client<P>;
+        switchTab<P>(windowHandle: string): Client<P>;
     }
 
     export interface Options {
@@ -1085,3 +1171,4 @@ declare var browser: WebdriverIO.Client<void>;
 declare module "webdriverio" {
     export = WebdriverIO;
 }
+