npm - detox - Versions diffs - 21.0.0-rc.5 → 21.0.0-rc.7 - Mend

detox 21.0.0-rc.5 → 21.0.0-rc.7

Files changed (186) hide show

package/index.d.ts CHANGED Viewed

@@ -1,1826 +1,5 @@
-// 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 {
-    const detox: Detox.DetoxExportWrapper;
-    const device: Detox.DetoxExportWrapper['device'];
-    const element: Detox.DetoxExportWrapper['element'];
-    const waitFor: Detox.DetoxExportWrapper['waitFor'];
-    const expect: Detox.DetoxExportWrapper['expect'];
-    const by: Detox.DetoxExportWrapper['by'];
-    const web: Detox.DetoxExportWrapper['web'];
-    namespace NodeJS {
-        interface Global {
-            detox: Detox.DetoxExportWrapper;
-            device: Detox.DetoxExportWrapper['device'];
-            element: Detox.DetoxExportWrapper['element'];
-            waitFor: Detox.DetoxExportWrapper['waitFor'];
-            expect: Detox.DetoxExportWrapper['expect'];
-            by: Detox.DetoxExportWrapper['by'];
-            web: Detox.DetoxExportWrapper['web'];
-        }
-    }
-    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;
-        }
-        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>;
-            /**
-             * 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 {
-            /**
-             * (Android Only)
-             * Find an element on the DOM tree by its id
-             * @param id
-             * @example
-             * web.element(by.web.id('testingh1'))
-             */
-            id(id: string): WebMatcher;
-            /**
-             * (Android Only)
-             * Find an element on the DOM tree by its CSS class
-             * @param className
-             * @example
-             * web.element(by.web.className('a'))
-             */
-            className(className: string): WebMatcher;
-            /**
-             * (Android Only)
-             * 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;
-            /**
-             * (Android Only)
-             * 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;
-            /**
-             * (Android Only)
-             * 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;
-            /**
-             * (Android Only)
-             * 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;
-            /**
-             * (Android Only)
-             * 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;
-            /**
-             * (Android Only)
-             * Find an element on the DOM tree by its tag name
-             * @param tag
-             * @example
-             * web.element(by.web.tag('mark'))
-             */
-            tag(tagName: string): WebMatcher;
-            /**
-             * (iOS Only)
-             * Find an element on the web-view by its text content
-             * @param label
-             * @example
-             * web.element(by.web.label('Welcome'))
-             */
-            label(label: string): WebMatcher;
-            /**
-             * (iOS Only)
-             * Find an element on the web-view by its content description
-             * @param value
-             * @example
-             * web.element(by.web.value('Write a comment...'))
-             */
-            value(value: 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>;
-            /**
-             * Gets the native (OS-dependent) attributes of the element.
-             * For more information, see {@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[]; }>;
-        }
-        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 {
-            /**
-             * Taps the element
-             */
-            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 script on the element
-             * @param script a method that accept the element as its first arg
-             * @example function foo(element) { console.log(element); }
-             */
-            runScript(script: string): Promise<any>;
-            /**
-             * Running a script on the element that accept args
-             * @param script a method that accept few args, and the element as the last arg.
-             * @param args a list of args to pass to the script
-             * @example function foo(a, b, c, element) { console.log(`${a}, ${b}, ${c}, ${element}`)}
-             */
-            runScriptWithArgs(script: string, args: any[]): Promise<any>;
-            /**
-             * 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;
-        }
-    }
-}
+/// <reference path="detox.d.ts" />
+/// <reference path="globals.d.ts" />
 declare const detox: Detox.DetoxExportWrapper;
 export = detox;