xdl

  • Version 60.0.12
  • Published
  • 9.43 MB
  • 63 dependencies
  • MIT license

Install

npm i xdl
yarn add xdl
pnpm add xdl

Overview

The Expo Development Library

Index

Variables

Functions

Classes

Type Aliases

Namespaces

Variables

variable Analytics

const Analytics: AnalyticsClient;

    variable Config

    const Config: XDLConfig;

      variable LoadingEvent

      const LoadingEvent: {
      START_LOADING: string;
      STOP_LOADING: string;
      START_PROGRESS_BAR: string;
      TICK_PROGRESS_BAR: string;
      STOP_PROGRESS_BAR: string;
      };

        variable Logger

        const Logger: {
        child: (options: object) => bunyan;
        notifications: bunyan;
        global: bunyan;
        DEBUG: number;
        INFO: number;
        WARN: number;
        ERROR: number;
        };

          variable UnifiedAnalytics

          const UnifiedAnalytics: AnalyticsClient;

            variable UserManager

            const UserManager: UserManagerInstance;

              variable UserSettings

              const UserSettings: any;

                Functions

                function isDevClientPackageInstalled

                isDevClientPackageInstalled: (projectRoot: string) => boolean;

                  function printBundleSizes

                  printBundleSizes: (bundles: {
                  android?: BundleOutput;
                  ios?: BundleOutput;
                  }) => void;

                    Classes

                    class ApiV2

                    class ApiV2Client {}

                      constructor

                      constructor(options?: APIV2ClientOptions);

                        property accessToken

                        accessToken: string;

                          property exponentClient

                          static exponentClient: string;

                            property sessionSecret

                            sessionSecret: string;

                              method clientForUser

                              static clientForUser: (user?: APIV2ClientOptions | null) => ApiV2Client;

                                method deleteAsync

                                deleteAsync: (
                                methodName: string,
                                args?: ParsedUrlQueryInput,
                                extraOptions?: Partial<RequestOptions>,
                                returnEntireResponse?: boolean
                                ) => Promise<any>;

                                  method getAsync

                                  getAsync: (
                                  methodName: string,
                                  args?: ParsedUrlQueryInput,
                                  extraOptions?: Partial<RequestOptions>,
                                  returnEntireResponse?: boolean
                                  ) => Promise<any>;

                                    method patchAsync

                                    patchAsync: (
                                    methodName: string,
                                    data: JSONObject,
                                    extraOptions?: Partial<RequestOptions>,
                                    returnEntireResponse?: boolean
                                    ) => Promise<any>;

                                      method postAsync

                                      postAsync: (
                                      methodName: string,
                                      data?: JSONObject,
                                      extraOptions?: Partial<RequestOptions>,
                                      returnEntireResponse?: boolean
                                      ) => Promise<any>;

                                        method putAsync

                                        putAsync: (
                                        methodName: string,
                                        data: JSONObject,
                                        extraOptions?: Partial<RequestOptions>,
                                        returnEntireResponse?: boolean
                                        ) => Promise<any>;

                                          method setClientName

                                          static setClientName: (name: string) => void;

                                            method uploadFormDataAsync

                                            uploadFormDataAsync: (methodName: string, formData: FormData) => Promise<any>;

                                              class PackagerLogsStream

                                              class PackagerLogsStream {}

                                                constructor

                                                constructor({
                                                projectRoot,
                                                getCurrentOpenProjectId,
                                                updateLogs,
                                                onStartBuildBundle,
                                                onProgressBuildBundle,
                                                onFinishBuildBundle,
                                                getSnippetForError,
                                                }: {
                                                projectRoot: string;
                                                getCurrentOpenProjectId?: () => any;
                                                updateLogs: (updater: LogUpdater) => void;
                                                onStartBuildBundle?: StartBuildBundleCallback;
                                                onProgressBuildBundle?: ProgressBuildBundleCallback;
                                                onFinishBuildBundle?: FinishBuildBundleCallback;
                                                getSnippetForError?: (error: MetroError) => string | null;
                                                });

                                                  property bundleDetailsCache

                                                  bundleDetailsCache: Record<string, BundleDetails>;

                                                    property projectId

                                                    projectId?: number;

                                                      method getPlatformTagForBuildDetails

                                                      static getPlatformTagForBuildDetails: (
                                                      bundleDetails?: BundleDetails | null
                                                      ) => string;

                                                        class XDLError

                                                        class XDLError extends Error {}

                                                          constructor

                                                          constructor(code: ErrorCode, message: string);

                                                            property code

                                                            code: string;

                                                              property isXDLError

                                                              isXDLError: boolean;

                                                                property name

                                                                readonly name: string;

                                                                  Type Aliases

                                                                  type ErrorCode

                                                                  type ErrorCode =
                                                                  | 'INVALID_USERNAME_PASSWORD'
                                                                  | 'TOO_MANY_ATTEMPTS'
                                                                  | 'REGISTRATION_ERROR'
                                                                  | 'LEGACY_ACCOUNT_ERROR'
                                                                  | 'ROBOT_ACCOUNT_ERROR'
                                                                  | 'USER_ACCOUNT_ERROR'
                                                                  | 'DIRECTORY_ALREADY_EXISTS'
                                                                  | 'HOOK_INITIALIZATION_ERROR'
                                                                  | 'INVALID_ARGUMENT'
                                                                  | 'INVALID_ASSETS'
                                                                  | 'INVALID_BUNDLE'
                                                                  | 'INVALID_JSON'
                                                                  | 'INVALID_MANIFEST'
                                                                  | 'INVALID_OPTIONS'
                                                                  | 'INVALID_VERSION'
                                                                  | 'NGROK_ERROR'
                                                                  | 'NO_EXPO_SERVER_PORT'
                                                                  | 'NO_PACKAGE_JSON'
                                                                  | 'NO_PACKAGER_PORT'
                                                                  | 'NO_PORT_FOUND'
                                                                  | 'NO_PROJECT_ROOT'
                                                                  | 'NO_SDK_VERSION'
                                                                  | 'NOT_LOGGED_IN'
                                                                  | 'PLATFORM_NOT_SUPPORTED'
                                                                  | 'PUBLISH_VALIDATION_ERROR'
                                                                  | 'WONT_OVERWRITE_WITHOUT_FORCE'
                                                                  | 'XCODE_LICENSE_NOT_ACCEPTED'
                                                                  | 'APP_NOT_INSTALLED'
                                                                  | 'SIMCTL_NOT_AVAILABLE'
                                                                  | 'WEB_NOT_CONFIGURED'
                                                                  | 'WEBPACK_BUNDLE'
                                                                  | 'WEBPACK_DEPRECATED'
                                                                  | 'WEBPACK_INVALID_OPTION'
                                                                  | 'NETWORK_REQUIRED'
                                                                  | 'ROBOT_OWNER_ERROR'
                                                                  | 'CREDENTIAL_ERROR'
                                                                  | 'NO_DEV_CLIENT_SCHEME';

                                                                    type LogRecord

                                                                    type LogRecord = (MetroLogRecord | ExpoLogRecord | DeviceLogRecord) &
                                                                    ProjectUtils.LogFields;

                                                                      type LogUpdater

                                                                      type LogUpdater = (logState: LogRecord[]) => LogRecord[];

                                                                        type RobotUser

                                                                        type RobotUser = {
                                                                        kind: 'robot';
                                                                        userId: string;
                                                                        username: string;
                                                                        givenName?: string;
                                                                        currentConnection: ConnectionType;
                                                                        sessionSecret?: never;
                                                                        accessToken?: string;
                                                                        };

                                                                          type User

                                                                          type User = {
                                                                          kind: 'user';
                                                                          username: string;
                                                                          nickname: string;
                                                                          userId: string;
                                                                          picture: string;
                                                                          email?: string;
                                                                          emailVerified?: boolean;
                                                                          givenName?: string;
                                                                          familyName?: string;
                                                                          userMetadata: {
                                                                          onboarded: boolean;
                                                                          legacy?: boolean;
                                                                          };
                                                                          currentConnection: ConnectionType;
                                                                          sessionSecret?: string;
                                                                          accessToken?: string;
                                                                          };

                                                                            Namespaces

                                                                            namespace Android

                                                                            module 'build/Android.d.ts' {}
                                                                            • Parameter device

                                                                              Android device to open on

                                                                              Parameter

                                                                              props.launchActivity Activity to launch [application identifier]/.[main activity name], ex: com.bacon.app/.MainActivity

                                                                            function activateEmulatorWindowAsync

                                                                            activateEmulatorWindowAsync: (
                                                                            device: Pick<Device, 'type' | 'pid'>
                                                                            ) => Promise<void>;

                                                                              function attemptToStartEmulatorOrAssertAsync

                                                                              attemptToStartEmulatorOrAssertAsync: (device: Device) => Promise<Device | null>;

                                                                                function checkSplashScreenImages

                                                                                checkSplashScreenImages: (projectRoot: string) => Promise<void>;
                                                                                • Checks whether resizeMode is set to native and if true analyzes provided images for splashscreen providing Logger feedback upon problems.

                                                                                  Parameter projectRoot

                                                                                  directory of the expo project SDK33

                                                                                function getAdbFileOutputAsync

                                                                                getAdbFileOutputAsync: (
                                                                                args: string[],
                                                                                encoding?: 'latin1'
                                                                                ) => Promise<string | Buffer>;

                                                                                  function getAdbOutputAsync

                                                                                  getAdbOutputAsync: (args: string[]) => Promise<string>;

                                                                                    function getAllAvailableDevicesAsync

                                                                                    getAllAvailableDevicesAsync: () => Promise<Device[]>;

                                                                                      function getAttachedDevicesAsync

                                                                                      getAttachedDevicesAsync: () => Promise<Device[]>;

                                                                                        function getDeviceABIsAsync

                                                                                        getDeviceABIsAsync: (
                                                                                        device: Pick<Device, 'name' | 'pid'>
                                                                                        ) => Promise<DeviceABI[]>;

                                                                                          function getDeviceAPIVersionAsync

                                                                                          getDeviceAPIVersionAsync: (
                                                                                          device: Pick<Device, 'name' | 'pid'>
                                                                                          ) => Promise<number>;
                                                                                          • Returns

                                                                                            number like 30 (i.e. API 30)

                                                                                          function getDeviceSDKVersionAsync

                                                                                          getDeviceSDKVersionAsync: (
                                                                                          device: Pick<Device, 'name' | 'pid'>
                                                                                          ) => Promise<string>;
                                                                                          • Returns

                                                                                            string like '11' (i.e. Android 11)

                                                                                          function getPropertyForDeviceAsync

                                                                                          getPropertyForDeviceAsync: (
                                                                                          device: Pick<Device, 'name' | 'pid'>,
                                                                                          name: string,
                                                                                          shouldRefresh?: boolean
                                                                                          ) => Promise<string>;

                                                                                            function installExpoAsync

                                                                                            installExpoAsync: ({
                                                                                            device,
                                                                                            url,
                                                                                            version,
                                                                                            }: {
                                                                                            device: Device;
                                                                                            url?: string;
                                                                                            version?: string;
                                                                                            }) => Promise<string>;

                                                                                              function installOnDeviceAsync

                                                                                              installOnDeviceAsync: (
                                                                                              device: Pick<Device, 'pid'>,
                                                                                              { binaryPath }: { binaryPath: string }
                                                                                              ) => Promise<string>;

                                                                                                function isDeviceBootedAsync

                                                                                                isDeviceBootedAsync: ({ name }?: { name?: string }) => Promise<Device | null>;

                                                                                                  function isPlatformSupported

                                                                                                  isPlatformSupported: () => boolean;

                                                                                                    function maybeStopAdbDaemonAsync

                                                                                                    maybeStopAdbDaemonAsync: () => Promise<boolean>;

                                                                                                      function openAppAsync

                                                                                                      openAppAsync: (
                                                                                                      device: Pick<Device, 'pid' | 'type'>,
                                                                                                      { launchActivity }: { launchActivity: string }
                                                                                                      ) => Promise<string>;
                                                                                                      • Parameter device

                                                                                                        Android device to open on

                                                                                                        Parameter

                                                                                                        props.launchActivity Activity to launch [application identifier]/.[main activity name], ex: com.bacon.app/.MainActivity

                                                                                                      function openProjectAsync

                                                                                                      openProjectAsync: ({
                                                                                                      projectRoot,
                                                                                                      shouldPrompt,
                                                                                                      devClient,
                                                                                                      device,
                                                                                                      scheme,
                                                                                                      applicationId,
                                                                                                      launchActivity,
                                                                                                      }: {
                                                                                                      projectRoot: string;
                                                                                                      shouldPrompt?: boolean;
                                                                                                      devClient?: boolean;
                                                                                                      device?: Device;
                                                                                                      scheme?: string;
                                                                                                      applicationId?: string | null;
                                                                                                      launchActivity?: string;
                                                                                                      }) => Promise<
                                                                                                      { success: true; url: string } | { success: false; error: Error | string }
                                                                                                      >;

                                                                                                        function openWebProjectAsync

                                                                                                        openWebProjectAsync: ({
                                                                                                        projectRoot,
                                                                                                        shouldPrompt,
                                                                                                        }: {
                                                                                                        projectRoot: string;
                                                                                                        shouldPrompt?: boolean;
                                                                                                        }) => Promise<{ success: true; url: string } | { success: false; error: string }>;

                                                                                                          function parseAdbDeviceProperties

                                                                                                          parseAdbDeviceProperties: (devicePropertiesString: string) => DeviceProperties;

                                                                                                            function promptForDeviceAsync

                                                                                                            promptForDeviceAsync: (devices: Device[]) => Promise<Device | null>;

                                                                                                              function resolveApplicationIdAsync

                                                                                                              resolveApplicationIdAsync: (projectRoot: string) => Promise<string | null>;

                                                                                                                function startAdbReverseAsync

                                                                                                                startAdbReverseAsync: (projectRoot: string) => Promise<boolean>;

                                                                                                                  function stopAdbReverseAsync

                                                                                                                  stopAdbReverseAsync: (projectRoot: string) => Promise<void>;

                                                                                                                    function uninstallExpoAsync

                                                                                                                    uninstallExpoAsync: (device: Device) => Promise<string | undefined>;

                                                                                                                      function upgradeExpoAsync

                                                                                                                      upgradeExpoAsync: ({
                                                                                                                      url,
                                                                                                                      version,
                                                                                                                      device,
                                                                                                                      }?: {
                                                                                                                      url?: string;
                                                                                                                      version?: string;
                                                                                                                      device?: Device | null;
                                                                                                                      }) => Promise<boolean>;

                                                                                                                        enum DeviceABI

                                                                                                                        enum DeviceABI {
                                                                                                                        arm = 'arm',
                                                                                                                        arm64 = 'arm64',
                                                                                                                        x64 = 'x64',
                                                                                                                        x86 = 'x86',
                                                                                                                        armeabiV7a = 'armeabi-v7a',
                                                                                                                        armeabi = 'armeabi',
                                                                                                                        universal = 'universal',
                                                                                                                        }

                                                                                                                          member arm

                                                                                                                          arm = 'arm'

                                                                                                                            member arm64

                                                                                                                            arm64 = 'arm64'

                                                                                                                              member armeabi

                                                                                                                              armeabi = 'armeabi'

                                                                                                                                member armeabiV7a

                                                                                                                                armeabiV7a = 'armeabi-v7a'

                                                                                                                                  member universal

                                                                                                                                  universal = 'universal'

                                                                                                                                    member x64

                                                                                                                                    x64 = 'x64'

                                                                                                                                      member x86

                                                                                                                                      x86 = 'x86'

                                                                                                                                        type Device

                                                                                                                                        type Device = {
                                                                                                                                        pid?: string;
                                                                                                                                        name: string;
                                                                                                                                        type: 'emulator' | 'device';
                                                                                                                                        isBooted: boolean;
                                                                                                                                        isAuthorized: boolean;
                                                                                                                                        };

                                                                                                                                          namespace AndroidCredentials

                                                                                                                                          module 'build/credentials/AndroidCredentials.d.ts' {}

                                                                                                                                            function exportCertBase64

                                                                                                                                            exportCertBase64: (
                                                                                                                                            {
                                                                                                                                            keystorePath,
                                                                                                                                            keystorePassword,
                                                                                                                                            keyAlias,
                                                                                                                                            }: Pick<KeystoreInfo, 'keystorePath' | 'keystorePassword' | 'keyAlias'>,
                                                                                                                                            certFile: string
                                                                                                                                            ) => Promise<SpawnResult>;

                                                                                                                                              function generateUploadKeystore

                                                                                                                                              generateUploadKeystore: (
                                                                                                                                              uploadKeystorePath: string,
                                                                                                                                              androidPackage: string,
                                                                                                                                              experienceName: string
                                                                                                                                              ) => Promise<KeystoreInfo>;

                                                                                                                                                function logKeystoreHashes

                                                                                                                                                logKeystoreHashes: (
                                                                                                                                                keystoreInfo: KeystoreInfo,
                                                                                                                                                linePrefix?: string
                                                                                                                                                ) => Promise<void>;

                                                                                                                                                  type Keystore

                                                                                                                                                  type Keystore = {
                                                                                                                                                  keystore: string;
                                                                                                                                                  keystorePassword: string;
                                                                                                                                                  keyPassword: string;
                                                                                                                                                  keyAlias: string;
                                                                                                                                                  };

                                                                                                                                                    type KeystoreInfo

                                                                                                                                                    type KeystoreInfo = {
                                                                                                                                                    keystorePath: string;
                                                                                                                                                    keystorePassword: string;
                                                                                                                                                    keyPassword: string;
                                                                                                                                                    keyAlias: string;
                                                                                                                                                    };

                                                                                                                                                      namespace AppleDevice

                                                                                                                                                      module 'build/apple/AppleDevice.d.ts' {}

                                                                                                                                                        function getConnectedDevices

                                                                                                                                                        getConnectedDevices: () => Promise<DeviceValues[]>;

                                                                                                                                                          function isEnabled

                                                                                                                                                          isEnabled: () => boolean;

                                                                                                                                                            function runOnDevice

                                                                                                                                                            runOnDevice: ({
                                                                                                                                                            udid,
                                                                                                                                                            appPath,
                                                                                                                                                            bundleId,
                                                                                                                                                            waitForApp,
                                                                                                                                                            deltaPath,
                                                                                                                                                            onProgress,
                                                                                                                                                            }: {
                                                                                                                                                            udid: string;
                                                                                                                                                            appPath: string;
                                                                                                                                                            bundleId: string;
                                                                                                                                                            waitForApp: boolean;
                                                                                                                                                            deltaPath: string;
                                                                                                                                                            onProgress: OnInstallProgressCallback;
                                                                                                                                                            }) => Promise<void>;

                                                                                                                                                              namespace Binaries

                                                                                                                                                              module 'build/Binaries.d.ts' {}

                                                                                                                                                                variable OSX_SOURCE_PATH

                                                                                                                                                                const OSX_SOURCE_PATH: string;

                                                                                                                                                                  function addToPathAsync

                                                                                                                                                                  addToPathAsync: (name: string) => Promise<void>;

                                                                                                                                                                    function getBinariesPath

                                                                                                                                                                    getBinariesPath: () => string;

                                                                                                                                                                      function isXcodeInstalled

                                                                                                                                                                      isXcodeInstalled: () => boolean;

                                                                                                                                                                        function writePathToUserSettingsAsync

                                                                                                                                                                        writePathToUserSettingsAsync: () => Promise<void>;

                                                                                                                                                                          namespace ConnectionStatus

                                                                                                                                                                          module 'build/ConnectionStatus.d.ts' {}

                                                                                                                                                                            function isOffline

                                                                                                                                                                            isOffline: () => boolean;

                                                                                                                                                                              function setIsOffline

                                                                                                                                                                              setIsOffline: (bool: boolean) => void;

                                                                                                                                                                                namespace CoreSimulator

                                                                                                                                                                                module 'build/apple/CoreSimulator.d.ts' {}
                                                                                                                                                                                • Get UDID for the first booted simulator. It's unclear if this is the exact method used by xcrun simctl to determine which device is "booted".

                                                                                                                                                                                  Returns

                                                                                                                                                                                  EFEEA6EF-E3F5-4EDE-9B72-29EAFA7514AE

                                                                                                                                                                                function devicePlistToSimulatorDevice

                                                                                                                                                                                devicePlistToSimulatorDevice: (
                                                                                                                                                                                deviceDirectory: string,
                                                                                                                                                                                data: any
                                                                                                                                                                                ) => SimulatorDevice;

                                                                                                                                                                                  function getBootedDeviceAsync

                                                                                                                                                                                  getBootedDeviceAsync: () => Promise<{ UDID: string } | null>;
                                                                                                                                                                                  • Get UDID for the first booted simulator. It's unclear if this is the exact method used by xcrun simctl to determine which device is "booted".

                                                                                                                                                                                    Returns

                                                                                                                                                                                    EFEEA6EF-E3F5-4EDE-9B72-29EAFA7514AE

                                                                                                                                                                                  function getContainerPathAsync

                                                                                                                                                                                  getContainerPathAsync: ({
                                                                                                                                                                                  udid,
                                                                                                                                                                                  bundleIdentifier,
                                                                                                                                                                                  }: {
                                                                                                                                                                                  udid: string;
                                                                                                                                                                                  bundleIdentifier: string;
                                                                                                                                                                                  }) => Promise<string | null>;
                                                                                                                                                                                  • Returns the local path for the installed binary.app on a given Apple simulator. Returns null when the app isn't installed.

                                                                                                                                                                                    This can be used as a replacement for xcrun simctl get_app_container <udid> <bundleIdentifier> but it's over 200x faster.

                                                                                                                                                                                    Parameter

                                                                                                                                                                                    props.udid device udid.

                                                                                                                                                                                    Parameter

                                                                                                                                                                                    props.bundleIdentifier bundle identifier for app

                                                                                                                                                                                    Returns

                                                                                                                                                                                    local file path to installed app binary, e.g. '/Users/evanbacon/Library/Developer/CoreSimulator/Devices/EFEEA6EF-E3F5-4EDE-9B72-29EAFA7514AE/data/Containers/Bundle/Application/FA43A0C6-C2AD-442D-B8B1-EAF3E88CF3BF/Exponent-2.21.3.tar.app'

                                                                                                                                                                                  function getDeviceInfoAsync

                                                                                                                                                                                  getDeviceInfoAsync: ({ udid }?: { udid?: string }) => Promise<SimulatorDevice>;

                                                                                                                                                                                    function isEnabled

                                                                                                                                                                                    isEnabled: () => boolean;

                                                                                                                                                                                      function listDevicesAsync

                                                                                                                                                                                      listDevicesAsync: () => Promise<SimulatorDevice[]>;

                                                                                                                                                                                        class CoreSimulatorError

                                                                                                                                                                                        class CoreSimulatorError extends Error {}

                                                                                                                                                                                          constructor

                                                                                                                                                                                          constructor(message: string, code?: 'MALFORMED_BINARY' | 'INVALID_UDID');

                                                                                                                                                                                            property code

                                                                                                                                                                                            code?: 'MALFORMED_BINARY' | 'INVALID_UDID';

                                                                                                                                                                                              property message

                                                                                                                                                                                              message: string;

                                                                                                                                                                                                namespace Detach

                                                                                                                                                                                                module 'build/detach/Detach.d.ts' {}

                                                                                                                                                                                                  function bundleAssetsAsync

                                                                                                                                                                                                  bundleAssetsAsync: (projectDir: string, args: any) => Promise<void>;

                                                                                                                                                                                                    function prepareDetachedBuildAsync

                                                                                                                                                                                                    prepareDetachedBuildAsync: (projectDir: string, args: any) => Promise<void>;

                                                                                                                                                                                                      namespace Doctor

                                                                                                                                                                                                      module 'build/project/Doctor.d.ts' {}

                                                                                                                                                                                                        variable ERROR

                                                                                                                                                                                                        const ERROR: number;

                                                                                                                                                                                                          variable FATAL

                                                                                                                                                                                                          const FATAL: number;

                                                                                                                                                                                                            variable NO_ISSUES

                                                                                                                                                                                                            const NO_ISSUES: number;

                                                                                                                                                                                                              variable WARNING

                                                                                                                                                                                                              const WARNING: number;

                                                                                                                                                                                                                function validateExpoServersAsync

                                                                                                                                                                                                                validateExpoServersAsync: (projectRoot: string) => Promise<number>;

                                                                                                                                                                                                                  function validateWithNetworkAsync

                                                                                                                                                                                                                  validateWithNetworkAsync: (
                                                                                                                                                                                                                  projectRoot: string,
                                                                                                                                                                                                                  options?: { skipSDKVersionRequirement?: boolean }
                                                                                                                                                                                                                  ) => Promise<number>;

                                                                                                                                                                                                                    function validateWithoutNetworkAsync

                                                                                                                                                                                                                    validateWithoutNetworkAsync: (
                                                                                                                                                                                                                    projectRoot: string,
                                                                                                                                                                                                                    options?: { skipSDKVersionRequirement?: boolean }
                                                                                                                                                                                                                    ) => Promise<number>;

                                                                                                                                                                                                                      namespace EmbeddedAssets

                                                                                                                                                                                                                      module 'build/EmbeddedAssets.d.ts' {}
                                                                                                                                                                                                                      • The code below here is duplicated from expo-cli currently *

                                                                                                                                                                                                                      function configureAsync

                                                                                                                                                                                                                      configureAsync: (config: EmbeddedAssetsConfiguration) => Promise<void>;

                                                                                                                                                                                                                        function getEmbeddedManifestPath

                                                                                                                                                                                                                        getEmbeddedManifestPath: (
                                                                                                                                                                                                                        platform: 'ios' | 'android',
                                                                                                                                                                                                                        projectRoot: string,
                                                                                                                                                                                                                        exp: ExpoAppManifest
                                                                                                                                                                                                                        ) => string;

                                                                                                                                                                                                                          function getIOSPaths

                                                                                                                                                                                                                          getIOSPaths: (projectRoot: string) => {
                                                                                                                                                                                                                          projectName: string;
                                                                                                                                                                                                                          iosProjectDirectory: string;
                                                                                                                                                                                                                          iosSupportingDirectory: string;
                                                                                                                                                                                                                          iconPath: string;
                                                                                                                                                                                                                          };
                                                                                                                                                                                                                          • The code below here is duplicated from expo-cli currently *

                                                                                                                                                                                                                          function shouldEmbedAssetsForExpoUpdates

                                                                                                                                                                                                                          shouldEmbedAssetsForExpoUpdates: (
                                                                                                                                                                                                                          projectRoot: string,
                                                                                                                                                                                                                          exp: ExpoAppManifest,
                                                                                                                                                                                                                          pkg: PackageJSONConfig,
                                                                                                                                                                                                                          target: ProjectTarget
                                                                                                                                                                                                                          ) => boolean;

                                                                                                                                                                                                                            type EmbeddedAssetsConfiguration

                                                                                                                                                                                                                            type EmbeddedAssetsConfiguration = {
                                                                                                                                                                                                                            projectRoot: string;
                                                                                                                                                                                                                            pkg: PackageJSONConfig;
                                                                                                                                                                                                                            exp: ExpoAppManifest;
                                                                                                                                                                                                                            releaseChannel?: string;
                                                                                                                                                                                                                            iosManifestUrl: string;
                                                                                                                                                                                                                            iosManifest: any;
                                                                                                                                                                                                                            iosBundle: string | Uint8Array;
                                                                                                                                                                                                                            androidManifestUrl: string;
                                                                                                                                                                                                                            androidManifest: any;
                                                                                                                                                                                                                            androidBundle: string | Uint8Array;
                                                                                                                                                                                                                            target: ProjectTarget;
                                                                                                                                                                                                                            };

                                                                                                                                                                                                                              namespace Env

                                                                                                                                                                                                                              module 'build/Env.d.ts' {}
                                                                                                                                                                                                                              • Returns true if we should use Metro using its JS APIs via @expo/dev-server (the modern and fast way), false if we should fall back to spawning it as a subprocess (supported for backwards compatibility with SDK39 and older).

                                                                                                                                                                                                                              function getFeatureGateOverrides

                                                                                                                                                                                                                              getFeatureGateOverrides: () => { enable: string[]; disable: string[] };

                                                                                                                                                                                                                                function isDebug

                                                                                                                                                                                                                                isDebug: () => boolean;

                                                                                                                                                                                                                                  function isInterstitiaLPageEnabled

                                                                                                                                                                                                                                  isInterstitiaLPageEnabled: () => boolean;

                                                                                                                                                                                                                                    function isLocal

                                                                                                                                                                                                                                    isLocal: () => boolean;

                                                                                                                                                                                                                                      function isStaging

                                                                                                                                                                                                                                      isStaging: () => boolean;

                                                                                                                                                                                                                                        function maySkipManifestValidation

                                                                                                                                                                                                                                        maySkipManifestValidation: () => boolean;

                                                                                                                                                                                                                                          function shouldEnableAnalytics

                                                                                                                                                                                                                                          shouldEnableAnalytics: () => boolean;

                                                                                                                                                                                                                                            function shouldUseDevServer

                                                                                                                                                                                                                                            shouldUseDevServer: (exp: Pick<ExpoConfig, 'sdkVersion'>) => boolean;
                                                                                                                                                                                                                                            • Returns true if we should use Metro using its JS APIs via @expo/dev-server (the modern and fast way), false if we should fall back to spawning it as a subprocess (supported for backwards compatibility with SDK39 and older).

                                                                                                                                                                                                                                            namespace Exp

                                                                                                                                                                                                                                            module 'build/Exp.d.ts' {}

                                                                                                                                                                                                                                              function sendAsync

                                                                                                                                                                                                                                              sendAsync: (
                                                                                                                                                                                                                                              recipient: string,
                                                                                                                                                                                                                                              url_: string,
                                                                                                                                                                                                                                              allowUnauthed?: boolean
                                                                                                                                                                                                                                              ) => Promise<any>;

                                                                                                                                                                                                                                                namespace IosCodeSigning

                                                                                                                                                                                                                                                module 'build/detach/IosCodeSigning.d.ts' {}

                                                                                                                                                                                                                                                  function validateProvisioningProfile

                                                                                                                                                                                                                                                  validateProvisioningProfile: (
                                                                                                                                                                                                                                                  plistData: PlistObject,
                                                                                                                                                                                                                                                  {
                                                                                                                                                                                                                                                  distCertFingerprint,
                                                                                                                                                                                                                                                  bundleIdentifier,
                                                                                                                                                                                                                                                  }: { distCertFingerprint: string; bundleIdentifier: string }
                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                    type IPABuilderParams

                                                                                                                                                                                                                                                    type IPABuilderParams = {
                                                                                                                                                                                                                                                    provisioningProfilePath: string;
                                                                                                                                                                                                                                                    certPath: string;
                                                                                                                                                                                                                                                    certPassword?: string;
                                                                                                                                                                                                                                                    appUUID: string;
                                                                                                                                                                                                                                                    keychainPath: string;
                                                                                                                                                                                                                                                    bundleIdentifier: string;
                                                                                                                                                                                                                                                    teamID: string;
                                                                                                                                                                                                                                                    manifest: any;
                                                                                                                                                                                                                                                    workspacePath: string;
                                                                                                                                                                                                                                                    clientBuild?: boolean;
                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                      namespace LoadingPageHandler

                                                                                                                                                                                                                                                      module 'build/start/LoadingPageHandler.d.ts' {}

                                                                                                                                                                                                                                                        variable DeepLinkEndpoint

                                                                                                                                                                                                                                                        const DeepLinkEndpoint: string;

                                                                                                                                                                                                                                                          variable LoadingEndpoint

                                                                                                                                                                                                                                                          const LoadingEndpoint: string;

                                                                                                                                                                                                                                                            function getLoadingPageHandler

                                                                                                                                                                                                                                                            getLoadingPageHandler: (
                                                                                                                                                                                                                                                            projectRoot: string
                                                                                                                                                                                                                                                            ) => (
                                                                                                                                                                                                                                                            req: express.Request | http.IncomingMessage,
                                                                                                                                                                                                                                                            res: express.Response | http.ServerResponse,
                                                                                                                                                                                                                                                            next: (err?: Error | undefined) => void
                                                                                                                                                                                                                                                            ) => Promise<void>;

                                                                                                                                                                                                                                                              function noCacheMiddleware

                                                                                                                                                                                                                                                              noCacheMiddleware: (
                                                                                                                                                                                                                                                              res: express.Response | http.ServerResponse
                                                                                                                                                                                                                                                              ) => express.Response | http.ServerResponse;
                                                                                                                                                                                                                                                                setOnDeepLink: (listener: OnDeepLinkListener) => void;

                                                                                                                                                                                                                                                                  namespace ModuleVersion

                                                                                                                                                                                                                                                                  module 'build/tools/ModuleVersion.d.ts' {}
                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                    just use the update-check npm package

                                                                                                                                                                                                                                                                  function createModuleVersionChecker

                                                                                                                                                                                                                                                                  createModuleVersionChecker: (
                                                                                                                                                                                                                                                                  name: string,
                                                                                                                                                                                                                                                                  currentVersion: string
                                                                                                                                                                                                                                                                  ) => {
                                                                                                                                                                                                                                                                  checkAsync: () => Promise<{
                                                                                                                                                                                                                                                                  updateIsAvailable: boolean;
                                                                                                                                                                                                                                                                  latest: string;
                                                                                                                                                                                                                                                                  current: string;
                                                                                                                                                                                                                                                                  deprecated: unknown;
                                                                                                                                                                                                                                                                  }>;
                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                    just use the update-check npm package

                                                                                                                                                                                                                                                                  namespace PKCS12Utils

                                                                                                                                                                                                                                                                  module 'build/detach/PKCS12Utils.d.ts' {}

                                                                                                                                                                                                                                                                    function findP12CertSerialNumber

                                                                                                                                                                                                                                                                    findP12CertSerialNumber: (
                                                                                                                                                                                                                                                                    p12Buffer: Buffer | string,
                                                                                                                                                                                                                                                                    passwordRaw: string | null
                                                                                                                                                                                                                                                                    ) => string | null;

                                                                                                                                                                                                                                                                      function getCertData

                                                                                                                                                                                                                                                                      getCertData: (
                                                                                                                                                                                                                                                                      p12Buffer: Buffer | string,
                                                                                                                                                                                                                                                                      passwordRaw: string | null
                                                                                                                                                                                                                                                                      ) => {
                                                                                                                                                                                                                                                                      serialNumber: string | null;
                                                                                                                                                                                                                                                                      version: number;
                                                                                                                                                                                                                                                                      signature: any;
                                                                                                                                                                                                                                                                      siginfo: any;
                                                                                                                                                                                                                                                                      validity: { notBefore: Date; notAfter: Date };
                                                                                                                                                                                                                                                                      issuer: {
                                                                                                                                                                                                                                                                      getField(sn: string | forge.pki.CertificateFieldOptions): any;
                                                                                                                                                                                                                                                                      addField(attr: forge.pki.CertificateField): void;
                                                                                                                                                                                                                                                                      attributes: any[];
                                                                                                                                                                                                                                                                      hash: any;
                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                      subject: {
                                                                                                                                                                                                                                                                      getField(sn: string | forge.pki.CertificateFieldOptions): any;
                                                                                                                                                                                                                                                                      addField(attr: forge.pki.CertificateField): void;
                                                                                                                                                                                                                                                                      attributes: any[];
                                                                                                                                                                                                                                                                      hash: any;
                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                      extensions: any[];
                                                                                                                                                                                                                                                                      privateKey: forge.pki.PrivateKey;
                                                                                                                                                                                                                                                                      publicKey: forge.pki.PublicKey;
                                                                                                                                                                                                                                                                      md: any;
                                                                                                                                                                                                                                                                      setSubject(
                                                                                                                                                                                                                                                                      attrs: forge.pki.CertificateField[],
                                                                                                                                                                                                                                                                      uniqueId?: string | undefined
                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                      setIssuer(
                                                                                                                                                                                                                                                                      attrs: forge.pki.CertificateField[],
                                                                                                                                                                                                                                                                      uniqueId?: string | undefined
                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                      setExtensions(exts: any[]): void;
                                                                                                                                                                                                                                                                      getExtension(
                                                                                                                                                                                                                                                                      options: string | { name: string } | { id: number }
                                                                                                                                                                                                                                                                      ): {} | undefined;
                                                                                                                                                                                                                                                                      sign(key: forge.pki.PrivateKey, md?: any): void;
                                                                                                                                                                                                                                                                      verify(child: forge.pki.Certificate): boolean;
                                                                                                                                                                                                                                                                      getAttribute(
                                                                                                                                                                                                                                                                      opts: string | forge.pki.GetAttributeOpts
                                                                                                                                                                                                                                                                      ): forge.pki.Attribute | null;
                                                                                                                                                                                                                                                                      isIssuer(parent: forge.pki.Certificate): boolean;
                                                                                                                                                                                                                                                                      issued(child: forge.pki.Certificate): boolean;
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        function getP12CertFingerprint

                                                                                                                                                                                                                                                                        getP12CertFingerprint: (
                                                                                                                                                                                                                                                                        p12Buffer: Buffer | string,
                                                                                                                                                                                                                                                                        passwordRaw: string | null
                                                                                                                                                                                                                                                                        ) => string;

                                                                                                                                                                                                                                                                          namespace Project

                                                                                                                                                                                                                                                                          module 'build/Project.d.ts' {}

                                                                                                                                                                                                                                                                            function broadcastMessage

                                                                                                                                                                                                                                                                            broadcastMessage: (
                                                                                                                                                                                                                                                                            method: 'reload' | 'devMenu' | 'sendDevCommand',
                                                                                                                                                                                                                                                                            params?: Record<string, any> | undefined
                                                                                                                                                                                                                                                                            ) => void;
                                                                                                                                                                                                                                                                            • Sends a message over web sockets to any connected device, does nothing when the dev server is not running.

                                                                                                                                                                                                                                                                              Parameter method

                                                                                                                                                                                                                                                                              name of the command. In RN projects reload, and devMenu are available. In Expo Go, sendDevCommand is available.

                                                                                                                                                                                                                                                                              Parameter params

                                                                                                                                                                                                                                                                            function createBundlesAsync

                                                                                                                                                                                                                                                                            createBundlesAsync: (
                                                                                                                                                                                                                                                                            projectRoot: string,
                                                                                                                                                                                                                                                                            publishOptions: PublishOptions | undefined,
                                                                                                                                                                                                                                                                            bundleOptions: { platforms: Platform[]; dev?: boolean; useDevServer: boolean }
                                                                                                                                                                                                                                                                            ) => Promise<Partial<Record<Platform, BundleOutput>>>;

                                                                                                                                                                                                                                                                              function getPublishExpConfigAsync

                                                                                                                                                                                                                                                                              getPublishExpConfigAsync: (
                                                                                                                                                                                                                                                                              projectRoot: string,
                                                                                                                                                                                                                                                                              options?: Pick<PublishOptions, 'releaseChannel'>
                                                                                                                                                                                                                                                                              ) => Promise<{
                                                                                                                                                                                                                                                                              exp: ExpoAppManifest;
                                                                                                                                                                                                                                                                              pkg: PackageJSONConfig;
                                                                                                                                                                                                                                                                              hooks: ExpoConfig['hooks'];
                                                                                                                                                                                                                                                                              }>;

                                                                                                                                                                                                                                                                                function prepareHooks

                                                                                                                                                                                                                                                                                prepareHooks: (
                                                                                                                                                                                                                                                                                hooks: ExpoConfig,
                                                                                                                                                                                                                                                                                hookType: HookType,
                                                                                                                                                                                                                                                                                projectRoot: string
                                                                                                                                                                                                                                                                                ) => LoadedHook[];

                                                                                                                                                                                                                                                                                  function publishAsync

                                                                                                                                                                                                                                                                                  publishAsync: (
                                                                                                                                                                                                                                                                                  projectRoot: string,
                                                                                                                                                                                                                                                                                  options?: PublishOptions
                                                                                                                                                                                                                                                                                  ) => Promise<PublishedProjectResult>;

                                                                                                                                                                                                                                                                                    function runHook

                                                                                                                                                                                                                                                                                    runHook: (
                                                                                                                                                                                                                                                                                    hook: LoadedHook,
                                                                                                                                                                                                                                                                                    hookOptions: Omit<HookArguments, 'config'>
                                                                                                                                                                                                                                                                                    ) => Promise<void>;

                                                                                                                                                                                                                                                                                      function startAsync

                                                                                                                                                                                                                                                                                      startAsync: (
                                                                                                                                                                                                                                                                                      projectRoot: string,
                                                                                                                                                                                                                                                                                      { exp, ...options }?: StartDevServerOptions & { exp?: ExpoConfig },
                                                                                                                                                                                                                                                                                      verbose?: boolean
                                                                                                                                                                                                                                                                                      ) => Promise<ExpoConfig>;

                                                                                                                                                                                                                                                                                        function startExpoServerAsync

                                                                                                                                                                                                                                                                                        startExpoServerAsync: (projectRoot: string) => Promise<void>;

                                                                                                                                                                                                                                                                                          function startReactNativeServerAsync

                                                                                                                                                                                                                                                                                          startReactNativeServerAsync: ({
                                                                                                                                                                                                                                                                                          projectRoot,
                                                                                                                                                                                                                                                                                          options,
                                                                                                                                                                                                                                                                                          exp,
                                                                                                                                                                                                                                                                                          verbose,
                                                                                                                                                                                                                                                                                          }: {
                                                                                                                                                                                                                                                                                          projectRoot: string;
                                                                                                                                                                                                                                                                                          options: StartDevServerOptions;
                                                                                                                                                                                                                                                                                          exp?: ExpoConfig;
                                                                                                                                                                                                                                                                                          verbose?: boolean;
                                                                                                                                                                                                                                                                                          }) => Promise<void>;

                                                                                                                                                                                                                                                                                            function startTunnelsAsync

                                                                                                                                                                                                                                                                                            startTunnelsAsync: (
                                                                                                                                                                                                                                                                                            projectRoot: string,
                                                                                                                                                                                                                                                                                            options?: { autoInstall?: boolean }
                                                                                                                                                                                                                                                                                            ) => Promise<void>;

                                                                                                                                                                                                                                                                                              function startWebpackAsync

                                                                                                                                                                                                                                                                                              startWebpackAsync: (
                                                                                                                                                                                                                                                                                              projectRoot: string,
                                                                                                                                                                                                                                                                                              { exp, ...options }?: StartDevServerOptions & { exp?: ExpoConfig }
                                                                                                                                                                                                                                                                                              ) => Promise<void>;

                                                                                                                                                                                                                                                                                                function stopAsync

                                                                                                                                                                                                                                                                                                stopAsync: (projectRoot: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                  function stopReactNativeServerAsync

                                                                                                                                                                                                                                                                                                  stopReactNativeServerAsync: (projectRoot: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                    function stopTunnelsAsync

                                                                                                                                                                                                                                                                                                    stopTunnelsAsync: (projectRoot: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                      function writeArtifactSafelyAsync

                                                                                                                                                                                                                                                                                                      writeArtifactSafelyAsync: (
                                                                                                                                                                                                                                                                                                      projectRoot: string,
                                                                                                                                                                                                                                                                                                      keyName: string | null,
                                                                                                                                                                                                                                                                                                      artifactPath: string,
                                                                                                                                                                                                                                                                                                      artifact: string | Uint8Array
                                                                                                                                                                                                                                                                                                      ) => Promise<void>;

                                                                                                                                                                                                                                                                                                        interface PublishedProjectResult

                                                                                                                                                                                                                                                                                                        interface PublishedProjectResult {}

                                                                                                                                                                                                                                                                                                          property err

                                                                                                                                                                                                                                                                                                          err?: string;
                                                                                                                                                                                                                                                                                                          • TODO: What is this? Where does it come from?

                                                                                                                                                                                                                                                                                                          property ids

                                                                                                                                                                                                                                                                                                          ids: string[];
                                                                                                                                                                                                                                                                                                          • TODO: What is this?

                                                                                                                                                                                                                                                                                                          property projectPageUrl

                                                                                                                                                                                                                                                                                                          projectPageUrl: string;
                                                                                                                                                                                                                                                                                                          • Project page URL

                                                                                                                                                                                                                                                                                                          property url

                                                                                                                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                                                                                                                          • Project manifest URL

                                                                                                                                                                                                                                                                                                          type LoadedHook

                                                                                                                                                                                                                                                                                                          type LoadedHook = Hook & {
                                                                                                                                                                                                                                                                                                          _fn: (input: HookArguments) => any;
                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                            type PublishOptions

                                                                                                                                                                                                                                                                                                            type PublishOptions = {
                                                                                                                                                                                                                                                                                                            releaseChannel?: string;
                                                                                                                                                                                                                                                                                                            target?: ProjectTarget;
                                                                                                                                                                                                                                                                                                            resetCache?: boolean;
                                                                                                                                                                                                                                                                                                            maxWorkers?: number;
                                                                                                                                                                                                                                                                                                            quiet?: boolean;
                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                              type StartOptions

                                                                                                                                                                                                                                                                                                              type StartOptions = {
                                                                                                                                                                                                                                                                                                              metroPort?: number;
                                                                                                                                                                                                                                                                                                              webpackPort?: number;
                                                                                                                                                                                                                                                                                                              isWebSocketsEnabled?: boolean;
                                                                                                                                                                                                                                                                                                              isRemoteReloadingEnabled?: boolean;
                                                                                                                                                                                                                                                                                                              devClient?: boolean;
                                                                                                                                                                                                                                                                                                              reset?: boolean;
                                                                                                                                                                                                                                                                                                              nonInteractive?: boolean;
                                                                                                                                                                                                                                                                                                              nonPersistent?: boolean;
                                                                                                                                                                                                                                                                                                              maxWorkers?: number;
                                                                                                                                                                                                                                                                                                              webOnly?: boolean;
                                                                                                                                                                                                                                                                                                              target?: ProjectTarget;
                                                                                                                                                                                                                                                                                                              platforms?: ExpoConfig['platforms'];
                                                                                                                                                                                                                                                                                                              forceManifestType?: 'expo-updates' | 'classic';
                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                namespace ProjectAssets

                                                                                                                                                                                                                                                                                                                module 'build/ProjectAssets.d.ts' {}

                                                                                                                                                                                                                                                                                                                  function exportAssetsAsync

                                                                                                                                                                                                                                                                                                                  exportAssetsAsync: ({
                                                                                                                                                                                                                                                                                                                  projectRoot,
                                                                                                                                                                                                                                                                                                                  exp,
                                                                                                                                                                                                                                                                                                                  hostedUrl,
                                                                                                                                                                                                                                                                                                                  assetPath,
                                                                                                                                                                                                                                                                                                                  outputDir,
                                                                                                                                                                                                                                                                                                                  bundles,
                                                                                                                                                                                                                                                                                                                  experimentalBundle,
                                                                                                                                                                                                                                                                                                                  }: ExportAssetsOptions) => Promise<{ exp: ExpoAppManifest; assets: Asset[] }>;

                                                                                                                                                                                                                                                                                                                    function publishAssetsAsync

                                                                                                                                                                                                                                                                                                                    publishAssetsAsync: (
                                                                                                                                                                                                                                                                                                                    options: Pick<ExportAssetsOptions, 'projectRoot' | 'exp' | 'bundles'>
                                                                                                                                                                                                                                                                                                                    ) => Promise<{ exp: ExpoAppManifest; assets: Asset[] }>;

                                                                                                                                                                                                                                                                                                                      function resolveGoogleServicesFile

                                                                                                                                                                                                                                                                                                                      resolveGoogleServicesFile: (
                                                                                                                                                                                                                                                                                                                      projectRoot: string,
                                                                                                                                                                                                                                                                                                                      manifest: ExpoConfig
                                                                                                                                                                                                                                                                                                                      ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                        function resolveManifestAssets

                                                                                                                                                                                                                                                                                                                        resolveManifestAssets: ({
                                                                                                                                                                                                                                                                                                                        projectRoot,
                                                                                                                                                                                                                                                                                                                        manifest,
                                                                                                                                                                                                                                                                                                                        resolver,
                                                                                                                                                                                                                                                                                                                        strict,
                                                                                                                                                                                                                                                                                                                        }: {
                                                                                                                                                                                                                                                                                                                        projectRoot: string;
                                                                                                                                                                                                                                                                                                                        manifest: ExpoConfig;
                                                                                                                                                                                                                                                                                                                        resolver: (assetPath: string) => Promise<string>;
                                                                                                                                                                                                                                                                                                                        strict?: boolean;
                                                                                                                                                                                                                                                                                                                        }) => Promise<void>;

                                                                                                                                                                                                                                                                                                                          type Asset

                                                                                                                                                                                                                                                                                                                          type Asset = ManifestAsset | BundleAssetWithFileHashes;

                                                                                                                                                                                                                                                                                                                            namespace ProjectSettings

                                                                                                                                                                                                                                                                                                                            module 'build/ProjectSettings.d.ts' {}

                                                                                                                                                                                                                                                                                                                              function dotExpoProjectDirectory

                                                                                                                                                                                                                                                                                                                              dotExpoProjectDirectory: (projectRoot: string) => string;

                                                                                                                                                                                                                                                                                                                                function dotExpoProjectDirectoryExists

                                                                                                                                                                                                                                                                                                                                dotExpoProjectDirectoryExists: (projectRoot: string) => boolean;

                                                                                                                                                                                                                                                                                                                                  function getCurrentStatusAsync

                                                                                                                                                                                                                                                                                                                                  getCurrentStatusAsync: (projectRoot: string) => Promise<ProjectStatus>;

                                                                                                                                                                                                                                                                                                                                    function getDevicesInfoAsync

                                                                                                                                                                                                                                                                                                                                    getDevicesInfoAsync: (projectRoot: string) => Promise<DevicesInfo>;

                                                                                                                                                                                                                                                                                                                                      function readAsync

                                                                                                                                                                                                                                                                                                                                      readAsync: (projectRoot: string) => Promise<ProjectSettings>;

                                                                                                                                                                                                                                                                                                                                        function readDevicesInfoAsync

                                                                                                                                                                                                                                                                                                                                        readDevicesInfoAsync: (projectRoot: string) => Promise<DevicesInfo>;

                                                                                                                                                                                                                                                                                                                                          function readPackagerInfoAsync

                                                                                                                                                                                                                                                                                                                                          readPackagerInfoAsync: (projectRoot: string) => Promise<PackagerInfo>;

                                                                                                                                                                                                                                                                                                                                            function saveDevicesAsync

                                                                                                                                                                                                                                                                                                                                            saveDevicesAsync: (
                                                                                                                                                                                                                                                                                                                                            projectRoot: string,
                                                                                                                                                                                                                                                                                                                                            deviceIds: string | string[]
                                                                                                                                                                                                                                                                                                                                            ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                              function setAsync

                                                                                                                                                                                                                                                                                                                                              setAsync: (
                                                                                                                                                                                                                                                                                                                                              projectRoot: string,
                                                                                                                                                                                                                                                                                                                                              json: Partial<ProjectSettings>
                                                                                                                                                                                                                                                                                                                                              ) => Promise<ProjectSettings>;

                                                                                                                                                                                                                                                                                                                                                function setDevicesInfoAsync

                                                                                                                                                                                                                                                                                                                                                setDevicesInfoAsync: (
                                                                                                                                                                                                                                                                                                                                                projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                json: DevicesInfo
                                                                                                                                                                                                                                                                                                                                                ) => Promise<DevicesInfo>;

                                                                                                                                                                                                                                                                                                                                                  function setPackagerInfoAsync

                                                                                                                                                                                                                                                                                                                                                  setPackagerInfoAsync: (
                                                                                                                                                                                                                                                                                                                                                  projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                  json: Partial<PackagerInfo>
                                                                                                                                                                                                                                                                                                                                                  ) => Promise<PackagerInfo>;

                                                                                                                                                                                                                                                                                                                                                    type DeviceInfo

                                                                                                                                                                                                                                                                                                                                                    type DeviceInfo = {
                                                                                                                                                                                                                                                                                                                                                    installationId: string;
                                                                                                                                                                                                                                                                                                                                                    lastUsed: number;
                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                      type DevicesInfo

                                                                                                                                                                                                                                                                                                                                                      type DevicesInfo = {
                                                                                                                                                                                                                                                                                                                                                      devices: DeviceInfo[];
                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                        type ProjectSettings

                                                                                                                                                                                                                                                                                                                                                        type ProjectSettings = {
                                                                                                                                                                                                                                                                                                                                                        scheme: string | null;
                                                                                                                                                                                                                                                                                                                                                        hostType: 'localhost' | 'lan' | 'tunnel';
                                                                                                                                                                                                                                                                                                                                                        lanType: 'ip' | 'hostname';
                                                                                                                                                                                                                                                                                                                                                        dev: boolean;
                                                                                                                                                                                                                                                                                                                                                        devClient: boolean;
                                                                                                                                                                                                                                                                                                                                                        minify: boolean;
                                                                                                                                                                                                                                                                                                                                                        urlRandomness: string | null;
                                                                                                                                                                                                                                                                                                                                                        https: boolean;
                                                                                                                                                                                                                                                                                                                                                        strict?: boolean;
                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                          type Settings

                                                                                                                                                                                                                                                                                                                                                          type Settings = ProjectSettings;

                                                                                                                                                                                                                                                                                                                                                            namespace ProjectUtils

                                                                                                                                                                                                                                                                                                                                                            module 'build/project/ProjectUtils.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                              function attachLoggerStream

                                                                                                                                                                                                                                                                                                                                                              attachLoggerStream: (projectRoot: string, stream: bunyan.Stream) => void;

                                                                                                                                                                                                                                                                                                                                                                function clearNotification

                                                                                                                                                                                                                                                                                                                                                                clearNotification: (projectRoot: string, id: string) => void;

                                                                                                                                                                                                                                                                                                                                                                  function getLogger

                                                                                                                                                                                                                                                                                                                                                                  getLogger: (projectRoot: string) => bunyan;

                                                                                                                                                                                                                                                                                                                                                                    function logDebug

                                                                                                                                                                                                                                                                                                                                                                    logDebug: (
                                                                                                                                                                                                                                                                                                                                                                    projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                    tag: LogTag,
                                                                                                                                                                                                                                                                                                                                                                    message: string,
                                                                                                                                                                                                                                                                                                                                                                    id?: string
                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                      function logError

                                                                                                                                                                                                                                                                                                                                                                      logError: (
                                                                                                                                                                                                                                                                                                                                                                      projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                      tag: LogTag,
                                                                                                                                                                                                                                                                                                                                                                      message: string,
                                                                                                                                                                                                                                                                                                                                                                      id?: string
                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                        function logInfo

                                                                                                                                                                                                                                                                                                                                                                        logInfo: (
                                                                                                                                                                                                                                                                                                                                                                        projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                        tag: LogTag,
                                                                                                                                                                                                                                                                                                                                                                        message: string,
                                                                                                                                                                                                                                                                                                                                                                        id?: string
                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                          function logWarning

                                                                                                                                                                                                                                                                                                                                                                          logWarning: (
                                                                                                                                                                                                                                                                                                                                                                          projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                          tag: LogTag,
                                                                                                                                                                                                                                                                                                                                                                          message: string,
                                                                                                                                                                                                                                                                                                                                                                          id?: string
                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                            function logWithLevel

                                                                                                                                                                                                                                                                                                                                                                            logWithLevel: (
                                                                                                                                                                                                                                                                                                                                                                            projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                            level: string,
                                                                                                                                                                                                                                                                                                                                                                            fields: LogFields,
                                                                                                                                                                                                                                                                                                                                                                            msg: string,
                                                                                                                                                                                                                                                                                                                                                                            id?: string
                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                              type LogFields

                                                                                                                                                                                                                                                                                                                                                                              type LogFields = {
                                                                                                                                                                                                                                                                                                                                                                              tag: LogTag;
                                                                                                                                                                                                                                                                                                                                                                              issueId?: string;
                                                                                                                                                                                                                                                                                                                                                                              issueCleared?: boolean;
                                                                                                                                                                                                                                                                                                                                                                              includesStack?: boolean;
                                                                                                                                                                                                                                                                                                                                                                              deviceId?: string;
                                                                                                                                                                                                                                                                                                                                                                              deviceName?: string;
                                                                                                                                                                                                                                                                                                                                                                              groupDepth?: number;
                                                                                                                                                                                                                                                                                                                                                                              shouldHide?: boolean;
                                                                                                                                                                                                                                                                                                                                                                              _expoEventType?: 'TUNNEL_READY';
                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                type LogTag

                                                                                                                                                                                                                                                                                                                                                                                type LogTag = 'expo' | 'metro' | 'device';

                                                                                                                                                                                                                                                                                                                                                                                  namespace Prompts

                                                                                                                                                                                                                                                                                                                                                                                  module 'build/Prompts.d.ts' {}
                                                                                                                                                                                                                                                                                                                                                                                  • Used to pause/resume interaction observers while prompting (made for TerminalUI).

                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                  function addInteractionListener

                                                                                                                                                                                                                                                                                                                                                                                  addInteractionListener: (callback: InteractionCallback) => void;
                                                                                                                                                                                                                                                                                                                                                                                  • Used to pause/resume interaction observers while prompting (made for TerminalUI).

                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                  function confirmAsync

                                                                                                                                                                                                                                                                                                                                                                                  confirmAsync: (options: {
                                                                                                                                                                                                                                                                                                                                                                                  initial?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                  message: string;
                                                                                                                                                                                                                                                                                                                                                                                  }) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                    function pauseInteractions

                                                                                                                                                                                                                                                                                                                                                                                    pauseInteractions: (options?: Omit<InteractionOptions, 'pause'>) => void;

                                                                                                                                                                                                                                                                                                                                                                                      function removeInteractionListener

                                                                                                                                                                                                                                                                                                                                                                                      removeInteractionListener: (callback: InteractionCallback) => void;

                                                                                                                                                                                                                                                                                                                                                                                        function resumeInteractions

                                                                                                                                                                                                                                                                                                                                                                                        resumeInteractions: (options?: Omit<InteractionOptions, 'pause'>) => void;

                                                                                                                                                                                                                                                                                                                                                                                          namespace SimControl

                                                                                                                                                                                                                                                                                                                                                                                          module 'build/SimControl.d.ts' {}
                                                                                                                                                                                                                                                                                                                                                                                          • '/Users/name/Library/Developer/CoreSimulator/Devices/00E55DC0-0364-49DF-9EC6-77BE587137D4/data'

                                                                                                                                                                                                                                                                                                                                                                                          function addMediaAsync

                                                                                                                                                                                                                                                                                                                                                                                          addMediaAsync: (udid: string, mediaPath: string) => Promise<SpawnResult>;

                                                                                                                                                                                                                                                                                                                                                                                            function bootAsync

                                                                                                                                                                                                                                                                                                                                                                                            bootAsync: ({ udid }: { udid: string }) => Promise<SimulatorDevice | null>;

                                                                                                                                                                                                                                                                                                                                                                                              function captureScreenAsync

                                                                                                                                                                                                                                                                                                                                                                                              captureScreenAsync: (
                                                                                                                                                                                                                                                                                                                                                                                              udid: string,
                                                                                                                                                                                                                                                                                                                                                                                              captureType: 'screenshot' | 'recordVideo',
                                                                                                                                                                                                                                                                                                                                                                                              outputFilePath: string
                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<SpawnResult>;

                                                                                                                                                                                                                                                                                                                                                                                                function deleteUnavailableAsync

                                                                                                                                                                                                                                                                                                                                                                                                deleteUnavailableAsync: () => Promise<SpawnResult>;

                                                                                                                                                                                                                                                                                                                                                                                                  function eraseAllAsync

                                                                                                                                                                                                                                                                                                                                                                                                  eraseAllAsync: () => Promise<SpawnResult>;

                                                                                                                                                                                                                                                                                                                                                                                                    function eraseAsync

                                                                                                                                                                                                                                                                                                                                                                                                    eraseAsync: (udid: string) => Promise<SpawnResult>;

                                                                                                                                                                                                                                                                                                                                                                                                      function getContainerPathAsync

                                                                                                                                                                                                                                                                                                                                                                                                      getContainerPathAsync: ({
                                                                                                                                                                                                                                                                                                                                                                                                      udid,
                                                                                                                                                                                                                                                                                                                                                                                                      bundleIdentifier,
                                                                                                                                                                                                                                                                                                                                                                                                      }: {
                                                                                                                                                                                                                                                                                                                                                                                                      udid: string;
                                                                                                                                                                                                                                                                                                                                                                                                      bundleIdentifier: string;
                                                                                                                                                                                                                                                                                                                                                                                                      }) => Promise<string | null>;
                                                                                                                                                                                                                                                                                                                                                                                                      • Returns the local path for the installed tar.app. Returns null when the app isn't installed.

                                                                                                                                                                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                                                                                                                                                                        props.udid device udid.

                                                                                                                                                                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                                                                                                                                                                        props.bundleIdentifier bundle identifier for app

                                                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                                                        local file path to installed app binary, e.g. '/Users/evanbacon/Library/Developer/CoreSimulator/Devices/EFEEA6EF-E3F5-4EDE-9B72-29EAFA7514AE/data/Containers/Bundle/Application/FA43A0C6-C2AD-442D-B8B1-EAF3E88CF3BF/Exponent-2.21.3.tar.app'

                                                                                                                                                                                                                                                                                                                                                                                                      function getDefaultSimulatorDeviceUDIDAsync

                                                                                                                                                                                                                                                                                                                                                                                                      getDefaultSimulatorDeviceUDIDAsync: () => Promise<string | null>;

                                                                                                                                                                                                                                                                                                                                                                                                        function installAsync

                                                                                                                                                                                                                                                                                                                                                                                                        installAsync: (options: { udid: string; dir: string }) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                          function isLicenseOutOfDate

                                                                                                                                                                                                                                                                                                                                                                                                          isLicenseOutOfDate: (text: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                            function isXcrunInstalledAsync

                                                                                                                                                                                                                                                                                                                                                                                                            isXcrunInstalledAsync: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                              function listAsync

                                                                                                                                                                                                                                                                                                                                                                                                              listAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                              type: 'devices' | 'devicetypes' | 'runtimes' | 'pairs',
                                                                                                                                                                                                                                                                                                                                                                                                              query?: string | 'available'
                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<SimulatorDeviceList>;

                                                                                                                                                                                                                                                                                                                                                                                                                function listDevicesAsync

                                                                                                                                                                                                                                                                                                                                                                                                                listDevicesAsync: () => Promise<XCTraceDevice[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                • Get a list of all connected devices.

                                                                                                                                                                                                                                                                                                                                                                                                                function listSimulatorDevicesAsync

                                                                                                                                                                                                                                                                                                                                                                                                                listSimulatorDevicesAsync: () => Promise<SimulatorDevice[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                  function openBundleIdAsync

                                                                                                                                                                                                                                                                                                                                                                                                                  openBundleIdAsync: (options: {
                                                                                                                                                                                                                                                                                                                                                                                                                  udid?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                  bundleIdentifier: string;
                                                                                                                                                                                                                                                                                                                                                                                                                  }) => Promise<SpawnResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                    function openURLAsync

                                                                                                                                                                                                                                                                                                                                                                                                                    openURLAsync: (options: { udid?: string; url: string }) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                      function parseXcrunError

                                                                                                                                                                                                                                                                                                                                                                                                                      parseXcrunError: (e: any) => Error;

                                                                                                                                                                                                                                                                                                                                                                                                                        function runBootAsync

                                                                                                                                                                                                                                                                                                                                                                                                                        runBootAsync: ({ udid }: { udid: string }) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                          function setAppearanceAsync

                                                                                                                                                                                                                                                                                                                                                                                                                          setAppearanceAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                          udid: string,
                                                                                                                                                                                                                                                                                                                                                                                                                          theme: 'light' | 'dark'
                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<SpawnResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                            function shutdownAsync

                                                                                                                                                                                                                                                                                                                                                                                                                            shutdownAsync: (udid?: string) => Promise<SpawnResult | null>;

                                                                                                                                                                                                                                                                                                                                                                                                                              function simctlAsync

                                                                                                                                                                                                                                                                                                                                                                                                                              simctlAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                              [command, ...args]: (string | undefined)[],
                                                                                                                                                                                                                                                                                                                                                                                                                              options?: SpawnOptions
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<SpawnResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                function uninstallAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                uninstallAsync: (options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                udid?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                bundleIdentifier: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                }) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                  function updatePermissionsAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                  updatePermissionsAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  udid: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                  action: 'grant' | 'revoke' | 'reset',
                                                                                                                                                                                                                                                                                                                                                                                                                                  permission: PermissionName,
                                                                                                                                                                                                                                                                                                                                                                                                                                  bundleIdentifier?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<SpawnResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                    function waitForDeviceToBootAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                    waitForDeviceToBootAsync: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                    udid,
                                                                                                                                                                                                                                                                                                                                                                                                                                    }: Pick<SimulatorDevice, 'udid'>) => Promise<SimulatorDevice | null>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      function xcrunAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                      xcrunAsync: (args: string[], options?: SpawnOptions) => Promise<SpawnResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        function xcrunWithLogging

                                                                                                                                                                                                                                                                                                                                                                                                                                        xcrunWithLogging: (
                                                                                                                                                                                                                                                                                                                                                                                                                                        args: string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: SpawnOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<SpawnResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          type SimulatorDevice

                                                                                                                                                                                                                                                                                                                                                                                                                                          type SimulatorDevice = {
                                                                                                                                                                                                                                                                                                                                                                                                                                          availabilityError: 'runtime profile not found';
                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                          * '/Users/name/Library/Developer/CoreSimulator/Devices/00E55DC0-0364-49DF-9EC6-77BE587137D4/data'
                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                          dataPath: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                          * '/Users/name/Library/Logs/CoreSimulator/00E55DC0-0364-49DF-9EC6-77BE587137D4'
                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                          logPath: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                          * '00E55DC0-0364-49DF-9EC6-77BE587137D4'
                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                          udid: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                          * com.apple.CoreSimulator.SimRuntime.tvOS-13-4
                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                          runtime: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                          isAvailable: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                          * 'com.apple.CoreSimulator.SimDeviceType.Apple-TV-1080p'
                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                          deviceTypeIdentifier: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                          state: DeviceState;
                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                          * 'Apple TV'
                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                          osType: OSType;
                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                          * '13.4'
                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                          osVersion: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                          * 'iPhone 11 (13.6)'
                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                          windowName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                            type XCTraceDevice

                                                                                                                                                                                                                                                                                                                                                                                                                                            type XCTraceDevice = {
                                                                                                                                                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                                                                                                                                                            * '00E55DC0-0364-49DF-9EC6-77BE587137D4'
                                                                                                                                                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                                                                                                                                                            udid: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                                                                                                                                                            * 'Apple TV'
                                                                                                                                                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                            deviceType: 'device' | 'catalyst';
                                                                                                                                                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                                                                                                                                                            * '13.4'
                                                                                                                                                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                                                                                                                                                            osVersion: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace Simulator

                                                                                                                                                                                                                                                                                                                                                                                                                                              module 'build/Simulator.d.ts' {}
                                                                                                                                                                                                                                                                                                                                                                                                                                              • Ensure Xcode is installed an recent enough to be used with Expo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                true when Xcode is installed, false when the process should end.

                                                                                                                                                                                                                                                                                                                                                                                                                                              function activateSimulatorWindowAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                              activateSimulatorWindowAsync: () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                function closeSimulatorAppAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                closeSimulatorAppAsync: () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  function doesExpoClientNeedUpdatedAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                  doesExpoClientNeedUpdatedAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                  simulator: Pick<SimControl.SimulatorDevice, 'udid'>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  sdkVersion?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    function ensureSimulatorAppRunningAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                    ensureSimulatorAppRunningAsync: ({ udid }: { udid?: string }) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      function ensureSimulatorOpenAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                      ensureSimulatorOpenAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                      { udid, osType }?: { udid?: string; osType?: string },
                                                                                                                                                                                                                                                                                                                                                                                                                                                      tryAgain?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<SimControl.SimulatorDevice>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Ensure a simulator is booted and the Simulator app is opened. This is where any timeout related error handling should live.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      function ensureXcodeCommandLineToolsInstalledAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                      ensureXcodeCommandLineToolsInstalledAsync: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        function ensureXcodeInstalledAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                        ensureXcodeInstalledAsync: () => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Ensure Xcode is installed an recent enough to be used with Expo.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          true when Xcode is installed, false when the process should end.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        function expoVersionOnSimulatorAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                        expoVersionOnSimulatorAsync: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                        udid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        udid: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }) => Promise<string | null>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          function installExpoOnSimulatorAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                          installExpoOnSimulatorAsync: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                          url,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          simulator,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          version,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          }: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                          simulator: Pick<SimControl.SimulatorDevice, 'name' | 'udid'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          version?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          }) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            function isExpoClientInstalledOnSimulatorAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                            isExpoClientInstalledOnSimulatorAsync: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                            udid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            udid: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              function isPlatformSupported

                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPlatformSupported: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                function isSimulatorBootedAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                isSimulatorBootedAsync: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                udid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                udid?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }) => Promise<SimControl.SimulatorDevice | null>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function isSimulatorInstalledAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isSimulatorInstalledAsync: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function openProjectAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    openProjectAsync: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectRoot,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    shouldPrompt,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    devClient,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    udid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scheme,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    skipNativeLogs,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    applicationId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectRoot: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    shouldPrompt?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    devClient?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scheme?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    udid?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    skipNativeLogs?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    applicationId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }) => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | { success: true; url: string; udid: string; bundleIdentifier: string }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | { success: false; error: string }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function openWebProjectAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      openWebProjectAsync: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectRoot,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      shouldPrompt,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      shouldPrompt: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectRoot: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }) => Promise<{ success: true; url: string } | { success: false; error: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function promptForSimulatorAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        promptForSimulatorAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        devices: SimControl.SimulatorDevice[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        osType?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<SimControl.SimulatorDevice | null>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function resolveApplicationIdAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resolveApplicationIdAsync: (projectRoot: string) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function sortDefaultDeviceToBeginningAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sortDefaultDeviceToBeginningAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            devices: SimControl.SimulatorDevice[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            osType?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<SimControl.SimulatorDevice[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Sort the devices so the last simulator that was opened (user's default) is the first suggested.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter devices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function streamLogsAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            streamLogsAsync: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bundleIdentifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            udid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bundleIdentifier: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            udid: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function uninstallExpoAppFromSimulatorAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              uninstallExpoAppFromSimulatorAsync: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              udid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              udid?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function upgradeExpoAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                upgradeExpoAsync: (options?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                udid?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                url?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                version?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function waitForExpoClientInstalledOnSimulatorAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  waitForExpoClientInstalledOnSimulatorAsync: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  udid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  udid: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function waitForExpoClientUninstalledOnSimulatorAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    waitForExpoClientUninstalledOnSimulatorAsync: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    udid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    udid: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace ThirdParty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module 'build/ThirdParty.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function getManifest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getManifest: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        publicUrl: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { platform }?: { platform?: 'android' | 'ios' | 'all' }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace UrlUtils

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          module 'build/UrlUtils.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function constructAssetsUrlAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructAssetsUrlAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            entryPoint: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestHostname?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function constructBundleQueryParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructBundleQueryParams: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts: MetroQueryOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function constructBundleQueryParamsWithConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructBundleQueryParamsWithConfig: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts: MetroQueryOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                exp: Pick<ExpoConfig, 'sdkVersion'>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function constructBundleUrlAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructBundleUrlAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts: Partial<URLOptions>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  requestHostname?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function constructDebuggerHostAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructDebuggerHostAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    requestHostname?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function constructDeepLinkAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructDeepLinkAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: Partial<URLOptions>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      requestHostname?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function constructDevClientUrlAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructDevClientUrlAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: Partial<URLOptions>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        requestHostname?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function constructHostUriAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructHostUriAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          requestHostname?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function constructLoadingUrlAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructLoadingUrlAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            platform: 'ios' | 'android' | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestHostname?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function constructLogUrlAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructLogUrlAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              requestHostname?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function constructManifestUrlAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructManifestUrlAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: Partial<URLOptions>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                requestHostname?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function constructPublishUrlAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructPublishUrlAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  entryPoint: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  requestHostname?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  metroQueryOptions?: MetroQueryOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function constructSourceMapUrlAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructSourceMapUrlAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    entryPoint: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    requestHostname?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function constructUrlAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructUrlAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      incomingOpts: Partial<URLOptions> | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isPackager: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      requestHostname?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function constructUrlWithExtensionAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructUrlWithExtensionAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        entryPoint: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ext: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        requestHostname?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        metroQueryOptions?: MetroQueryOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function constructWebAppUrlAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructWebAppUrlAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: { hostType?: 'localhost' | 'lan' | 'tunnel' }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<string | null>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function isHttps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isHttps: (urlString: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function isURL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isURL: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              urlString: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protocols,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              requireProtocol,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }: { protocols?: string[]; requireProtocol?: boolean }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function stripJSExtension

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stripJSExtension: (entryPoint: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace Versions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  module 'build/Versions.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function canTurtleBuildSdkVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    canTurtleBuildSdkVersion: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sdkVersion: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    platform: keyof TurtleSDKVersions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function gteSdkVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gteSdkVersion: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      expJson: Pick<ExpoConfig, 'sdkVersion'>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sdkVersion: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function lteSdkVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lteSdkVersion: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        expJson: Pick<ExpoConfig, 'sdkVersion'>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sdkVersion: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function newestReleasedSdkVersionAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          newestReleasedSdkVersionAsync: () => Promise<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          version: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          data: SDKVersion | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function oldestSupportedMajorVersionAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            oldestSupportedMajorVersionAsync: () => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function parseSdkVersionFromTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseSdkVersionFromTag: (tag: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function releasedSdkVersionsAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                releasedSdkVersionsAsync: () => Promise<SDKVersions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function sdkVersionsAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sdkVersionsAsync: () => Promise<SDKVersions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function versionsAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    versionsAsync: (options?: { skipCache?: boolean }) => Promise<Versions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SDKVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SDKVersion = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      androidExpoViewUrl?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      expoReactNativeTag: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      exponentReactNativeTag?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      expokitNpmPackage?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      facebookReactNativeVersion: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      facebookReactVersion?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iosExpoViewUrl?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iosExponentViewUrl?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iosVersion?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isDeprecated?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      packagesToInstallWhenEjecting?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [name: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      releaseNoteUrl?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iosClientUrl?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      iosClientVersion?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      androidClientUrl?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      androidClientVersion?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      relatedPackages?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [name: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      beta?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SDKVersions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SDKVersions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [version: string]: SDKVersion;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace Webpack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          module 'build/Webpack.d.ts' {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Get the URL for the running instance of Webpack dev server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter projectRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function broadcastMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          broadcastMessage: (message: 'reload' | string, data?: any) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function bundleAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bundleAsync: (projectRoot: string, options?: BundlingOptions) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function getUrlAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getUrlAsync: (projectRoot: string) => Promise<string | null>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the URL for the running instance of Webpack dev server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter projectRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function openAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              openAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              projectRoot: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<{ success: true; url: string } | { success: false; error: Error }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function startAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                startAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                projectRoot: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: CLIWebOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<WebpackDevServerResults | null>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function stopAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stopAsync: (projectRoot: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WebEnvironment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WebEnvironment = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    projectRoot: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isImageEditingEnabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pwa: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mode: 'development' | 'production' | 'test' | 'none';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    https: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    logger: Log;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    port?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    platform?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type WebpackDevServerResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type WebpackDevServerResults = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      server: WebpackDevServer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      location: Omit<WebpackSettings, 'server'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      messageSocket: MessageSocket;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (50)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (63)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (19)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/xdl.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/xdl)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <a href="https://www.jsdocs.io/package/xdl"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>