droidline 0.1.9 → 0.1.11

package/dist/generated.d.ts

@@ -104,6 +104,13 @@ export interface DeviceInfo {
     leased?: any;
     [field: string]: any;
 }
+export interface ImageMatch {
+    x?: any;
+    y?: any;
+    bounds?: any;
+    score?: any;
+    [field: string]: any;
+}
 export interface Notification {
     key?: any;
     package?: any;
@@ -163,6 +170,12 @@ export interface FindImageOptions {
     threshold?: number;
     /** Seconds to wait for the target to appear. @default 10 */
     timeout?: number;
+    /** Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match. */
+    region?: ReadonlyArray<number>;
+    /** Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time. */
+    scales?: ReadonlyArray<number>;
+    /** Also require the average color to agree, so a red and a green button of the same shape differ. @default false */
+    color?: boolean;
 }
 export interface FindImageResult {
     x: number;
@@ -175,6 +188,12 @@ export interface TapImageOptions {
     threshold?: number;
     /** Seconds to wait for the target to appear. @default 10 */
     timeout?: number;
+    /** Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match. */
+    region?: ReadonlyArray<number>;
+    /** Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time. */
+    scales?: ReadonlyArray<number>;
+    /** Also require the average color to agree, so a red and a green button of the same shape differ. @default false */
+    color?: boolean;
 }
 export interface TapImageResult {
     x: number;
@@ -182,6 +201,45 @@ export interface TapImageResult {
     score: number;
     ms: number;
 }
+export interface ImageExistsOptions {
+    /** How close the match must be, from 0 to 1. @default 0.9 */
+    threshold?: number;
+    /** Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match. */
+    region?: ReadonlyArray<number>;
+    /** Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time. */
+    scales?: ReadonlyArray<number>;
+    /** Also require the average color to agree, so a red and a green button of the same shape differ. @default false */
+    color?: boolean;
+}
+export interface FindImagesOptions {
+    /** How close the match must be, from 0 to 1. @default 0.9 */
+    threshold?: number;
+    /** Seconds to wait for at least one match. 0 answers at once. @default 0 */
+    timeout?: number;
+    /** Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match. */
+    region?: ReadonlyArray<number>;
+    /** Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time. */
+    scales?: ReadonlyArray<number>;
+    /** Also require the average color to agree, so a red and a green button of the same shape differ. @default false */
+    color?: boolean;
+    /** Most matches to return. @default 20 */
+    max?: number;
+}
+export interface WaitImageGoneOptions {
+    /** How close the match must be, from 0 to 1. @default 0.9 */
+    threshold?: number;
+    /** Seconds to wait for the target to appear. @default 10 */
+    timeout?: number;
+    /** Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match. */
+    region?: ReadonlyArray<number>;
+    /** Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time. */
+    scales?: ReadonlyArray<number>;
+    /** Also require the average color to agree, so a red and a green button of the same shape differ. @default false */
+    color?: boolean;
+}
+export interface WaitImageGoneResult {
+    ms: number;
+}
 export interface OcrOptions {
     /** Tesseract languages, such as kor+eng. Each needs its language data installed. @default "eng" */
     lang?: string;
@@ -594,11 +652,14 @@ export declare abstract class DeviceCommands {
     /**
      * Find a picture on the screen.
      *
-     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone, because another screen size or density will not match. On Android 9 and 10 screenshots need screen capture permission.
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
      *
      * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
      * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
      * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
      * @param opts Optional parameters by name, see FindImageOptions.
      * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
      * @example await d.find_image("ok-button.png")
@@ -607,11 +668,14 @@ export declare abstract class DeviceCommands {
     /**
      * Find a picture on the screen.
      *
-     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone, because another screen size or density will not match. On Android 9 and 10 screenshots need screen capture permission.
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
      *
      * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
      * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
      * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
      * @param opts Optional parameters by name, see FindImageOptions.
      * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
      * @example await d.find_image("ok-button.png")
@@ -620,11 +684,14 @@ export declare abstract class DeviceCommands {
     /**
      * Find a picture on the screen.
      *
-     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone, because another screen size or density will not match. On Android 9 and 10 screenshots need screen capture permission.
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
      *
      * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
      * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
      * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
      * @param opts Optional parameters by name, see FindImageOptions.
      * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
      * @example await d.find_image("ok-button.png")
@@ -633,11 +700,62 @@ export declare abstract class DeviceCommands {
     /**
      * Find a picture on the screen.
      *
-     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone, because another screen size or density will not match. On Android 9 and 10 screenshots need screen capture permission.
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see FindImageOptions.
+     * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
+     * @example await d.find_image("ok-button.png")
+     */
+    find_image(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, opts?: FindImageOptions): Promise<FindImageResult>;
+    /**
+     * Find a picture on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see FindImageOptions.
+     * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
+     * @example await d.find_image("ok-button.png")
+     */
+    find_image(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, opts?: FindImageOptions): Promise<FindImageResult>;
+    /**
+     * Find a picture on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see FindImageOptions.
+     * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
+     * @example await d.find_image("ok-button.png")
+     */
+    find_image(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, color?: boolean, opts?: FindImageOptions): Promise<FindImageResult>;
+    /**
+     * Find a picture on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
      *
      * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
      * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
      * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
      * @param opts Optional parameters by name, see FindImageOptions.
      * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
      * @example await d.find_image("ok-button.png")
@@ -647,11 +765,14 @@ export declare abstract class DeviceCommands {
     /**
      * Find a picture on the screen.
      *
-     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone, because another screen size or density will not match. On Android 9 and 10 screenshots need screen capture permission.
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
      *
      * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
      * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
      * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
      * @param opts Optional parameters by name, see FindImageOptions.
      * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
      * @example await d.find_image("ok-button.png")
@@ -661,25 +782,82 @@ export declare abstract class DeviceCommands {
     /**
      * Find a picture on the screen.
      *
-     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone, because another screen size or density will not match. On Android 9 and 10 screenshots need screen capture permission.
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
      *
      * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
      * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
      * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
      * @param opts Optional parameters by name, see FindImageOptions.
      * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
      * @example await d.find_image("ok-button.png")
      * @alias find_image
      */
     findImage(image: string | Uint8Array, threshold?: number, timeout?: number, opts?: FindImageOptions): Promise<FindImageResult>;
+    /**
+     * Find a picture on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see FindImageOptions.
+     * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
+     * @example await d.find_image("ok-button.png")
+     * @alias find_image
+     */
+    findImage(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, opts?: FindImageOptions): Promise<FindImageResult>;
+    /**
+     * Find a picture on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see FindImageOptions.
+     * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
+     * @example await d.find_image("ok-button.png")
+     * @alias find_image
+     */
+    findImage(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, opts?: FindImageOptions): Promise<FindImageResult>;
+    /**
+     * Find a picture on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see FindImageOptions.
+     * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
+     * @example await d.find_image("ok-button.png")
+     * @alias find_image
+     */
+    findImage(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, color?: boolean, opts?: FindImageOptions): Promise<FindImageResult>;
     /**
      * Find a picture on the screen and tap its center.
      *
-     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone, because another screen size or density will not match. On Android 9 and 10 screenshots need screen capture permission.
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
      *
      * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
      * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
      * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
      * @param opts Optional parameters by name, see TapImageOptions.
      * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
      * @example await d.tap_image("ok-button.png")
@@ -688,11 +866,14 @@ export declare abstract class DeviceCommands {
     /**
      * Find a picture on the screen and tap its center.
      *
-     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone, because another screen size or density will not match. On Android 9 and 10 screenshots need screen capture permission.
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
      *
      * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
      * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
      * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
      * @param opts Optional parameters by name, see TapImageOptions.
      * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
      * @example await d.tap_image("ok-button.png")
@@ -701,11 +882,14 @@ export declare abstract class DeviceCommands {
     /**
      * Find a picture on the screen and tap its center.
      *
-     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone, because another screen size or density will not match. On Android 9 and 10 screenshots need screen capture permission.
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
      *
      * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
      * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
      * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
      * @param opts Optional parameters by name, see TapImageOptions.
      * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
      * @example await d.tap_image("ok-button.png")
@@ -714,11 +898,62 @@ export declare abstract class DeviceCommands {
     /**
      * Find a picture on the screen and tap its center.
      *
-     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone, because another screen size or density will not match. On Android 9 and 10 screenshots need screen capture permission.
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
      *
      * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
      * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
      * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see TapImageOptions.
+     * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
+     * @example await d.tap_image("ok-button.png")
+     */
+    tap_image(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, opts?: TapImageOptions): Promise<TapImageResult>;
+    /**
+     * Find a picture on the screen and tap its center.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see TapImageOptions.
+     * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
+     * @example await d.tap_image("ok-button.png")
+     */
+    tap_image(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, opts?: TapImageOptions): Promise<TapImageResult>;
+    /**
+     * Find a picture on the screen and tap its center.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see TapImageOptions.
+     * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
+     * @example await d.tap_image("ok-button.png")
+     */
+    tap_image(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, color?: boolean, opts?: TapImageOptions): Promise<TapImageResult>;
+    /**
+     * Find a picture on the screen and tap its center.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
      * @param opts Optional parameters by name, see TapImageOptions.
      * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
      * @example await d.tap_image("ok-button.png")
@@ -728,11 +963,14 @@ export declare abstract class DeviceCommands {
     /**
      * Find a picture on the screen and tap its center.
      *
-     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone, because another screen size or density will not match. On Android 9 and 10 screenshots need screen capture permission.
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
      *
      * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
      * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
      * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
      * @param opts Optional parameters by name, see TapImageOptions.
      * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
      * @example await d.tap_image("ok-button.png")
@@ -742,17 +980,669 @@ export declare abstract class DeviceCommands {
     /**
      * Find a picture on the screen and tap its center.
      *
-     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone, because another screen size or density will not match. On Android 9 and 10 screenshots need screen capture permission.
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
      *
      * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
      * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
      * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
      * @param opts Optional parameters by name, see TapImageOptions.
      * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
      * @example await d.tap_image("ok-button.png")
      * @alias tap_image
      */
     tapImage(image: string | Uint8Array, threshold?: number, timeout?: number, opts?: TapImageOptions): Promise<TapImageResult>;
+    /**
+     * Find a picture on the screen and tap its center.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see TapImageOptions.
+     * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
+     * @example await d.tap_image("ok-button.png")
+     * @alias tap_image
+     */
+    tapImage(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, opts?: TapImageOptions): Promise<TapImageResult>;
+    /**
+     * Find a picture on the screen and tap its center.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see TapImageOptions.
+     * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
+     * @example await d.tap_image("ok-button.png")
+     * @alias tap_image
+     */
+    tapImage(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, opts?: TapImageOptions): Promise<TapImageResult>;
+    /**
+     * Find a picture on the screen and tap its center.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see TapImageOptions.
+     * @throws {DroidlineError} with code NOT_FOUND, NO_PERMISSION.
+     * @example await d.tap_image("ok-button.png")
+     * @alias tap_image
+     */
+    tapImage(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, color?: boolean, opts?: TapImageOptions): Promise<TapImageResult>;
+    /**
+     * Whether a picture is on the screen right now. Never waits.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see ImageExistsOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.image_exists("coin.png")
+     */
+    image_exists(image: string | Uint8Array, opts?: ImageExistsOptions): Promise<boolean>;
+    /**
+     * Whether a picture is on the screen right now. Never waits.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see ImageExistsOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.image_exists("coin.png")
+     */
+    image_exists(image: string | Uint8Array, threshold?: number, opts?: ImageExistsOptions): Promise<boolean>;
+    /**
+     * Whether a picture is on the screen right now. Never waits.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see ImageExistsOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.image_exists("coin.png")
+     */
+    image_exists(image: string | Uint8Array, threshold?: number, region?: ReadonlyArray<number>, opts?: ImageExistsOptions): Promise<boolean>;
+    /**
+     * Whether a picture is on the screen right now. Never waits.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see ImageExistsOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.image_exists("coin.png")
+     */
+    image_exists(image: string | Uint8Array, threshold?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, opts?: ImageExistsOptions): Promise<boolean>;
+    /**
+     * Whether a picture is on the screen right now. Never waits.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see ImageExistsOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.image_exists("coin.png")
+     */
+    image_exists(image: string | Uint8Array, threshold?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, color?: boolean, opts?: ImageExistsOptions): Promise<boolean>;
+    /**
+     * Whether a picture is on the screen right now. Never waits.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see ImageExistsOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.image_exists("coin.png")
+     * @alias image_exists
+     */
+    imageExists(image: string | Uint8Array, opts?: ImageExistsOptions): Promise<boolean>;
+    /**
+     * Whether a picture is on the screen right now. Never waits.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see ImageExistsOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.image_exists("coin.png")
+     * @alias image_exists
+     */
+    imageExists(image: string | Uint8Array, threshold?: number, opts?: ImageExistsOptions): Promise<boolean>;
+    /**
+     * Whether a picture is on the screen right now. Never waits.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see ImageExistsOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.image_exists("coin.png")
+     * @alias image_exists
+     */
+    imageExists(image: string | Uint8Array, threshold?: number, region?: ReadonlyArray<number>, opts?: ImageExistsOptions): Promise<boolean>;
+    /**
+     * Whether a picture is on the screen right now. Never waits.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see ImageExistsOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.image_exists("coin.png")
+     * @alias image_exists
+     */
+    imageExists(image: string | Uint8Array, threshold?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, opts?: ImageExistsOptions): Promise<boolean>;
+    /**
+     * Whether a picture is on the screen right now. Never waits.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see ImageExistsOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.image_exists("coin.png")
+     * @alias image_exists
+     */
+    imageExists(image: string | Uint8Array, threshold?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, color?: boolean, opts?: ImageExistsOptions): Promise<boolean>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     */
+    find_images(image: string | Uint8Array, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     */
+    find_images(image: string | Uint8Array, threshold?: number, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     */
+    find_images(image: string | Uint8Array, threshold?: number, timeout?: number, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     */
+    find_images(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     */
+    find_images(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     */
+    find_images(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, color?: boolean, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     */
+    find_images(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, color?: boolean, max?: number, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     * @alias find_images
+     */
+    findImages(image: string | Uint8Array, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     * @alias find_images
+     */
+    findImages(image: string | Uint8Array, threshold?: number, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     * @alias find_images
+     */
+    findImages(image: string | Uint8Array, threshold?: number, timeout?: number, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     * @alias find_images
+     */
+    findImages(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     * @alias find_images
+     */
+    findImages(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     * @alias find_images
+     */
+    findImages(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, color?: boolean, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Every place a picture appears on the screen.
+     *
+     * Answers at once, with an empty list when nothing matches, unless timeout is set. Best matches come first and never overlap. Runs on the PC; for a phone with another screen density, pass scales.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for at least one match. 0 answers at once. Default: 0.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param max Most matches to return. Default: 20.
+     * @param opts Optional parameters by name, see FindImagesOptions.
+     * @throws {DroidlineError} with code NO_PERMISSION.
+     * @example await d.find_images("coin.png")
+     * @alias find_images
+     */
+    findImages(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, color?: boolean, max?: number, opts?: FindImagesOptions): Promise<Array<ImageMatch>>;
+    /**
+     * Wait until a picture is no longer on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see WaitImageGoneOptions.
+     * @throws {DroidlineError} with code TIMEOUT, NO_PERMISSION.
+     * @example await d.wait_image_gone("loading.png")
+     */
+    wait_image_gone(image: string | Uint8Array, opts?: WaitImageGoneOptions): Promise<WaitImageGoneResult>;
+    /**
+     * Wait until a picture is no longer on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see WaitImageGoneOptions.
+     * @throws {DroidlineError} with code TIMEOUT, NO_PERMISSION.
+     * @example await d.wait_image_gone("loading.png")
+     */
+    wait_image_gone(image: string | Uint8Array, threshold?: number, opts?: WaitImageGoneOptions): Promise<WaitImageGoneResult>;
+    /**
+     * Wait until a picture is no longer on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see WaitImageGoneOptions.
+     * @throws {DroidlineError} with code TIMEOUT, NO_PERMISSION.
+     * @example await d.wait_image_gone("loading.png")
+     */
+    wait_image_gone(image: string | Uint8Array, threshold?: number, timeout?: number, opts?: WaitImageGoneOptions): Promise<WaitImageGoneResult>;
+    /**
+     * Wait until a picture is no longer on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see WaitImageGoneOptions.
+     * @throws {DroidlineError} with code TIMEOUT, NO_PERMISSION.
+     * @example await d.wait_image_gone("loading.png")
+     */
+    wait_image_gone(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, opts?: WaitImageGoneOptions): Promise<WaitImageGoneResult>;
+    /**
+     * Wait until a picture is no longer on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see WaitImageGoneOptions.
+     * @throws {DroidlineError} with code TIMEOUT, NO_PERMISSION.
+     * @example await d.wait_image_gone("loading.png")
+     */
+    wait_image_gone(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, opts?: WaitImageGoneOptions): Promise<WaitImageGoneResult>;
+    /**
+     * Wait until a picture is no longer on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see WaitImageGoneOptions.
+     * @throws {DroidlineError} with code TIMEOUT, NO_PERMISSION.
+     * @example await d.wait_image_gone("loading.png")
+     */
+    wait_image_gone(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, color?: boolean, opts?: WaitImageGoneOptions): Promise<WaitImageGoneResult>;
+    /**
+     * Wait until a picture is no longer on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see WaitImageGoneOptions.
+     * @throws {DroidlineError} with code TIMEOUT, NO_PERMISSION.
+     * @example await d.wait_image_gone("loading.png")
+     * @alias wait_image_gone
+     */
+    waitImageGone(image: string | Uint8Array, opts?: WaitImageGoneOptions): Promise<WaitImageGoneResult>;
+    /**
+     * Wait until a picture is no longer on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see WaitImageGoneOptions.
+     * @throws {DroidlineError} with code TIMEOUT, NO_PERMISSION.
+     * @example await d.wait_image_gone("loading.png")
+     * @alias wait_image_gone
+     */
+    waitImageGone(image: string | Uint8Array, threshold?: number, opts?: WaitImageGoneOptions): Promise<WaitImageGoneResult>;
+    /**
+     * Wait until a picture is no longer on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see WaitImageGoneOptions.
+     * @throws {DroidlineError} with code TIMEOUT, NO_PERMISSION.
+     * @example await d.wait_image_gone("loading.png")
+     * @alias wait_image_gone
+     */
+    waitImageGone(image: string | Uint8Array, threshold?: number, timeout?: number, opts?: WaitImageGoneOptions): Promise<WaitImageGoneResult>;
+    /**
+     * Wait until a picture is no longer on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see WaitImageGoneOptions.
+     * @throws {DroidlineError} with code TIMEOUT, NO_PERMISSION.
+     * @example await d.wait_image_gone("loading.png")
+     * @alias wait_image_gone
+     */
+    waitImageGone(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, opts?: WaitImageGoneOptions): Promise<WaitImageGoneResult>;
+    /**
+     * Wait until a picture is no longer on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see WaitImageGoneOptions.
+     * @throws {DroidlineError} with code TIMEOUT, NO_PERMISSION.
+     * @example await d.wait_image_gone("loading.png")
+     * @alias wait_image_gone
+     */
+    waitImageGone(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, opts?: WaitImageGoneOptions): Promise<WaitImageGoneResult>;
+    /**
+     * Wait until a picture is no longer on the screen.
+     *
+     * Optional, and runs on the PC: the server takes a screenshot and compares. Cut the image from a screenshot of the same phone; for a phone with another screen density, pass scales. On Android 9 and 10 screenshots need screen capture permission.
+     *
+     * @param image PNG or JPEG of what to find, cut from a screenshot of the same phone. The SDKs and the CLI take a file path; on the wire it is base64.
+     * @param threshold How close the match must be, from 0 to 1. Default: 0.9.
+     * @param timeout Seconds to wait for the target to appear. Default: 10.
+     * @param region Search only inside this box, given as left, top, right, bottom in screen pixels. Faster, and nothing outside it can match.
+     * @param scales Sizes of the image to try, 1 being the size it was cut at, such as 0.8, 1, 1.25 for a phone with another screen density. Each size adds time.
+     * @param color Also require the average color to agree, so a red and a green button of the same shape differ. Default: false.
+     * @param opts Optional parameters by name, see WaitImageGoneOptions.
+     * @throws {DroidlineError} with code TIMEOUT, NO_PERMISSION.
+     * @example await d.wait_image_gone("loading.png")
+     * @alias wait_image_gone
+     */
+    waitImageGone(image: string | Uint8Array, threshold?: number, timeout?: number, region?: ReadonlyArray<number>, scales?: ReadonlyArray<number>, color?: boolean, opts?: WaitImageGoneOptions): Promise<WaitImageGoneResult>;
     /**
      * Read the text on the screen with OCR.
      *

package/dist/generated.js

@@ -78,25 +78,55 @@ export class DeviceCommands {
         return this._run("record", "none", collect("record", args, ["on"], ["minutes"]));
     }
     async find_image(...args) {
-        const params = collect("find_image", args, ["image"], ["threshold", "timeout"]);
+        const params = collect("find_image", args, ["image"], ["threshold", "timeout", "region", "scales", "color"]);
         params["image"] = await this._loadImage(params["image"]);
         return this._run("find_image", "fields", params);
     }
     async findImage(...args) {
-        const params = collect("find_image", args, ["image"], ["threshold", "timeout"]);
+        const params = collect("find_image", args, ["image"], ["threshold", "timeout", "region", "scales", "color"]);
         params["image"] = await this._loadImage(params["image"]);
         return this._run("find_image", "fields", params);
     }
     async tap_image(...args) {
-        const params = collect("tap_image", args, ["image"], ["threshold", "timeout"]);
+        const params = collect("tap_image", args, ["image"], ["threshold", "timeout", "region", "scales", "color"]);
         params["image"] = await this._loadImage(params["image"]);
         return this._run("tap_image", "fields", params);
     }
     async tapImage(...args) {
-        const params = collect("tap_image", args, ["image"], ["threshold", "timeout"]);
+        const params = collect("tap_image", args, ["image"], ["threshold", "timeout", "region", "scales", "color"]);
         params["image"] = await this._loadImage(params["image"]);
         return this._run("tap_image", "fields", params);
     }
+    async image_exists(...args) {
+        const params = collect("image_exists", args, ["image"], ["threshold", "region", "scales", "color"]);
+        params["image"] = await this._loadImage(params["image"]);
+        return this._run("image_exists", "value", params);
+    }
+    async imageExists(...args) {
+        const params = collect("image_exists", args, ["image"], ["threshold", "region", "scales", "color"]);
+        params["image"] = await this._loadImage(params["image"]);
+        return this._run("image_exists", "value", params);
+    }
+    async find_images(...args) {
+        const params = collect("find_images", args, ["image"], ["threshold", "timeout", "region", "scales", "color", "max"]);
+        params["image"] = await this._loadImage(params["image"]);
+        return this._run("find_images", "value", params);
+    }
+    async findImages(...args) {
+        const params = collect("find_images", args, ["image"], ["threshold", "timeout", "region", "scales", "color", "max"]);
+        params["image"] = await this._loadImage(params["image"]);
+        return this._run("find_images", "value", params);
+    }
+    async wait_image_gone(...args) {
+        const params = collect("wait_image_gone", args, ["image"], ["threshold", "timeout", "region", "scales", "color"]);
+        params["image"] = await this._loadImage(params["image"]);
+        return this._run("wait_image_gone", "fields", params);
+    }
+    async waitImageGone(...args) {
+        const params = collect("wait_image_gone", args, ["image"], ["threshold", "timeout", "region", "scales", "color"]);
+        params["image"] = await this._loadImage(params["image"]);
+        return this._run("wait_image_gone", "fields", params);
+    }
     async ocr(...args) {
         return this._run("ocr", "fields", collect("ocr", args, [], ["lang"]));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "droidline",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Android automation from Node.js: test your apps on real phones, script the tasks you repeat and run many phones at once. No ADB, no USB cable, no root.",
   "license": "MIT",
   "type": "module",