detox 20.13.2 → 20.13.3

package/detox.d.ts

@@ -0,0 +1,1823 @@
+// TypeScript definitions for Detox
+// Original authors (from DefinitelyTyped):
+// * Jane Smith <jsmith@example.com>
+// * Tareq El-Masri <https://github.com/TareqElMasri>
+// * Steve Chun <https://github.com/stevechun>
+// * Hammad Jutt <https://github.com/hammadj>
+// * pera <https://github.com/santiagofm>
+// * Max Komarychev <https://github.com/maxkomarychev>
+// * Dor Ben Baruch <https://github.com/Dor256>
+
+import { BunyanDebugStreamOptions } from 'bunyan-debug-stream';
+
+declare global {
+    namespace Detox {
+        //#region DetoxConfig
+
+        interface DetoxConfig extends DetoxConfigurationCommon {
+            /**
+             * @example extends: './relative/detox.config'
+             * @example extends: '@my-org/detox-preset'
+             */
+            extends?: string;
+
+            apps?: Record<string, DetoxAppConfig>;
+            devices?: Record<string, DetoxDeviceConfig>;
+            selectedConfiguration?: string;
+            configurations: Record<string, DetoxConfiguration>;
+        }
+
+        type DetoxConfigurationCommon = {
+            artifacts?: false | DetoxArtifactsConfig;
+            behavior?: DetoxBehaviorConfig;
+            logger?: DetoxLoggerConfig;
+            session?: DetoxSessionConfig;
+            testRunner?: DetoxTestRunnerConfig;
+        };
+
+        interface DetoxArtifactsConfig {
+            rootDir?: string;
+            pathBuilder?: string;
+            plugins?: {
+                log?: 'none' | 'failing' | 'all' | DetoxLogArtifactsPluginConfig;
+                screenshot?: 'none' | 'manual' | 'failing' | 'all' | DetoxScreenshotArtifactsPluginConfig;
+                video?: 'none' | 'failing' | 'all' | DetoxVideoArtifactsPluginConfig;
+                instruments?: 'none' | 'all' | DetoxInstrumentsArtifactsPluginConfig;
+                uiHierarchy?: 'disabled' | 'enabled' | DetoxUIHierarchyArtifactsPluginConfig;
+
+                [pluginId: string]: unknown;
+            };
+        }
+
+        interface DetoxBehaviorConfig {
+            init?: {
+                /**
+                 * By default, Detox exports `device`, `expect`, `element`, `by` and `waitFor`
+                 * as global variables. If you want to control their initialization manually,
+                 * set this property to `false`.
+                 *
+                 * This is useful when during E2E tests you also need to run regular expectations
+                 * in Node.js. Jest's `expect` for instance, will not be overridden by Detox when
+                 * this option is used.
+                 */
+                exposeGlobals?: boolean;
+                /**
+                 * By default, Detox will uninstall and install the app upon initialization.
+                 * If you wish to reuse the existing app for a faster run, set the property to
+                 * `false`.
+                 */
+                reinstallApp?: boolean;
+                /**
+                 * When false, `detox test` command always deletes the shared lock file on start,
+                 * assuming it had been left from the previous, already finished test session.
+                 * The lock file contains information about busy and free devices and ensures
+                 * no device can be used simultaneously by multiple test workers.
+                 *
+                 * Setting it to **true** might be useful when if you need to run multiple
+                 * `detox test` commands in parallel, e.g. test a few configurations at once.
+                 *
+                 * @default false
+                 */
+                keepLockFile?: boolean;
+            };
+            launchApp?: 'auto' | 'manual';
+            cleanup?: {
+                shutdownDevice?: boolean;
+            };
+        }
+
+        type _DetoxLoggerOptions = Omit<BunyanDebugStreamOptions, 'out'>;
+
+        interface DetoxLoggerConfig {
+            /**
+             * Log level filters the messages printed to your terminal,
+             * and it does not affect the logs written to the artifacts.
+             *
+             * Use `info` by default.
+             * Use `error` or warn when you want to make the output as silent as possible.
+             * Use `debug` to control what generally is happening under the hood.
+             * Use `trace` when troubleshooting specific issues.
+             *
+             * @default 'info'
+             */
+            level?: DetoxLogLevel;
+            /**
+             * When enabled, hijacks all the console methods (console.log, console.warn, etc)
+             * so that the messages printed via them are formatted and saved as Detox logs.
+             *
+             * @default true
+             */
+            overrideConsole?: boolean;
+            /**
+             * Since Detox is using
+             * {@link https://www.npmjs.com/package/bunyan-debug-stream bunyan-debug-stream}
+             * for printing logs, all its options are exposed for sake of simplicity
+             * of customization.
+             *
+             * The only exception is {@link BunyanDebugStreamOptions#out} option,
+             * which is always set to `process.stdout`.
+             *
+             * You can also pass a callback function to override the logger config
+             * programmatically, e.g. depending on the selected log level.
+             *
+             * @see {@link BunyanDebugStreamOptions}
+             */
+            options?: _DetoxLoggerOptions | ((config: Partial<DetoxLoggerConfig>) => _DetoxLoggerOptions);
+        }
+
+        interface DetoxSessionConfig {
+            autoStart?: boolean;
+            debugSynchronization?: number;
+            server?: string;
+            sessionId?: string;
+        }
+
+        interface DetoxTestRunnerConfig {
+            args?: {
+                /**
+                 * The command to use for runner: 'jest', 'nyc jest',
+                 */
+                $0: string;
+                /**
+                 * The positional arguments to pass to the runner.
+                 */
+                _?: string[];
+                /**
+                 * Any other properties recognized by test runner
+                 */
+                [prop: string]: unknown;
+            };
+
+            /**
+             * This is an add-on section used by our Jest integration code (but not Detox core itself).
+             * In other words, if you’re implementing (or using) a custom integration with some other test runner, feel free to define a section for yourself (e.g. `testRunner.mocha`)
+             */
+            jest?: {
+                /**
+                 * Environment setup timeout
+                 *
+                 * As a part of the environment setup, Detox boots the device and installs the apps.
+                 * If that takes longer than the specified value, the entire test suite will be considered as failed, e.g.:
+                 * ```plain text
+                 * FAIL  e2e/starter.test.js
+                 * ● Test suite failed to run
+                 *
+                 * Exceeded timeout of 300000ms while setting up Detox environment
+                 * ```
+                 *
+                 * The default value is 5 minutes.
+                 *
+                 * @default 300000
+                 * @see {@link https://jestjs.io/docs/configuration/#testenvironment-string}
+                 */
+                setupTimeout?: number | undefined;
+                /**
+                 * Environemnt teardown timeout
+                 *
+                 * If the environment teardown takes longer than the specified value, Detox will throw a timeout error.
+                 * The default value is half a minute.
+                 *
+                 * @default 30000 (30 seconds)
+                 * @see {@link https://jestjs.io/docs/configuration/#testenvironment-string}
+                 */
+                teardownTimeout?: number | undefined;
+                /**
+                 * Jest provides an API to re-run individual failed tests: `jest.retryTimes(count)`.
+                 * When Detox detects the use of this API, it suppresses its own CLI retry mechanism controlled via `detox test … --retries <N>` or {@link DetoxTestRunnerConfig#retries}.
+                 * The motivation is simple – activating the both mechanisms is apt to increase your test duration dramatically, if your tests are flaky.
+                 * If you wish nevertheless to use both the mechanisms simultaneously, set it to `true`.
+                 *
+                 * @default false
+                 * @see {@link https://jestjs.io/docs/29.0/jest-object#jestretrytimesnumretries-options}
+                 */
+                retryAfterCircusRetries?: boolean;
+                /**
+                 * By default, Jest prints the test names and their status (_passed_ or _failed_) at the very end of the test session.
+                 * When enabled, it makes Detox to print messages like these each time the new test starts and ends:
+                 * ```plain text
+                 * 18:03:36.258 detox[40125] i Sanity: should have welcome screen
+                 * 18:03:37.495 detox[40125] i Sanity: should have welcome screen [OK]
+                 * 18:03:37.496 detox[40125] i Sanity: should show hello screen after tap
+                 * 18:03:38.928 detox[40125] i Sanity: should show hello screen after tap [OK]
+                 * 18:03:38.929 detox[40125] i Sanity: should show world screen after tap
+                 * 18:03:40.351 detox[40125] i Sanity: should show world screen after tap [OK]
+                 * ```
+                 * By default, it is enabled automatically in test sessions with a single worker.
+                 * And vice versa, if multiple tests are executed concurrently, Detox turns it off to avoid confusion in the log.
+                 * Use boolean values, `true` or `false`, to turn off the automatic choice.
+                 *
+                 * @default undefined
+                 */
+                reportSpecs?: boolean | undefined;
+                /**
+                 * In the environment setup phase, Detox boots the device and installs the apps.
+                 * This flag tells Detox to print messages like these every time the device gets assigned to a specific suite:
+                 *
+                 * ```plain text
+                 * 18:03:29.869 detox[40125] i starter.test.js is assigned to 4EC84833-C7EA-4CA3-A6E9-5C30A29EA596 (iPhone 12 Pro Max)
+                 * ```
+                 *
+                 * @default true
+                 */
+                reportWorkerAssign?: boolean | undefined;
+            };
+            /**
+             * Retries count. Zero means a single attempt to run tests.
+             */
+            retries?: number;
+            /**
+             * When true, tells Detox CLI to cancel next retrying if it gets
+             * at least one report about a permanent test suite failure.
+             * Has no effect, if {@link DetoxTestRunnerConfig#retries} is
+             * undefined or set to zero.
+             *
+             * @default false
+             * @see {DetoxInternals.DetoxTestFileReport#isPermanentFailure}
+             */
+            bail?: boolean;
+            /**
+             * Custom handler to process --inspect-brk CLI flag.
+             * Use it when you rely on another test runner than Jest to mutate the config.
+             */
+            inspectBrk?: (config: DetoxTestRunnerConfig) => void;
+            /**
+             * Forward environment variables to the spawned test runner
+             * accordingly to the given CLI argument overrides.
+             *
+             * If false, Detox CLI will be only printing a hint message on
+             * how to start the test runner using environment variables,
+             * in case when a user wants to avoid using Detox CLI.
+             *
+             * @default false
+             */
+            forwardEnv?: boolean;
+        }
+
+        type DetoxAppConfig = (DetoxBuiltInAppConfig | DetoxCustomAppConfig) & {
+            /**
+             * App name to use with device.selectApp(appName) calls.
+             * Can be omitted if you have a single app under the test.
+             *
+             * @see Device#selectApp
+             */
+            name?: string;
+        };
+
+        type DetoxDeviceConfig = DetoxBuiltInDeviceConfig | DetoxCustomDriverConfig;
+
+        interface DetoxLogArtifactsPluginConfig {
+            enabled?: boolean;
+            keepOnlyFailedTestsArtifacts?: boolean;
+        }
+
+        interface DetoxScreenshotArtifactsPluginConfig {
+            enabled?: boolean;
+            keepOnlyFailedTestsArtifacts?: boolean;
+            shouldTakeAutomaticSnapshots?: boolean;
+            takeWhen?: {
+                testStart?: boolean;
+                testFailure?: boolean;
+                testDone?: boolean;
+                appNotReady?: boolean;
+            };
+        }
+
+        interface DetoxVideoArtifactsPluginConfig {
+            enabled?: boolean;
+            keepOnlyFailedTestsArtifacts?: boolean;
+            android?: Partial<{
+                size: [number, number];
+                bitRate: number;
+                timeLimit: number;
+                verbose: boolean;
+            }>;
+            simulator?: Partial<{
+                codec: string;
+            }>;
+        }
+
+        interface DetoxInstrumentsArtifactsPluginConfig {
+            enabled?: boolean;
+        }
+
+        interface DetoxUIHierarchyArtifactsPluginConfig {
+            enabled?: boolean;
+        }
+
+        type DetoxBuiltInAppConfig = (DetoxIosAppConfig | DetoxAndroidAppConfig);
+
+        interface DetoxIosAppConfig {
+            type: 'ios.app';
+            binaryPath: string;
+            bundleId?: string;
+            build?: string;
+            start?: string;
+            launchArgs?: Record<string, any>;
+        }
+
+        interface DetoxAndroidAppConfig {
+            type: 'android.apk';
+            binaryPath: string;
+            bundleId?: string;
+            build?: string;
+            start?: string;
+            testBinaryPath?: string;
+            launchArgs?: Record<string, any>;
+            /**
+             * TCP ports to `adb reverse` upon the installation.
+             * E.g. 8081 - to be able to access React Native packager in Debug mode.
+             *
+             * @example [8081]
+             */
+            reversePorts?: number[];
+        }
+
+        interface DetoxCustomAppConfig {
+            type: string;
+
+            [prop: string]: unknown;
+        }
+
+        type DetoxBuiltInDeviceConfig =
+            | DetoxIosSimulatorDriverConfig
+            | DetoxAttachedAndroidDriverConfig
+            | DetoxAndroidEmulatorDriverConfig
+            | DetoxGenymotionCloudDriverConfig;
+
+        interface DetoxIosSimulatorDriverConfig {
+            type: 'ios.simulator';
+            device: string | Partial<IosSimulatorQuery>;
+            bootArgs?: string;
+        }
+
+        interface DetoxSharedAndroidDriverConfig {
+            forceAdbInstall?: boolean;
+            utilBinaryPaths?: string[];
+        }
+
+        interface DetoxAttachedAndroidDriverConfig extends DetoxSharedAndroidDriverConfig {
+            type: 'android.attached';
+            device: string | { adbName: string };
+        }
+
+        interface DetoxAndroidEmulatorDriverConfig extends DetoxSharedAndroidDriverConfig {
+            type: 'android.emulator';
+            device: string | { avdName: string };
+            bootArgs?: string;
+            gpuMode?: 'auto' | 'host' | 'swiftshader_indirect' | 'angle_indirect' | 'guest' | 'off';
+            headless?: boolean;
+            /**
+             * @default true
+             */
+            readonly?: boolean;
+        }
+
+        interface DetoxGenymotionCloudDriverConfig extends DetoxSharedAndroidDriverConfig {
+            type: 'android.genycloud';
+            device: string | { recipeUUID: string; } | { recipeName: string; };
+        }
+
+        interface DetoxCustomDriverConfig {
+            type: string;
+
+            [prop: string]: unknown;
+        }
+
+        interface IosSimulatorQuery {
+            id: string;
+            type: string;
+            name: string;
+            os: string;
+        }
+
+        type DetoxConfiguration = DetoxConfigurationCommon & (
+            | DetoxConfigurationSingleApp
+            | DetoxConfigurationMultiApps
+            );
+
+        interface DetoxConfigurationSingleApp {
+            device: DetoxAliasedDevice;
+            app: DetoxAliasedApp;
+        }
+
+        interface DetoxConfigurationMultiApps {
+            device: DetoxAliasedDevice;
+            apps: DetoxAliasedApp[];
+        }
+
+        type DetoxAliasedDevice = string | DetoxDeviceConfig;
+
+        type DetoxAliasedApp = string | DetoxAppConfig;
+
+        //#endregion
+
+        interface DetoxExportWrapper {
+            readonly device: Device;
+
+            readonly element: ElementFacade;
+
+            readonly waitFor: WaitForFacade;
+
+            readonly expect: ExpectFacade;
+
+            readonly by: ByFacade;
+
+            readonly web: WebFacade;
+
+            readonly DetoxConstants: {
+                userNotificationTriggers: {
+                    push: 'push';
+                    calendar: 'calendar';
+                    timeInterval: 'timeInterval';
+                    location: 'location';
+                };
+                userActivityTypes: {
+                    searchableItem: string;
+                    browsingWeb: string;
+                },
+                searchableItemActivityIdentifier: string;
+            };
+
+            /**
+             * Detox logger instance. Can be used for saving user logs to the general log file.
+             */
+            readonly log: Logger;
+
+            /**
+             * @deprecated
+             *
+             * Deprecated - use {@link Detox.Logger#trace}
+             * Detox tracer instance. Can be used for building timelines in Google Event Tracing format.
+             */
+            readonly trace: {
+                /** @deprecated */
+                readonly startSection: (name: string) => void;
+                /** @deprecated */
+                readonly endSection: (name: string) => void;
+            };
+
+            /**
+             * Trace a single call, with a given name and arguments.
+             *
+             * @deprecated
+             * @param sectionName The name of the section to trace.
+             * @param promiseOrFunction Promise or a function that provides a promise.
+             * @param args Optional arguments to pass to the trace.
+             * @returns The returned value of the traced call.
+             * @see https://wix.github.io/Detox/docs/19.x/api/detox-object-api/#detoxtracecall
+             */
+            readonly traceCall: <T>(event: string, action: () => Promise<T>, args?: Record<string, unknown>) => Promise<T>;
+        }
+
+        interface Logger {
+            readonly level: DetoxLogLevel;
+
+            readonly fatal: _LogMethod;
+            readonly error: _LogMethod;
+            readonly warn: _LogMethod;
+            readonly info: _LogMethod;
+            readonly debug: _LogMethod;
+            readonly trace: _LogMethod;
+
+            child(context?: Partial<LogEvent>): Logger;
+        }
+
+        /** @internal */
+        interface _LogMethod extends _LogMethodSignature {
+            readonly begin: _LogMethodSignature;
+            readonly complete: _CompleteMethodSignature;
+            readonly end: _LogMethodSignature;
+        }
+
+        /** @internal */
+        interface _LogMethodSignature {
+            (...args: unknown[]): void
+            (event: LogEvent, ...args: unknown[]): void;
+        }
+
+        /** @internal */
+        interface _CompleteMethodSignature {
+            <T>(message: string, action: T | (() => T)): T;
+            <T>(event: LogEvent, message: string, action: T | (() => T)): T;
+        }
+
+        type LogEvent = {
+            /** Use when there's a risk of logging several parallel duration events. */
+            id?: string | number;
+            /** Optional. Event categories (tags) to facilitate filtering. */
+            cat?: string | string[];
+            /** Optional. Color name (applicable in Google Chrome Trace Format) */
+            cname?: string;
+
+            /** Reserved property. Process ID. */
+            pid?: never;
+            /** Reserved property. Thread ID. */
+            tid?: never;
+            /** Reserved property. Timestamp. */
+            ts?: never;
+            /** Reserved property. Event phase. */
+            ph?: never;
+
+            [customProperty: string]: unknown;
+        };
+
+        type DetoxLogLevel = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace';
+
+        type Point2D = {
+            x: number,
+            y: number,
+        }
+
+        /**
+         * A construct allowing for the querying and modification of user arguments passed to an app upon launch by Detox.
+         *
+         * @see AppLaunchArgs#modify
+         * @see AppLaunchArgs#reset
+         * @see AppLaunchArgs#get
+         */
+        interface AppLaunchArgs {
+            /**
+             * Shared (global) arguments that are not specific to a particular application.
+             * Selecting another app does not reset them, yet they still can be overridden
+             * by configuring app-specific launch args.
+             * @see Device#selectApp
+             * @see AppLaunchArgs
+             */
+            readonly shared: ScopedAppLaunchArgs;
+
+            /**
+             * Modify the launch-arguments via a modifier object, according to the following logic:
+             * - Non-nullish modifier properties would set a new value or override the previous value of
+             *   existing properties with the same name.
+             * - Modifier properties set to either `undefined` or `null` would delete the corresponding property
+             *   if it existed.
+             * These custom app launch arguments get erased whenever you select a different application.
+             * If you need to share them between all the applications, use {@link AppLaunchArgs#shared} property.
+             * Note: app-specific launch args have a priority over shared ones.
+             *
+             * @param modifier The modifier object.
+             * @example
+             * // With current launch arguments set to:
+             * // {
+             * //   mockServerPort: 1234,
+             * //   mockServerCredentials: 'user@test.com:12345678',
+             * // }
+             * device.appLaunchArgs.modify({
+             *   mockServerPort: 4321,
+             *   mockServerCredentials: null,
+             *   mockServerToken: 'abcdef',
+             * });
+             * await device.launchApp();
+             * // ==> launch-arguments become:
+             * // {
+             * //   mockServerPort: 4321,
+             * //   mockServerToken: 'abcdef',
+             * // }
+             */
+            modify(modifier: object): this;
+
+            /**
+             * Reset all app-specific launch arguments (back to an empty object).
+             * If you need to reset the shared launch args, use {@link AppLaunchArgs#shared}.
+             */
+            reset(): this;
+
+            /**
+             * Get all currently set launch arguments (including shared ones).
+             * @returns An object containing all launch-arguments.
+             * Note: mutating the values inside the result object is pointless, as it is immutable.
+             */
+            get(): object;
+        }
+
+        /**
+         * Shared (global) arguments that are not specific to a particular application.
+         */
+        interface ScopedAppLaunchArgs {
+            /** @see AppLaunchArgs#modify */
+            modify(modifier: object): this;
+
+            /** @see AppLaunchArgs#reset */
+            reset(): this;
+
+            /** @see AppLaunchArgs#get */
+            get(): object;
+        }
+
+        type DigitWithoutZero = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+        type Digit = 0 | DigitWithoutZero;
+        type BatteryLevel = `${Digit}` | `${DigitWithoutZero}${Digit}` | "100";
+
+        interface Device {
+            /**
+             * Holds the environment-unique ID of the device, namely, the adb ID on Android (e.g. emulator-5554) and the Mac-global simulator UDID on iOS -
+             * as used by simctl (e.g. AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE).
+             */
+            id: string;
+            /**
+             * Holds a descriptive name of the device. Example: emulator-5554 (Pixel_API_29)
+             */
+            name: string;
+
+            /**
+             * Select the current app (relevant only to multi-app configs) by its name.
+             * After execution, all app-specific device methods will target the selected app.
+             *
+             * @see DetoxAppConfig#name
+             * @example
+             * await device.selectApp('passenger');
+             * await device.launchApp(); // passenger
+             * // ... run tests for the passenger app
+             * await device.uninstallApp(); // passenger
+             * await device.selectApp('driver');
+             * await device.installApp(); // driver
+             * await device.launchApp(); // driver
+             * // ... run tests for the driver app
+             * await device.terminateApp(); // driver
+             */
+            selectApp(app: string): Promise<void>;
+
+            /**
+             * Launch the app.
+             *
+             * <p>For info regarding launch arguments, refer to the [dedicated guide](https://wix.github.io/Detox/docs/api/launch-args).
+             *
+             * @example
+             * // Terminate the app and launch it again. If set to false, the simulator will try to bring app from background,
+             * // if the app isn't running, it will launch a new instance. default is false
+             * await device.launchApp({newInstance: true});
+             * @example
+             * // Grant or deny runtime permissions for your application.
+             * await device.launchApp({permissions: {calendar: 'YES'}});
+             * @example
+             * // Mock opening the app from URL to test your app's deep link handling mechanism.
+             * await device.launchApp({url: url});
+             * @example
+             * // Start the app with some custom arguments.
+             * await device.launchApp({
+             *   launchArgs: {arg1: 1, arg2: "2"},
+             * });
+             */
+            launchApp(config?: DeviceLaunchAppConfig): Promise<void>;
+
+            /**
+             * Relaunch the app. Convenience method that calls {@link Device#launchApp}
+             * with { newInstance: true } override.
+             *
+             * @deprecated
+             * @param config
+             * @see Device#launchApp
+             */
+            relaunchApp(config?: DeviceLaunchAppConfig): Promise<void>;
+
+            /**
+             * Access the user-defined launch-arguments predefined through static scopes such as the Detox configuration file and
+             * command-line arguments. This access allows - through dedicated methods, for both value-querying and
+             * modification (see {@link AppLaunchArgs}).
+             * Refer to the [dedicated guide](https://wix.github.io/Detox/docs/api/launch-args) for complete details.
+             *
+             * @example
+             * // With Detox being preconfigured statically to use these arguments in app launch:
+             * // {
+             * //   mockServerPort: 1234,
+             * // }
+             * // The following code would result in these arguments eventually passed into the launched app:
+             * // {
+             * //   mockServerPort: 4321,
+             * //   mockServerToken: 'uvwxyz',
+             * // }
+             * device.appLaunchArgs.modify({
+             *   mockServerPort: 4321,
+             *   mockServerToken: 'abcdef',
+             * });
+             * await device.launchApp({ launchArgs: { mockServerToken: 'uvwxyz' } });
+             *
+             * @see AppLaunchArgs
+             */
+            appLaunchArgs: AppLaunchArgs;
+
+            /**
+             * Terminate the app.
+             *
+             * @example
+             * // By default, terminateApp() with no params will terminate the app
+             * await device.terminateApp();
+             * @example
+             * // To terminate another app, specify its bundle id
+             * await device.terminateApp('other.bundle.id');
+             */
+            terminateApp(bundle?: string): Promise<void>;
+
+            /**
+             * Send application to background by bringing com.apple.springboard to the foreground.
+             * Combining sendToHome() with launchApp({newInstance: false}) will simulate app coming back from background.
+             * @example
+             * await device.sendToHome();
+             * await device.launchApp({newInstance: false});
+             */
+            sendToHome(): Promise<void>;
+
+            /**
+             * If this is a React Native app, reload the React Native JS bundle. This action is much faster than device.launchApp(), and can be used if you just need to reset your React Native logic.
+             *
+             * @example await device.reloadReactNative()
+             */
+            reloadReactNative(): Promise<void>;
+
+            /**
+             * By default, installApp() with no params will install the app file defined in the current configuration.
+             * To install another app, specify its path
+             * @example await device.installApp();
+             * @example await device.installApp('path/to/other/app');
+             */
+            installApp(path?: any): Promise<void>;
+
+            /**
+             * By default, uninstallApp() with no params will uninstall the app defined in the current configuration.
+             * To uninstall another app, specify its bundle id
+             * @example await device.installApp('other.bundle.id');
+             */
+            uninstallApp(bundle?: string): Promise<void>;
+
+            /**
+             * Mock opening the app from URL. sourceApp is an optional parameter to specify source application bundle id.
+             */
+            openURL(url: { url: string; sourceApp?: string }): Promise<void>;
+
+            /**
+             * Mock handling of received user notification when app is in foreground.
+             */
+            sendUserNotification(...params: any[]): Promise<void>;
+
+            /**
+             * Mock handling of received user activity when app is in foreground.
+             */
+            sendUserActivity(...params: any[]): Promise<void>;
+
+            /**
+             * Takes "portrait" or "landscape" and rotates the device to the given orientation. Currently only available in the iOS Simulator.
+             */
+            setOrientation(orientation: Orientation): Promise<void>;
+
+            /**
+             * Sets the simulator/emulator location to the given latitude and longitude.
+             *
+             * <p/>On iOS `setLocation` is dependent on [fbsimctl](https://github.com/facebook/idb/tree/4b7929480c3c0f158f33f78a5b802c1d0e7030d2/fbsimctl)
+             * which [is now deprecated](https://github.com/wix/Detox/issues/1371).
+             * If `fbsimctl` is not installed, the command will fail, asking for it to be installed.
+             *
+             * <p/>On Android `setLocation` will work with both Android Emulator (bundled with Android development tools) and Genymotion.
+             * The correct permissions must be set in your app manifest.
+             *
+             * @example await device.setLocation(32.0853, 34.7818);
+             */
+            setLocation(lat: number, lon: number): Promise<void>;
+
+            /**
+             * (iOS only) Override simulator’s status bar.
+             * @platform iOS
+             * @param {config} config status bar configuration.
+             * @example
+             * await device.setStatusBar({
+             *   time: "12:34",
+             *   // Set the date or time to a fixed value.
+             *   // If the string is a valid ISO date string it will also set the date on relevant devices.
+             *   dataNetwork: "wifi",
+             *   // If specified must be one of 'hide', 'wifi', '3g', '4g', 'lte', 'lte-a', 'lte+', '5g', '5g+', '5g-uwb', or '5g-uc'.
+             *   wifiMode: "failed",
+             *   // If specified must be one of 'searching', 'failed', or 'active'.
+             *   wifiBars: "2",
+             *   // If specified must be 0-3.
+             *   cellularMode: "searching",
+             *   // If specified must be one of 'notSupported', 'searching', 'failed', or 'active'.
+             *   cellularBars: "3",
+             *   // If specified must be 0-4.
+             *   operatorName: "A1",
+             *   // Set the cellular operator/carrier name. Use '' for the empty string.
+             *   batteryState: "charging",
+             *   // If specified must be one of 'charging', 'charged', or 'discharging'.
+             *   batteryLevel: "50",
+             *   // If specified must be 0-100.
+             *  });
+             */
+            setStatusBar(config: {
+              time?: string,
+              dataNetwork?: "hide" | "wifi" | "3g" | "4g" | "lte" | "lte-a" | "lte+" | "5g" | "5g+" | "5g-uwb" | "5g-uc",
+              wifiMode?: "searching" |"failed" | "active",
+              wifiBars?: "0" | "1" | "2" | "3",
+              cellularMode?: "notSupported" | "searching" | "failed" | "active",
+              cellularBars?: "0" | "1" | "2" | "3" | "4",
+              operatorName?: string;
+              batteryState?: "charging" | "charged" | "discharging",
+              batteryLevel?: BatteryLevel,
+            }): Promise<void>;
+
+            /**
+             * Disable network synchronization mechanism on preferred endpoints. Useful if you want to on skip over synchronizing on certain URLs.
+             *
+             * @example await device.setURLBlacklist(['.*127.0.0.1.*']);
+             */
+            setURLBlacklist(urls: string[]): Promise<void>;
+
+            /**
+             * Temporarily disable synchronization (idle/busy monitoring) with the app - namely, stop waiting for the app to go idle before moving forward in the test execution.
+             *
+             * <p/>This API is useful for cases where test assertions must be made in an area of your application where it is okay for it to ever remain partly *busy* (e.g. due to an
+             * endlessly repeating on-screen animation). However, using it inherently suggests that you are likely to resort to applying `sleep()`'s in your test code - testing
+             * that area, **which is not recommended and can never be 100% stable.
+             * **Therefore, as a rule of thumb, test code running "inside" a sync-disabled mode must be reduced to the bare minimum.
+             *
+             * <p/>Note: Synchronization is enabled by default, and it gets **reenabled on every launch of a new instance of the app.**
+             *
+             * @example await device.disableSynchronization();
+             */
+            disableSynchronization(): Promise<void>;
+
+            /**
+             * Reenable synchronization (idle/busy monitoring) with the app - namely, resume waiting for the app to go idle before moving forward in the test execution, after a
+             * previous disabling of it through a call to `device.disableSynchronization()`.
+             *
+             * <p/>Warning: Making this call would resume synchronization **instantly**, having its returned promise only resolve when the app becomes idle again.
+             * In other words, this **must only be called after you navigate back to "the safe zone", where the app should be able to eventually become idle again**, or it would
+             * remain suspended "forever" (i.e. until a safeguard time-out expires).
+             *
+             * @example await device.enableSynchronization();
+             */
+            enableSynchronization(): Promise<void>;
+
+            /**
+             * Resets the Simulator to clean state (like the Simulator > Reset Content and Settings... menu item), especially removing previously set permissions.
+             *
+             * @example await device.resetContentAndSettings();
+             */
+            resetContentAndSettings(): Promise<void>;
+
+            /**
+             * Returns the current device, ios or android.
+             *
+             * @example
+             * if (device.getPlatform() === 'ios') {
+             *     await expect(loopSwitch).toHaveValue('1');
+             * }
+             */
+            getPlatform(): 'ios' | 'android';
+
+            /**
+             * Takes a screenshot on the device and schedules putting it in the artifacts folder upon completion of the current test.
+             * @param name for the screenshot artifact
+             * @returns a temporary path to the screenshot.
+             * @example
+             * test('Menu items should have logout', async () => {
+             *   const tempPath = await device.takeScreenshot('tap on menu');
+             *   // The temporary path will remain valid until the test completion.
+             *   // Afterwards, the screenshot will be moved, e.g.:
+             *   // * on success, to: <artifacts-location>/✓ Menu items should have Logout/tap on menu.png
+             *   // * on failure, to: <artifacts-location>/✗ Menu items should have Logout/tap on menu.png
+             * });
+             */
+            takeScreenshot(name: string): Promise<string>;
+
+            /**
+             * (iOS only) Saves a view hierarchy snapshot (*.viewhierarchy) of the currently opened application
+             * to a temporary folder and schedules putting it to the artifacts folder upon the completion of
+             * the current test. The file can be opened later in Xcode 12.0 and above.
+             * @see https://developer.apple.com/documentation/xcode-release-notes/xcode-12-release-notes#:~:text=57933113
+             * @param [name="capture"] optional name for the *.viewhierarchy artifact
+             * @returns a temporary path to the captured view hierarchy snapshot.
+             * @example
+             * test('Menu items should have logout', async () => {
+             *   await device.captureViewHierarchy('myElements');
+             *   // The temporary path will remain valid until the test completion.
+             *   // Afterwards, the artifact will be moved, e.g.:
+             *   // * on success, to: <artifacts-location>/✓ Menu items should have Logout/myElements.viewhierarchy
+             *   // * on failure, to: <artifacts-location>/✗ Menu items should have Logout/myElements.viewhierarchy
+             * });
+             */
+            captureViewHierarchy(name?: string): Promise<string>;
+
+            /**
+             * Simulate shake (iOS Only)
+             */
+            shake(): Promise<void>;
+
+            /**
+             * Toggles device enrollment in biometric auth (TouchID or FaceID) (iOS Only)
+             * @example await device.setBiometricEnrollment(true);
+             * @example await device.setBiometricEnrollment(false);
+             */
+            setBiometricEnrollment(enabled: boolean): Promise<void>;
+
+            /**
+             * Simulates the success of a face match via FaceID (iOS Only)
+             */
+            matchFace(): Promise<void>;
+
+            /**
+             * Simulates the failure of a face match via FaceID (iOS Only)
+             */
+            unmatchFace(): Promise<void>;
+
+            /**
+             * Simulates the success of a finger match via TouchID (iOS Only)
+             */
+            matchFinger(): Promise<void>;
+
+            /**
+             * Simulates the failure of a finger match via TouchID (iOS Only)
+             */
+            unmatchFinger(): Promise<void>;
+
+            /**
+             * Clears the simulator keychain (iOS Only)
+             */
+            clearKeychain(): Promise<void>;
+
+            /**
+             * Simulate press back button (Android Only)
+             * @example await device.pressBack();
+             */
+            pressBack(): Promise<void>;
+
+            /**
+             * (Android Only)
+             * Exposes UiAutomator's UiDevice API (https://developer.android.com/reference/android/support/test/uiautomator/UiDevice).
+             * This is not a part of the official Detox API,
+             * it may break and change whenever an update to UiDevice or UiAutomator gradle dependencies ('androidx.test.uiautomator:uiautomator') is introduced.
+             * UIDevice's autogenerated code reference: https://github.com/wix/Detox/blob/master/detox/src/android/espressoapi/UIDevice.js
+             */
+            getUiDevice(): Promise<void>;
+
+            /**
+             * (Android Only)
+             * Runs `adb reverse tcp:PORT tcp:PORT` for the current device
+             * to enable network requests forwarding on localhost:PORT (computer<->device).
+             * For more information, see {@link https://www.reddit.com/r/reactnative/comments/5etpqw/what_do_you_call_what_adb_reverse_is_doing|here}.
+             * This is a no-op when running on iOS.
+             */
+            reverseTcpPort(port: number): Promise<void>;
+
+            /**
+             * (Android Only)
+             * Runs `adb reverse --remove tcp:PORT tcp:PORT` for the current device
+             * to disable network requests forwarding on localhost:PORT (computer<->device).
+             * For more information, see {@link https://www.reddit.com/r/reactnative/comments/5etpqw/what_do_you_call_what_adb_reverse_is_doing|here}.
+             * This is a no-op when running on iOS.
+             */
+            unreverseTcpPort(port: number): Promise<void>;
+        }
+
+        /**
+         * @deprecated
+         */
+        type DetoxAny = NativeElement & WaitFor;
+
+        interface ElementFacade {
+            (by: NativeMatcher): IndexableNativeElement;
+        }
+
+        interface IndexableNativeElement extends NativeElement {
+            /**
+             * Choose from multiple elements matching the same matcher using index
+             * @example await element(by.text('Product')).atIndex(2).tap();
+             */
+            atIndex(index: number): NativeElement;
+        }
+
+        interface NativeElement extends NativeElementActions {
+        }
+
+        interface ByFacade {
+            /**
+             * by.id will match an id that is given to the view via testID prop.
+             * @example
+             * // In a React Native component add testID like so:
+             * <TouchableOpacity testID={'tap_me'}>
+             * // Then match with by.id:
+             * await element(by.id('tap_me'));
+             * await element(by.id(/^tap_[a-z]+$/));
+             */
+            id(id: string | RegExp): NativeMatcher;
+
+            /**
+             * Find an element by text, useful for text fields, buttons.
+             * @example
+             * await element(by.text('Tap Me'));
+             * await element(by.text(/^Tap .*$/));
+             */
+            text(text: string | RegExp): NativeMatcher;
+
+            /**
+             * Find an element by accessibilityLabel on iOS, or by contentDescription on Android.
+             * @example
+             * await element(by.label('Welcome'));
+             * await element(by.label(/[a-z]+/i));
+             */
+            label(label: string | RegExp): NativeMatcher;
+
+            /**
+             * Find an element by native view type.
+             * @example await element(by.type('RCTImageView'));
+             */
+            type(nativeViewType: string): NativeMatcher;
+
+            /**
+             * Find an element with an accessibility trait. (iOS only)
+             * @example await element(by.traits(['button']));
+             */
+            traits(traits: string[]): NativeMatcher;
+
+            /**
+             * Collection of web matchers
+             */
+            readonly web: ByWebFacade;
+        }
+
+        interface ByWebFacade {
+            /**
+             * Find an element on the DOM tree by its id
+             * @param id
+             * @example
+             * web.element(by.web.id('testingh1'))
+             */
+            id(id: string): WebMatcher;
+
+            /**
+             * Find an element on the DOM tree by its CSS class
+             * @param className
+             * @example
+             * web.element(by.web.className('a'))
+             */
+            className(className: string): WebMatcher;
+
+            /**
+             * Find an element on the DOM tree matching the given CSS selector
+             * @param cssSelector
+             * @example
+             * web.element(by.web.cssSelector('#cssSelector'))
+             */
+            cssSelector(cssSelector: string): WebMatcher;
+
+            /**
+             * Find an element on the DOM tree by its "name" attribute
+             * @param name
+             * @example
+             * web.element(by.web.name('sec_input'))
+             */
+            name(name: string): WebMatcher;
+
+            /**
+             * Find an element on the DOM tree by its XPath
+             * @param xpath
+             * @example
+             * web.element(by.web.xpath('//*[@id="testingh1-1"]'))
+             */
+            xpath(xpath: string): WebMatcher;
+
+            /**
+             * Find an <a> element on the DOM tree by its link text (href content)
+             * @param linkText
+             * @example
+             * web.element(by.web.href('disney.com'))
+             */
+            href(linkText: string): WebMatcher;
+
+            /**
+             * Find an <a> element on the DOM tree by its partial link text (href content)
+             * @param linkTextFragment
+             * @example
+             * web.element(by.web.hrefContains('disney'))
+             */
+            hrefContains(linkTextFragment: string): WebMatcher;
+
+            /**
+             * Find an element on the DOM tree by its tag name
+             * @param tag
+             * @example
+             * web.element(by.web.tag('mark'))
+             */
+            tag(tagName: string): WebMatcher;
+        }
+
+        interface NativeMatcher {
+            /**
+             * Find an element satisfying all the matchers
+             * @example await element(by.text('Product').and(by.id('product_name'));
+             */
+            and(by: NativeMatcher): NativeMatcher;
+
+            /**
+             * Find an element by a matcher with a parent matcher
+             * @example await element(by.id('Grandson883').withAncestor(by.id('Son883')));
+             */
+            withAncestor(parentBy: NativeMatcher): NativeMatcher;
+
+            /**
+             * Find an element by a matcher with a child matcher
+             * @example await element(by.id('Son883').withDescendant(by.id('Grandson883')));
+             */
+            withDescendant(childBy: NativeMatcher): NativeMatcher;
+        }
+
+        interface WebMatcher {
+            __web__: any; // prevent type coersion
+        }
+
+        interface ExpectFacade {
+            (element: NativeElement): Expect;
+
+            (webElement: WebElement): WebExpect;
+        }
+
+        interface WebViewElement {
+            element(webMatcher: WebMatcher): IndexableWebElement;
+        }
+
+        interface WebFacade extends WebViewElement {
+            /**
+             * Gets the webview element as a testing element.
+             * @param matcher a simple view matcher for the webview element in th UI hierarchy.
+             * If there is only ONE webview element in the UI hierarchy, its NOT a must to supply it.
+             * If there are MORE then one webview element in the UI hierarchy you MUST supply are view matcher.
+             */
+            (matcher?: NativeMatcher): WebViewElement;
+        }
+
+        interface Expect<R = Promise<void>> {
+
+            /**
+             * Expect the view to be at least N% visible. If no number is provided then defaults to 75%. Negating this
+             * expectation with a `not` expects the view's visible area to be smaller than N%.
+             * @param pct optional integer ranging from 1 to 100, indicating how much percent of the view should be
+             *  visible to the user to be accepted.
+             * @example await expect(element(by.id('mainTitle'))).toBeVisible(35);
+             */
+            toBeVisible(pct?: number): R;
+
+            /**
+             * Negate the expectation.
+             * @example await expect(element(by.id('cancelButton'))).not.toBeVisible();
+             */
+            not: this;
+
+            /**
+             * Expect the view to not be visible.
+             * @example await expect(element(by.id('cancelButton'))).toBeNotVisible();
+             * @deprecated Use `.not.toBeVisible()` instead.
+             */
+            toBeNotVisible(): R;
+
+            /**
+             * Expect the view to exist in the UI hierarchy.
+             * @example await expect(element(by.id('okButton'))).toExist();
+             */
+            toExist(): R;
+
+            /**
+             * Expect the view to not exist in the UI hierarchy.
+             * @example await expect(element(by.id('cancelButton'))).toNotExist();
+             * @deprecated Use `.not.toExist()` instead.
+             */
+            toNotExist(): R;
+
+            /**
+             * Expect the view to be focused.
+             * @example await expect(element(by.id('emailInput'))).toBeFocused();
+             */
+            toBeFocused(): R;
+
+            /**
+             * Expect the view not to be focused.
+             * @example await expect(element(by.id('passwordInput'))).toBeNotFocused();
+             * @deprecated Use `.not.toBeFocused()` instead.
+             */
+            toBeNotFocused(): R;
+
+            /**
+             * In React Native apps, expect UI component of type <Text> to have text.
+             * In native iOS apps, expect UI elements of type UIButton, UILabel, UITextField or UITextViewIn to have inputText with text.
+             * @example await expect(element(by.id('mainTitle'))).toHaveText('Welcome back!);
+             */
+            toHaveText(text: string): R;
+
+            /**
+             * Expects a specific accessibilityLabel, as specified via the `accessibilityLabel` prop in React Native.
+             * On the native side (in both React Native and pure-native apps), that is equivalent to `accessibilityLabel`
+             * on iOS and contentDescription on Android. Refer to Detox's documentation in order to learn about caveats
+             * with accessibility-labels in React Native apps.
+             * @example await expect(element(by.id('submitButton'))).toHaveLabel('Submit');
+             */
+            toHaveLabel(label: string): R;
+
+            /**
+             * In React Native apps, expect UI component to have testID with that id.
+             * In native iOS apps, expect UI element to have accessibilityIdentifier with that id.
+             * @example await expect(element(by.text('Submit'))).toHaveId('submitButton');
+             */
+            toHaveId(id: string): R;
+
+            /**
+             * Expects a toggle-able element (e.g. a Switch or a Check-Box) to be on/checked or off/unchecked.
+             * As a reference, in react-native, this is the equivalent switch component.
+             * @example await expect(element(by.id('switch'))).toHaveToggleValue(true);
+             */
+            toHaveToggleValue(value: boolean): R;
+
+            /**
+             * Expect components like a Switch to have a value ('0' for off, '1' for on).
+             * @example await expect(element(by.id('temperatureDial'))).toHaveValue('25');
+             */
+            toHaveValue(value: any): R;
+
+            /**
+             * Expect Slider to have a position (0 - 1).
+             * Can have an optional tolerance to take into account rounding issues on ios
+             * @example await expect(element(by.id('SliderId'))).toHavePosition(0.75);
+             * @example await expect(element(by.id('SliderId'))).toHavePosition(0.74, 0.1);
+             */
+            toHaveSliderPosition(position: number, tolerance?: number): Promise<void>;
+        }
+
+        interface WaitForFacade {
+            /**
+             * This API polls using the given expectation continuously until the expectation is met. Use manual synchronization with waitFor only as a last resort.
+             * NOTE: Every waitFor call must set a timeout using withTimeout(). Calling waitFor without setting a timeout will do nothing.
+             * @example await waitFor(element(by.id('bigButton'))).toExist().withTimeout(2000);
+             */
+            (element: NativeElement): Expect<WaitFor>;
+        }
+
+        interface WaitFor {
+            /**
+             * Waits for the condition to be met until the specified time (millis) have elapsed.
+             * @example await waitFor(element(by.id('bigButton'))).toExist().withTimeout(2000);
+             */
+            withTimeout(millis: number): Promise<void>;
+
+            /**
+             * Performs the action repeatedly on the element until an expectation is met
+             * @example await waitFor(element(by.text('Item #5'))).toBeVisible().whileElement(by.id('itemsList')).scroll(50, 'down');
+             */
+            whileElement(by: NativeMatcher): NativeElement & WaitFor;
+
+            // TODO: not sure about & WaitFor - check if we can chain whileElement multiple times
+        }
+
+        interface NativeElementActions {
+            /**
+             * Simulate tap on an element
+             * @param point relative coordinates to the matched element (the element size could changes on different devices or even when changing the device font size)
+             * @example await element(by.id('tappable')).tap();
+             * @example await element(by.id('tappable')).tap({ x:5, y:10 });
+             */
+            tap(point?: Point2D): Promise<void>;
+
+            /**
+             * Simulate long press on an element
+             * @param duration (iOS only) custom press duration time, in milliseconds. Optional (default is 1000ms).
+             * @example await element(by.id('tappable')).longPress();
+             */
+            longPress(duration?: number): Promise<void>;
+
+            /**
+             * Simulate long press on an element and then drag it to the position of the target element. (iOS Only)
+             * @example await element(by.id('draggable')).longPressAndDrag(2000, NaN, NaN, element(by.id('target')), NaN, NaN, 'fast', 0);
+             */
+            longPressAndDrag(duration: number, normalizedPositionX: number, normalizedPositionY: number, targetElement: NativeElement,
+                             normalizedTargetPositionX: number, normalizedTargetPositionY: number, speed: Speed, holdDuration: number): Promise<void>;
+
+            /**
+             * Simulate multiple taps on an element.
+             * @param times number of times to tap
+             * @example await element(by.id('tappable')).multiTap(3);
+             */
+            multiTap(times: number): Promise<void>;
+
+            /**
+             * Simulate tap at a specific point on an element.
+             * Note: The point coordinates are relative to the matched element and the element size could changes on different devices or even when changing the device font size.
+             * @example await element(by.id('tappable')).tapAtPoint({ x:5, y:10 });
+             * @deprecated Use `.tap()` instead.
+             */
+            tapAtPoint(point: Point2D): Promise<void>;
+
+            /**
+             * Use the builtin keyboard to type text into a text field.
+             * @example await element(by.id('textField')).typeText('passcode');
+             */
+            typeText(text: string): Promise<void>;
+
+            /**
+             * Paste text into a text field.
+             * @example await element(by.id('textField')).replaceText('passcode again');
+             */
+            replaceText(text: string): Promise<void>;
+
+            /**
+             * Clear text from a text field.
+             * @example await element(by.id('textField')).clearText();
+             */
+            clearText(): Promise<void>;
+
+            /**
+             * Taps the backspace key on the built-in keyboard.
+             * @example await element(by.id('textField')).tapBackspaceKey();
+             */
+            tapBackspaceKey(): Promise<void>;
+
+            /**
+             * Taps the return key on the built-in keyboard.
+             * @example await element(by.id('textField')).tapReturnKey();
+             */
+            tapReturnKey(): Promise<void>;
+
+            /**
+             * Scrolls a given amount of pixels in the provided direction, starting from the provided start positions.
+             * @param pixels - independent device pixels
+             * @param direction - left/right/up/down
+             * @param startPositionX - the X starting scroll position, in percentage; valid input: `[0.0, 1.0]`, `NaN`; default: `NaN`—choose the best value automatically
+             * @param startPositionY - the Y starting scroll position, in percentage; valid input: `[0.0, 1.0]`, `NaN`; default: `NaN`—choose the best value automatically
+             * @example await element(by.id('scrollView')).scroll(100, 'down', NaN, 0.85);
+             * @example await element(by.id('scrollView')).scroll(100, 'up');
+             */
+            scroll(
+                pixels: number,
+                direction: Direction,
+                startPositionX?: number,
+                startPositionY?: number
+            ): Promise<void>;
+
+            /**
+             * Scroll to index.
+             * @example await element(by.id('scrollView')).scrollToIndex(10);
+             */
+            scrollToIndex(
+                index: Number
+            ): Promise<void>;
+
+            /**
+             * Scroll to edge.
+             * @example await element(by.id('scrollView')).scrollTo('bottom');
+             * @example await element(by.id('scrollView')).scrollTo('top');
+             */
+            scrollTo(edge: Direction): Promise<void>;
+
+            /**
+             * Adjust slider to position.
+             * @example await element(by.id('slider')).adjustSliderToPosition(0.75);
+             */
+            adjustSliderToPosition(newPosition: number): Promise<void>;
+
+            /**
+             * Swipes in the provided direction at the provided speed, started from percentage.
+             * @param speed default: `fast`
+             * @param percentage screen percentage to swipe; valid input: `[0.0, 1.0]`
+             * @param optional normalizedStartingPointX X coordinate of swipe starting point, relative to the view width; valid input: `[0.0, 1.0]`
+             * @param normalizedStartingPointY Y coordinate of swipe starting point, relative to the view height; valid input: `[0.0, 1.0]`
+             * @example await element(by.id('scrollView')).swipe('down');
+             * @example await element(by.id('scrollView')).swipe('down', 'fast');
+             * @example await element(by.id('scrollView')).swipe('down', 'fast', 0.5);
+             * @example await element(by.id('scrollView')).swipe('down', 'fast', 0.5, 0.2);
+             * @example await element(by.id('scrollView')).swipe('down', 'fast', 0.5, 0.2, 0.5);
+             */
+            swipe(direction: Direction, speed?: Speed, percentage?: number, normalizedStartingPointX?: number, normalizedStartingPointY?: number): Promise<void>;
+
+            /**
+             * Sets a picker view’s column to the given value. This function supports both date pickers and general picker views. (iOS Only)
+             * Note: When working with date pickers, you should always set an explicit locale when launching your app in order to prevent flakiness from different date and time styles.
+             * See [here](https://wix.github.io/Detox/docs/api/device-object-api#9-launch-with-a-specific-language-ios-only) for more information.
+             *
+             * @param column number of datepicker column (starts from 0)
+             * @param value string value in set column (must be correct)
+             * @example
+             * await expect(element(by.type('UIPickerView'))).toBeVisible();
+             * await element(by.type('UIPickerView')).setColumnToValue(1,"6");
+             * await element(by.type('UIPickerView')).setColumnToValue(2,"34");
+             */
+            setColumnToValue(column: number, value: string): Promise<void>;
+
+            /**
+             * Sets the date of a date-picker according to the specified date-string and format.
+             * @param dateString Textual representation of a date (e.g. '2023/01/01'). Should be in coherence with the format specified by `dateFormat`.
+             * @param dateFormat Format of `dateString`: Generally either 'ISO8601' or an explicitly specified format (e.g. 'yyyy/MM/dd'); It should
+             *      follow the rules of NSDateFormatter for iOS and DateTimeFormatter for Android.
+             * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString
+             * @example
+             * await element(by.id('datePicker')).setDatePickerDate('2023-01-01T00:00:00Z', 'ISO8601');
+             * await element(by.id('datePicker')).setDatePickerDate(new Date().toISOString(), 'ISO8601');
+             * await element(by.id('datePicker')).setDatePickerDate('2023/01/01', 'yyyy/MM/dd');
+             */
+            setDatePickerDate(dateString: string, dateFormat: string): Promise<void>;
+
+            /**
+             * Triggers a given [accessibility action]{@link https://reactnative.dev/docs/accessibility#accessibility-actions}.
+             * @param actionName - name of the accessibility action
+             * @example await element(by.id('view')).performAccessibilityAction('activate');
+             */
+            performAccessibilityAction(actionName: string): Promise<void>
+
+            /**
+             * Pinches in the given direction with speed and angle. (iOS only)
+             * @param angle value in radiant, default is `0`
+             * @example
+             * await expect(element(by.id('PinchableScrollView'))).toBeVisible();
+             * await element(by.id('PinchableScrollView')).pinchWithAngle('outward', 'slow', 0);
+             * @deprecated Use `.pinch()` instead.
+             */
+            pinchWithAngle(direction: PinchDirection, speed: Speed, angle: number): Promise<void>;
+
+            /**
+             * Pinches with the given scale, speed, and angle. (iOS only)
+             * @param speed default is `fast`
+             * @param angle value in radiant, default is `0`
+             * @example
+             * await element(by.id('PinchableScrollView')).pinch(1.1);
+             * await element(by.id('PinchableScrollView')).pinch(2.0);
+             * await element(by.id('PinchableScrollView')).pinch(0.001);
+             */
+            pinch(scale: number, speed?: Speed, angle?: number): Promise<void>;
+
+            /**
+             * Takes a screenshot of the element and schedules putting it in the artifacts folder upon completion of the current test.
+             * For more information, see {@link https://wix.github.io/Detox/docs/api/screenshots#element-level-screenshots}
+             * @param {string} name for the screenshot artifact
+             * @returns {Promise<string>} a temporary path to the screenshot.
+             * @example
+             * test('Menu items should have logout', async () => {
+             *   const imagePath = await element(by.id('menuRoot')).takeScreenshot('tap on menu');
+             *   // The temporary path will remain valid until the test completion.
+             *   // Afterwards, the screenshot will be moved, e.g.:
+             *   // * on success, to: <artifacts-location>/✓ Menu items should have Logout/tap on menu.png
+             *   // * on failure, to: <artifacts-location>/✗ Menu items should have Logout/tap on menu.png
+             * });
+             */
+            takeScreenshot(name: string): Promise<string>;
+
+            /**
+             * Retrieves the OS-dependent attributes of an element.
+             * If there are multiple matches, it returns an array of attributes for all matched elements.
+             * For detailed information, refer to {@link https://wix.github.io/Detox/docs/api/actions-on-element/#getattributes}
+             *
+             * @example
+             * test('Get the attributes for my text element', async () => {
+             *    const attributes = await element(by.id('myText')).getAttributes()
+             *    const jestExpect = require('expect');
+             *    // 'visible' attribute available on both iOS and Android
+             *    jestExpect(attributes.visible).toBe(true);
+             *    // 'activationPoint' attribute available on iOS only
+             *    jestExpect(attributes.activationPoint.x).toHaveValue(50);
+             *    // 'width' attribute available on Android only
+             *    jestExpect(attributes.width).toHaveValue(100);
+             * })
+             */
+            getAttributes(): Promise<IosElementAttributes | AndroidElementAttributes | { elements: IosElementAttributes[] } | { elements: AndroidElementAttributes[] } >;
+        }
+
+        interface WebExpect<R = Promise<void>> {
+            /**
+             * Negate the expectation.
+             * @example await expect(web.element(by.web.id('sessionTimeout'))).not.toExist();
+             */
+            not: this;
+
+            /**
+             * Expect the element content to have the `text` supplied
+             * @param text expected to be on the element content
+             * @example
+             * await expect(web.element(by.web.id('checkoutButton'))).toHaveText('Proceed to check out');
+             */
+            toHaveText(text: string): R;
+
+            /**
+             * Expect the view to exist in the webview DOM tree.
+             * @example await expect(web.element(by.web.id('submitButton'))).toExist();
+             */
+            toExist(): R;
+        }
+
+        interface IndexableWebElement extends WebElement {
+            /**
+             * Choose from multiple elements matching the same matcher using index
+             * @example await web.element(by.web.hrefContains('Details')).atIndex(2).tap();
+             */
+            atIndex(index: number): WebElement;
+        }
+
+        interface WebElement extends WebElementActions {
+        }
+
+        interface WebElementActions {
+            tap(): Promise<void>;
+
+            /**
+             * @param text to type
+             * @param isContentEditable whether its a ContentEditable element, default is false.
+             */
+            typeText(text: string, isContentEditable: boolean): Promise<void>;
+
+            /**
+             * At the moment not working on content-editable
+             * @param text to replace with the old content.
+             */
+            replaceText(text: string): Promise<void>;
+
+            /**
+             * At the moment not working on content-editable
+             */
+            clearText(): Promise<void>;
+
+            /**
+             * scrolling to the view, the element top position will be at the top of the screen.
+             */
+            scrollToView(): Promise<void>;
+
+            /**
+             * Gets the input content
+             */
+            getText(): Promise<string>;
+
+            /**
+             * Calls the focus function on the element
+             */
+            focus(): Promise<void>;
+
+            /**
+             * Selects all the input content, works on ContentEditable at the moment.
+             */
+            selectAllText(): Promise<void>;
+
+            /**
+             * Moves the input cursor / caret to the end of the content, works on ContentEditable at the moment.
+             */
+            moveCursorToEnd(): Promise<void>;
+
+            /**
+             * Running a JavaScript function on the element.
+             * The first argument to the function will be the element itself.
+             * The rest of the arguments will be forwarded to the JavaScript function as is.
+             *
+             * @param script a callback function in stringified form, or a plain function reference
+             * without closures, bindings etc. that will be converted to a string.
+             * @param args optional args to pass to the script
+             *
+             * @example
+             * await webElement.runScript('(el) => el.click()');
+             * await webElement.runScript(function setText(element, text) {
+             *   element.textContent = text;
+             * }, ['Custom Title']);
+             */
+            runScript(script: string, args?: unknown[]): Promise<any>;
+            runScript<F>(script: (...args: any[]) => F, args?: unknown[]): Promise<F>;
+
+            /**
+             * Gets the current page url
+             */
+            getCurrentUrl(): Promise<string>;
+
+            /**
+             * Gets the current page title
+             */
+            getTitle(): Promise<string>;
+        }
+
+        type Direction = 'left' | 'right' | 'top' | 'bottom' | 'up' | 'down';
+
+        type PinchDirection = 'outward' | 'inward'
+
+        type Orientation = 'portrait' | 'landscape';
+
+        type Speed = 'fast' | 'slow';
+
+        interface LanguageAndLocale {
+            language?: string;
+            locale?: string;
+        }
+
+        /**
+         *  Source for string definitions is https://github.com/wix/AppleSimulatorUtils
+         */
+        interface DevicePermissions {
+            location?: LocationPermission;
+            notifications?: NotificationsPermission;
+            calendar?: CalendarPermission;
+            camera?: CameraPermission;
+            contacts?: ContactsPermission;
+            health?: HealthPermission;
+            homekit?: HomekitPermission;
+            medialibrary?: MediaLibraryPermission;
+            microphone?: MicrophonePermission;
+            motion?: MotionPermission;
+            photos?: PhotosPermission;
+            reminders?: RemindersPermission;
+            siri?: SiriPermission;
+            speech?: SpeechPermission;
+            faceid?: FaceIDPermission;
+            userTracking?: UserTrackingPermission;
+        }
+
+        type LocationPermission = 'always' | 'inuse' | 'never' | 'unset';
+        type PermissionState = 'YES' | 'NO' | 'unset';
+        type CameraPermission = PermissionState;
+        type ContactsPermission = PermissionState;
+        type CalendarPermission = PermissionState;
+        type HealthPermission = PermissionState;
+        type HomekitPermission = PermissionState;
+        type MediaLibraryPermission = PermissionState;
+        type MicrophonePermission = PermissionState;
+        type MotionPermission = PermissionState;
+        type PhotosPermission = PermissionState;
+        type RemindersPermission = PermissionState;
+        type SiriPermission = PermissionState;
+        type SpeechPermission = PermissionState;
+        type NotificationsPermission = PermissionState;
+        type FaceIDPermission = PermissionState;
+        type UserTrackingPermission = PermissionState;
+
+        interface DeviceLaunchAppConfig {
+            /**
+             * Restart the app
+             * Terminate the app and launch it again. If set to false, the simulator will try to bring app from background, if the app isn't running, it will launch a new instance. default is false
+             */
+            newInstance?: boolean;
+            /**
+             * Set runtime permissions
+             * Grant or deny runtime permissions for your application.
+             */
+            permissions?: DevicePermissions;
+            /**
+             * Launch from URL
+             * Mock opening the app from URL to test your app's deep link handling mechanism.
+             */
+            url?: any;
+            /**
+             * Launch with user notifications
+             */
+            userNotification?: any;
+            /**
+             * Launch with user activity
+             */
+            userActivity?: any;
+            /**
+             * Launch into a fresh installation
+             * A flag that enables relaunching into a fresh installation of the app (it will uninstall and install the binary again), default is false.
+             */
+            delete?: boolean;
+            /**
+             * Arguments to pass-through into the app.
+             * Refer to the [dedicated guide](https://wix.github.io/Detox/docs/api/launch-args) for complete details.
+             */
+            launchArgs?: Record<string, any>;
+            /**
+             * Launch config for specifying the native language and locale
+             */
+            languageAndLocale?: LanguageAndLocale;
+        }
+
+        // Element Attributes Shared Among iOS and Android
+        interface ElementAttributes {
+            /**
+             * Whether or not the element is enabled for user interaction.
+             */
+            enabled: boolean;
+            /**
+             * The identifier of the element. Matches accessibilityIdentifier on iOS, and the main view tag, on Android - both commonly holding the component's test ID in React Native apps.
+             */
+            identifier: string;
+            /**
+             * Whether the element is visible. On iOS, visibility is calculated for the activation point. On Android, the attribute directly holds the value returned by View.getLocalVisibleRect()).
+             */
+            visible: boolean;
+            /**
+             * The text value of any textual element.
+             */
+            text?: string;
+            /**
+             * The label of the element. Largely matches accessibilityLabel for ios, and contentDescription for android.
+             * Refer to Detox's documentation (`toHaveLabel()` subsection) in order to learn about caveats associated with
+             * this property in React Native apps.
+             */
+            label?: string;
+            /**
+             * The placeholder text value of the element. Matches hint on android.
+             */
+            placeholder?: string;
+            /**
+             * The value of the element, where applicable.
+             * Matches accessibilityValue, on iOS.
+             * For example: the position of a slider, or whether a checkbox has been marked (Android).
+             */
+            value?: unknown;
+        }
+
+        interface IosElementAttributeFrame {
+            y: number;
+            x: number;
+            width: number;
+            height: number;
+        }
+
+        interface IosElementAttributeInsets {
+            right: number;
+            top: number;
+            left: number;
+            bottom: number;
+        }
+
+        // iOS Specific Attributes
+        interface IosElementAttributes extends ElementAttributes {
+            /**
+             * The [activation point]{@link https://developer.apple.com/documentation/objectivec/nsobject/1615179-accessibilityactivationpoint} of the element, in element coordinate space.
+             */
+            activationPoint: Point2D;
+            /**
+             * The activation point of the element, in normalized percentage ([0.0, 1.0]).
+             */
+            normalizedActivationPoint: Point2D;
+            /**
+             * Whether the element is hittable at the activation point.
+             */
+            hittable: boolean;
+            /**
+             * The frame of the element, in screen coordinate space.
+             */
+            frame: IosElementAttributeFrame;
+            /**
+             * The frame of the element, in container coordinate space.
+             */
+            elementFrame: IosElementAttributeFrame;
+            /**
+             * The bounds of the element, in element coordinate space.
+             */
+            elementBounds: IosElementAttributeFrame;
+            /**
+             * The safe area insets of the element, in element coordinate space.
+             */
+            safeAreaInsets: IosElementAttributeInsets;
+            /**
+             * The safe area bounds of the element, in element coordinate space.
+             */
+            elementSafeBounds: IosElementAttributeFrame;
+            /**
+             * The date of the element (if it is a date picker).
+             */
+            date?: string;
+            /**
+             * The normalized slider position (if it is a slider).
+             */
+            normalizedSliderPosition?: number;
+            /**
+             * The content offset (if it is a scroll view).
+             */
+            contentOffset?: Point2D;
+            /**
+             * The content inset (if it is a scroll view).
+             */
+            contentInset?: IosElementAttributeInsets;
+            /**
+             * The adjusted content inset (if it is a scroll view).
+             */
+            adjustedContentInset?: IosElementAttributeInsets;
+            /**
+             * @example "<CALayer: 0x600003f759e0>"
+             */
+            layer: string;
+        }
+
+        // Android Specific Attributes
+        interface AndroidElementAttributes extends ElementAttributes {
+            /**
+             * The OS visibility type associated with the element: visible, invisible or gone.
+             */
+            visibility: 'visible' | 'invisible' | 'gone';
+            /**
+             * Width of the element, in pixels.
+             */
+            width: number;
+            /**
+             * Height of the element, in pixels.
+             */
+            height: number;
+            /**
+             * Elevation of the element.
+             */
+            elevation: number;
+            /**
+             * Alpha value for the element.
+             */
+            alpha: number;
+            /**
+             * Whether the element is the one currently in focus.
+             */
+            focused: boolean;
+            /**
+             * The text size for the text element.
+             */
+            textSize?: number;
+            /**
+             * The length of the text element (character count).
+             */
+            length?: number;
+        }
+    }
+}
+
+export = Detox;