@donotuse/eas-cli 18.5.0-rc.1

package/build/project/ios/versions.d.ts

@@ -0,0 +1,3 @@
+export declare const BUILD_NUMBER_REQUIREMENTS = "buildNumber needs to consist only of up to 3 dot-separated positive integers";
+export declare function isValidBuildNumber(buildNumber: string): boolean;
+export declare function getNextBuildNumber(buildNumber: string): string;

package/build/project/ios/versions.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILD_NUMBER_REQUIREMENTS = void 0;
+exports.isValidBuildNumber = isValidBuildNumber;
+exports.getNextBuildNumber = getNextBuildNumber;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+exports.BUILD_NUMBER_REQUIREMENTS = `buildNumber needs to consist only of up to 3 dot-separated positive integers`;
+function isValidBuildNumber(buildNumber) {
+    return !!buildNumber.match(/^\d+(\.\d+)?(\.\d+)?$/);
+}
+function getNextBuildNumber(buildNumber) {
+    (0, assert_1.default)(isValidBuildNumber(buildNumber), `Invalid buildNumber ${buildNumber}`);
+    const comps = buildNumber.split('.');
+    comps[comps.length - 1] = String(Number(comps[comps.length - 1]) + 1);
+    return comps.join('.');
+}

package/build/project/maybeUploadAssetMapAsync.d.ts

@@ -0,0 +1,3 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { AssetMapSourceInput } from '../graphql/generated';
+export declare function maybeUploadAssetMapAsync(distRoot: string, graphqlClient: ExpoGraphqlClient): Promise<AssetMapSourceInput | null>;

package/build/project/maybeUploadAssetMapAsync.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeUploadAssetMapAsync = maybeUploadAssetMapAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const generated_1 = require("../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const uploads_1 = require("../uploads");
+const files_1 = require("../utils/files");
+const progress_1 = require("../utils/progress");
+async function maybeUploadAssetMapAsync(distRoot, graphqlClient) {
+    const assetMapPath = path_1.default.join(distRoot, 'assetmap.json');
+    if (!(await fs_extra_1.default.pathExists(assetMapPath))) {
+        return null;
+    }
+    let gcsBucketKey = undefined;
+    const fileStat = await fs_extra_1.default.promises.stat(assetMapPath);
+    try {
+        gcsBucketKey = await (0, uploads_1.uploadFileAtPathToGCSAsync)(graphqlClient, generated_1.UploadSessionType.EasUpdateAssetsMetadata, assetMapPath, (0, progress_1.createProgressTracker)({
+            total: fileStat.size,
+            message: ratio => `Uploading assetmap.json (${(0, files_1.formatBytes)(fileStat.size * ratio)} / ${(0, files_1.formatBytes)(fileStat.size)})`,
+            completedMessage: (duration) => `Uploaded assetmap.json ${chalk_1.default.dim(duration)}`,
+        }));
+    }
+    catch (err) {
+        let errMessage = 'Failed to upload assetmap to EAS';
+        if (err.message) {
+            errMessage += `\n\nReason: ${err.message}`;
+        }
+        log_1.default.warn(errMessage);
+        return null;
+    }
+    return {
+        type: generated_1.AssetMapSourceType.Gcs,
+        bucketKey: gcsBucketKey,
+    };
+}

package/build/project/maybeUploadFingerprintAsync.d.ts

@@ -0,0 +1,15 @@
+import { LocalBuildMode } from '../build/local';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { FingerprintSourceInput } from '../graphql/generated';
+export declare function maybeUploadFingerprintAsync({ hash, fingerprint, graphqlClient, localBuildMode, }: {
+    hash: string;
+    fingerprint: {
+        fingerprintSources: object[];
+        isDebugFingerprintSource: boolean;
+    };
+    graphqlClient: ExpoGraphqlClient;
+    localBuildMode?: LocalBuildMode;
+}): Promise<{
+    hash: string;
+    fingerprintSource?: FingerprintSourceInput;
+}>;

package/build/project/maybeUploadFingerprintAsync.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeUploadFingerprintAsync = maybeUploadFingerprintAsync;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const uuid_1 = require("uuid");
+const local_1 = require("../build/local");
+const generated_1 = require("../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const uploads_1 = require("../uploads");
+const paths_1 = require("../utils/paths");
+async function maybeUploadFingerprintAsync({ hash, fingerprint, graphqlClient, localBuildMode, }) {
+    if (localBuildMode === local_1.LocalBuildMode.LOCAL_BUILD_PLUGIN) {
+        // We're not uploading local build fingerprints to EAS
+        return {
+            hash,
+        };
+    }
+    await fs_extra_1.default.mkdirp((0, paths_1.getTmpDirectory)());
+    const fingerprintLocation = path_1.default.join((0, paths_1.getTmpDirectory)(), `${(0, uuid_1.v4)()}-runtime-fingerprint.json`);
+    await fs_extra_1.default.writeJSON(fingerprintLocation, {
+        hash,
+        sources: fingerprint.fingerprintSources,
+    });
+    let fingerprintGCSBucketKey = undefined;
+    try {
+        fingerprintGCSBucketKey = await (0, uploads_1.uploadFileAtPathToGCSAsync)(graphqlClient, generated_1.UploadSessionType.EasUpdateFingerprint, fingerprintLocation);
+    }
+    catch (err) {
+        let errMessage = 'Failed to upload fingerprint to EAS';
+        if (err.message) {
+            errMessage += `\n\nReason: ${err.message}`;
+        }
+        log_1.default.warn(errMessage);
+        return {
+            hash,
+        };
+    }
+    finally {
+        await fs_extra_1.default.remove(fingerprintLocation);
+    }
+    return {
+        hash,
+        fingerprintSource: {
+            type: generated_1.FingerprintSourceType.Gcs,
+            bucketKey: fingerprintGCSBucketKey,
+            isDebugFingerprint: fingerprint.isDebugFingerprintSource,
+        },
+    };
+}

package/build/project/metroConfig.d.ts

@@ -0,0 +1,3 @@
+import { Platform } from '@expo/eas-build-job';
+import { BuildContext } from '../build/context';
+export declare function validateMetroConfigForManagedWorkflowAsync(ctx: BuildContext<Platform>): Promise<void>;

package/build/project/metroConfig.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMetroConfigForManagedWorkflowAsync = validateMetroConfigForManagedWorkflowAsync;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const resolve_from_1 = tslib_1.__importDefault(require("resolve-from"));
+const log_1 = tslib_1.__importStar(require("../log"));
+const prompts_1 = require("../prompts");
+async function validateMetroConfigForManagedWorkflowAsync(ctx) {
+    if (!(await configExistsAsync(ctx.projectDir))) {
+        return;
+    }
+    const metroConfig = await loadConfigAsync(ctx.projectDir);
+    // SDK <50 | plugins whose presence can be used to determine if the config is extending Expo's Metro config
+    const hasHashAssetFilesPlugin = metroConfig.transformer?.assetPlugins?.find((plugin) => plugin.match(/expo-asset[/|\\]tools[/|\\]hashAssetFiles/));
+    // SDK >=51 | this is a custom property that we inject to ensure cache invalidation between projects.
+    const isExtendingExpoMetroConfig = metroConfig.transformer.hasOwnProperty('_expoRelativeProjectRoot');
+    if (!isExtendingExpoMetroConfig && !hasHashAssetFilesPlugin) {
+        log_1.default.warn(`It looks like that you are using a custom ${chalk_1.default.bold('metro.config.js')} that does not extend ${chalk_1.default.bold('@expo/metro-config')}.`);
+        log_1.default.warn('This can result in unexpected and hard to debug issues, like missing assets in the production bundle.');
+        if (!ctx.nonInteractive) {
+            log_1.default.warn(`We recommend you to abort, fix the ${chalk_1.default.bold('metro.config.js')}, and try again.`);
+        }
+        log_1.default.warn((0, log_1.learnMore)('https://docs.expo.dev/guides/customizing-metro/', {
+            learnMoreMessage: 'Learn more on customizing Metro',
+        }));
+        if (ctx.nonInteractive) {
+            log_1.default.warn("You've run EAS CLI in non-interactive mode, proceeding...");
+            return;
+        }
+        const shouldAbort = await (0, prompts_1.confirmAsync)({
+            message: 'Would you like to abort?',
+        });
+        if (shouldAbort) {
+            log_1.default.error('Aborting...');
+            core_1.Errors.exit(1);
+        }
+    }
+}
+function importMetroConfigFromProject(projectDir) {
+    const resolvedPath = resolve_from_1.default.silent(projectDir, 'metro-config');
+    if (!resolvedPath) {
+        throw new MetroConfigPackageMissingError('Missing package "metro-config" in the project. ' +
+            'This usually means `react-native` is not installed. ' +
+            'Verify that dependencies in package.json include "react-native" ' +
+            'and run `yarn` or `npm install`.');
+    }
+    return require(resolvedPath);
+}
+async function configExistsAsync(projectRoot) {
+    try {
+        const MetroConfig = importMetroConfigFromProject(projectRoot);
+        const result = await MetroConfig.resolveConfig(undefined, projectRoot);
+        return !result.isEmpty;
+    }
+    catch (err) {
+        if (err instanceof MetroConfigPackageMissingError) {
+            return false;
+        }
+        else {
+            throw err;
+        }
+    }
+}
+async function loadConfigAsync(projectDir) {
+    const MetroConfig = importMetroConfigFromProject(projectDir);
+    return await MetroConfig.loadConfig({ cwd: projectDir }, {});
+}
+class MetroConfigPackageMissingError extends Error {
+}

package/build/project/projectUtils.d.ts

@@ -0,0 +1,26 @@
+import { ExpoConfig } from '@expo/config';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { AccountFragment } from '../graphql/generated';
+/**
+ * Return a useful name describing the project config.
+ * - dynamic: app.config.js
+ * - static: app.json
+ * - custom path app config relative to root folder
+ * - both: app.config.js or app.json
+ */
+export declare function getProjectConfigDescription(projectDir: string): string;
+export declare function isExpoUpdatesInstalled(projectDir: string): boolean;
+export declare function isExpoNotificationsInstalled(projectDir: string): boolean;
+export declare function isExpoInstalled(projectDir: string): boolean;
+export declare function isExpoUpdatesInstalledAsDevDependency(projectDir: string): boolean;
+export declare function isExpoUpdatesInstalledOrAvailable(projectDir: string, sdkVersion?: string): boolean;
+export declare function isUsingEASUpdate(exp: ExpoConfig, projectId: string, manifestHostOverride: string | null): boolean;
+export declare function getExpoUpdatesPackageVersionIfInstalledAsync(projectDir: string): Promise<string | null>;
+export declare function validateAppVersionRuntimePolicySupportAsync(projectDir: string, exp: ExpoConfig): Promise<void>;
+export declare function enforceRollBackToEmbeddedUpdateSupportAsync(projectDir: string): Promise<void>;
+export declare function isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync(projectDir: string): Promise<boolean>;
+export declare function installExpoUpdatesAsync(projectDir: string, options?: {
+    silent: boolean;
+}): Promise<void>;
+export declare function getOwnerAccountForProjectIdAsync(graphqlClient: ExpoGraphqlClient, projectId: string): Promise<AccountFragment>;
+export declare function getDisplayNameForProjectIdAsync(graphqlClient: ExpoGraphqlClient, projectId: string): Promise<string>;

package/build/project/projectUtils.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectConfigDescription = getProjectConfigDescription;
+exports.isExpoUpdatesInstalled = isExpoUpdatesInstalled;
+exports.isExpoNotificationsInstalled = isExpoNotificationsInstalled;
+exports.isExpoInstalled = isExpoInstalled;
+exports.isExpoUpdatesInstalledAsDevDependency = isExpoUpdatesInstalledAsDevDependency;
+exports.isExpoUpdatesInstalledOrAvailable = isExpoUpdatesInstalledOrAvailable;
+exports.isUsingEASUpdate = isUsingEASUpdate;
+exports.getExpoUpdatesPackageVersionIfInstalledAsync = getExpoUpdatesPackageVersionIfInstalledAsync;
+exports.validateAppVersionRuntimePolicySupportAsync = validateAppVersionRuntimePolicySupportAsync;
+exports.enforceRollBackToEmbeddedUpdateSupportAsync = enforceRollBackToEmbeddedUpdateSupportAsync;
+exports.isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync = isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync;
+exports.installExpoUpdatesAsync = installExpoUpdatesAsync;
+exports.getOwnerAccountForProjectIdAsync = getOwnerAccountForProjectIdAsync;
+exports.getDisplayNameForProjectIdAsync = getDisplayNameForProjectIdAsync;
+const tslib_1 = require("tslib");
+const config_1 = require("@expo/config");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const resolve_from_1 = tslib_1.__importDefault(require("resolve-from"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
+const api_1 = require("../api");
+const AppQuery_1 = require("../graphql/queries/AppQuery");
+const log_1 = tslib_1.__importStar(require("../log"));
+const expoCli_1 = require("../utils/expoCli");
+/**
+ * Return a useful name describing the project config.
+ * - dynamic: app.config.js
+ * - static: app.json
+ * - custom path app config relative to root folder
+ * - both: app.config.js or app.json
+ */
+function getProjectConfigDescription(projectDir) {
+    const paths = (0, config_1.getConfigFilePaths)(projectDir);
+    if (paths.dynamicConfigPath) {
+        const relativeDynamicConfigPath = path_1.default.relative(projectDir, paths.dynamicConfigPath);
+        if (paths.staticConfigPath) {
+            return `${relativeDynamicConfigPath} or ${path_1.default.relative(projectDir, paths.staticConfigPath)}`;
+        }
+        return relativeDynamicConfigPath;
+    }
+    else if (paths.staticConfigPath) {
+        return path_1.default.relative(projectDir, paths.staticConfigPath);
+    }
+    return 'app.config.js/app.json';
+}
+function isExpoUpdatesInstalled(projectDir) {
+    const packageJson = (0, config_1.getPackageJson)(projectDir);
+    return !!(packageJson.dependencies && 'expo-updates' in packageJson.dependencies);
+}
+function isExpoNotificationsInstalled(projectDir) {
+    const packageJson = (0, config_1.getPackageJson)(projectDir);
+    return !!(packageJson.dependencies && 'expo-notifications' in packageJson.dependencies);
+}
+function isExpoInstalled(projectDir) {
+    const packageJson = (0, config_1.getPackageJson)(projectDir);
+    return !!(packageJson.dependencies && 'expo' in packageJson.dependencies);
+}
+function isExpoUpdatesInstalledAsDevDependency(projectDir) {
+    const packageJson = (0, config_1.getPackageJson)(projectDir);
+    return !!(packageJson.devDependencies && 'expo-updates' in packageJson.devDependencies);
+}
+function isExpoUpdatesInstalledOrAvailable(projectDir, sdkVersion) {
+    // before sdk 44, expo-updates was included in with the expo module
+    if (sdkVersion && semver_1.default.lt(sdkVersion, '44.0.0')) {
+        return true;
+    }
+    return isExpoUpdatesInstalled(projectDir);
+}
+function isUsingEASUpdate(exp, projectId, manifestHostOverride) {
+    return exp.updates?.url === (0, api_1.getEASUpdateURL)(projectId, manifestHostOverride);
+}
+async function getExpoUpdatesPackageVersionIfInstalledAsync(projectDir) {
+    const maybePackageJson = resolve_from_1.default.silent(projectDir, 'expo-updates/package.json');
+    if (!maybePackageJson) {
+        return null;
+    }
+    const { version } = await fs_extra_1.default.readJson(maybePackageJson);
+    return version ?? null;
+}
+async function validateAppVersionRuntimePolicySupportAsync(projectDir, exp) {
+    if (typeof exp.runtimeVersion !== 'object' || exp.runtimeVersion?.policy !== 'appVersion') {
+        return;
+    }
+    const expoUpdatesPackageVersion = await getExpoUpdatesPackageVersionIfInstalledAsync(projectDir);
+    if (expoUpdatesPackageVersion !== null &&
+        (semver_1.default.gte(expoUpdatesPackageVersion, '0.14.4') ||
+            expoUpdatesPackageVersion.includes('canary'))) {
+        return;
+    }
+    log_1.default.warn(`You need to be on SDK 46 or higher, and use expo-updates >= 0.14.4 to use appVersion runtime policy.`);
+}
+async function enforceRollBackToEmbeddedUpdateSupportAsync(projectDir) {
+    const expoUpdatesPackageVersion = await getExpoUpdatesPackageVersionIfInstalledAsync(projectDir);
+    if (expoUpdatesPackageVersion !== null &&
+        (semver_1.default.gte(expoUpdatesPackageVersion, '0.19.0') ||
+            expoUpdatesPackageVersion.includes('canary'))) {
+        return;
+    }
+    throw new Error(`The expo-updates package must have a version >= 0.19.0 to use roll back to embedded, which corresponds to Expo SDK 50 or greater. ${(0, log_1.learnMore)('https://docs.expo.dev/workflow/upgrading-expo-sdk-walkthrough/')}`);
+}
+async function isModernExpoUpdatesCLIWithRuntimeVersionCommandSupportedAsync(projectDir) {
+    const expoUpdatesPackageVersion = await getExpoUpdatesPackageVersionIfInstalledAsync(projectDir);
+    if (expoUpdatesPackageVersion === null) {
+        return false;
+    }
+    if (expoUpdatesPackageVersion.includes('canary')) {
+        return true;
+    }
+    // Anything SDK 51 or greater uses the expo-updates CLI
+    return semver_1.default.gte(expoUpdatesPackageVersion, '0.25.4');
+}
+async function installExpoUpdatesAsync(projectDir, options) {
+    log_1.default.log(chalk_1.default.gray `> npx expo install expo-updates`);
+    try {
+        await (0, expoCli_1.expoCommandAsync)(projectDir, ['install', 'expo-updates'], { silent: options?.silent });
+    }
+    catch (error) {
+        if (options?.silent) {
+            log_1.default.error('stdout' in error ? error.stdout : error.message);
+        }
+        throw error;
+    }
+}
+async function getOwnerAccountForProjectIdAsync(graphqlClient, projectId) {
+    const app = await AppQuery_1.AppQuery.byIdAsync(graphqlClient, projectId);
+    return app.ownerAccount;
+}
+async function getDisplayNameForProjectIdAsync(graphqlClient, projectId) {
+    const app = await AppQuery_1.AppQuery.byIdAsync(graphqlClient, projectId);
+    return app.fullName;
+}

package/build/project/publish.d.ts

@@ -0,0 +1,233 @@
+import { ExpoConfig, Platform as ExpoConfigPlatform } from '@expo/config';
+import { Env, Platform, Workflow } from '@expo/eas-build-job';
+import Joi from 'joi';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { PaginatedQueryOptions } from '../commandUtils/pagination';
+import { BuildFragment, FingerprintSourceInput, PartialManifestAsset, UpdateRolloutInfoGroup } from '../graphql/generated';
+import { RequestedPlatform } from '../platform';
+import { UpdateJsonInfo, UpdatePublishPlatform } from '../update/utils';
+import { Client } from '../vcs/vcs';
+type Metadata = {
+    version: number;
+    bundler: 'metro';
+    fileMetadata: {
+        [key in ExpoConfigPlatform]: {
+            assets: {
+                path: string;
+                ext: string;
+            }[];
+            bundle: string;
+        };
+    };
+};
+export type RawAsset = {
+    fileExtension?: string;
+    contentType: string;
+    path: string;
+    /** Original asset path derrived from asset map, or exported folder */
+    originalPath?: string;
+};
+type CollectedAssets = {
+    [platform in ExpoConfigPlatform]?: {
+        launchAsset: RawAsset;
+        assets: RawAsset[];
+    };
+};
+type ManifestExtra = {
+    expoClient?: {
+        [key: string]: any;
+    };
+    [key: string]: any;
+};
+type ManifestFragment = {
+    launchAsset: PartialManifestAsset;
+    assets: PartialManifestAsset[];
+    extra?: ManifestExtra;
+};
+type UpdateInfoGroup = {
+    [key in UpdatePublishPlatform]: ManifestFragment;
+};
+export type AssetMap = Record<string, {
+    httpServerLocation: string;
+    name: string;
+    type: string;
+}>;
+export declare const MetadataJoi: Joi.ObjectSchema<any>;
+export declare function guessContentTypeFromExtension(ext?: string): string;
+export declare function getBase64URLEncoding(buffer: Buffer): string;
+/**
+ * The storage key is used to store the asset in GCS
+ */
+export declare function getStorageKey(contentType: string, contentHash: string): string;
+/**
+ * Convenience function that computes an assets storage key starting from its buffer.
+ */
+export declare function getStorageKeyForAssetAsync(asset: RawAsset): Promise<string>;
+export declare function convertAssetToUpdateInfoGroupFormatAsync(asset: RawAsset): Promise<PartialManifestAsset>;
+/**
+ * This will be sorted later based on the platform's runtime versions.
+ */
+export declare function buildUnsortedUpdateInfoGroupAsync(assets: FilteredCollectedAssets, exp: ExpoConfig): Promise<Partial<UpdateInfoGroup>>;
+export type ExpoCLIExportPlatformFlag = ExpoConfigPlatform | 'all';
+export declare function buildBundlesAsync({ projectDir, inputDir, exp, platformFlag, clearCache, noBytecode, sourceMaps, extraEnv, }: {
+    projectDir: string;
+    inputDir: string;
+    exp: Pick<ExpoConfig, 'sdkVersion' | 'web'>;
+    platformFlag: ExpoCLIExportPlatformFlag;
+    clearCache?: boolean;
+    noBytecode?: boolean;
+    sourceMaps?: string;
+    extraEnv?: Record<string, string | undefined> | undefined;
+}): Promise<void>;
+export declare function resolveInputDirectoryAsync(inputDir: string, { skipBundler }: {
+    skipBundler?: boolean;
+}): Promise<string>;
+export declare function loadMetadata(distRoot: string): Metadata;
+export declare function generateEasMetadataAsync(distRoot: string, metadata: UpdateJsonInfo[]): Promise<void>;
+export type FilteredCollectedAssets = {
+    [RequestedPlatform.Ios]?: NonNullable<CollectedAssets['ios']>;
+    [RequestedPlatform.Android]?: NonNullable<CollectedAssets['android']>;
+};
+export declare function filterCollectedAssetsByRequestedPlatforms(collectedAssets: CollectedAssets, requestedPlatform: RequestedPlatform): FilteredCollectedAssets;
+export declare function getAssetHashFromPath(assetPath: string): string | null;
+export declare function getOriginalPathFromAssetMap(assetMap: AssetMap | null, asset: {
+    path: string;
+    ext: string;
+}): string | null;
+/** Given a directory, load the metadata.json and collect the assets for each platform. */
+export declare function collectAssetsAsync(dir: string): Promise<CollectedAssets>;
+export declare function filterOutAssetsThatAlreadyExistAsync(graphqlClient: ExpoGraphqlClient, uniqueAssetsWithStorageKey: (RawAsset & {
+    storageKey: string;
+})[]): Promise<(RawAsset & {
+    storageKey: string;
+})[]>;
+type AssetUploadResult = {
+    /** All found assets within the exported folder per platform */
+    assetCount: number;
+    /** The uploaded JS bundles, per platform */
+    launchAssetCount: number;
+    /** All unique assets within the exported folder with platforms combined */
+    uniqueAssetCount: number;
+    /** All unique assets uploaded  */
+    uniqueUploadedAssetCount: number;
+    /** All (non-launch) asset original paths, used for logging */
+    uniqueUploadedAssetPaths: string[];
+    /** The asset limit received from the server */
+    assetLimitPerUpdateGroup: number;
+};
+export declare function uploadAssetsAsync(graphqlClient: ExpoGraphqlClient, assetsForUpdateInfoGroup: FilteredCollectedAssets, projectId: string, cancelationToken: {
+    isCanceledOrFinished: boolean;
+}, onAssetUploadResultsChanged: (assetUploadResults: {
+    asset: RawAsset & {
+        storageKey: string;
+    };
+    finished: boolean;
+}[]) => void, onAssetUploadBegin: () => void): Promise<AssetUploadResult>;
+export declare function isUploadedAssetCountAboveWarningThreshold(uploadedAssetCount: number, assetLimitPerUpdateGroup: number): boolean;
+export declare function getBranchNameForCommandAsync({ graphqlClient, projectId, channelNameArg, branchNameArg, autoFlag, nonInteractive, paginatedQueryOptions, vcsClient, }: {
+    graphqlClient: ExpoGraphqlClient;
+    projectId: string;
+    channelNameArg: string | undefined;
+    branchNameArg: string | undefined;
+    autoFlag: boolean;
+    nonInteractive: boolean;
+    paginatedQueryOptions: PaginatedQueryOptions;
+    vcsClient: Client;
+}): Promise<string>;
+export declare function getUpdateMessageForCommandAsync(vcsClient: Client, { updateMessageArg, autoFlag, nonInteractive, jsonFlag, }: {
+    updateMessageArg: string | undefined;
+    autoFlag: boolean;
+    nonInteractive: boolean;
+    jsonFlag: boolean;
+}): Promise<string | undefined>;
+export declare const defaultPublishPlatforms: UpdatePublishPlatform[];
+export type RuntimeVersionInfo = {
+    runtimeVersion: string;
+    expoUpdatesRuntimeFingerprint: {
+        fingerprintSources: object[];
+        isDebugFingerprintSource: boolean;
+    } | null;
+    expoUpdatesRuntimeFingerprintHash: string | null;
+};
+type FingerprintInfoGroup = {
+    [key in UpdatePublishPlatform]?: FingerprintInfo;
+};
+type FingerprintInfo = {
+    fingerprintHash: string;
+    fingerprintSource: FingerprintSourceInput;
+};
+export declare function getRuntimeVersionInfoObjectsAsync({ exp, platforms, workflows, projectDir, env, }: {
+    exp: ExpoConfig;
+    platforms: UpdatePublishPlatform[];
+    workflows: Record<ExpoConfigPlatform, Workflow>;
+    projectDir: string;
+    env: Env | undefined;
+}): Promise<{
+    platform: UpdatePublishPlatform;
+    runtimeVersionInfo: RuntimeVersionInfo;
+}[]>;
+export declare function getRuntimeToPlatformsAndFingerprintInfoMappingFromRuntimeVersionInfoObjects(runtimeVersionInfoObjects: {
+    platform: UpdatePublishPlatform;
+    runtimeVersionInfo: RuntimeVersionInfo;
+}[]): (RuntimeVersionInfo & {
+    platforms: UpdatePublishPlatform[];
+})[];
+export declare function maybeCalculateFingerprintForRuntimeVersionInfoObjectsWithoutExpoUpdatesAsync({ projectDir, graphqlClient, runtimeToPlatformsAndFingerprintInfoAndFingerprintSourceMapping, workflowsByPlatform, env, }: {
+    projectDir: string;
+    graphqlClient: ExpoGraphqlClient;
+    runtimeToPlatformsAndFingerprintInfoAndFingerprintSourceMapping: (RuntimeVersionInfo & {
+        platforms: UpdatePublishPlatform[];
+        expoUpdatesRuntimeFingerprintSource: FingerprintSourceInput | null;
+    })[];
+    workflowsByPlatform: Record<Platform, Workflow>;
+    env: Env | undefined;
+}): Promise<(RuntimeVersionInfo & {
+    platforms: UpdatePublishPlatform[];
+    expoUpdatesRuntimeFingerprintSource: FingerprintSourceInput | null;
+    fingerprintInfoGroup: FingerprintInfoGroup;
+})[]>;
+export declare function findCompatibleBuildsAsync(graphqlClient: ExpoGraphqlClient, appId: string, runtimeToPlatformsAndFingerprintInfoMapping: {
+    runtimeVersion: string;
+    platforms: UpdatePublishPlatform[];
+    fingerprintInfoGroup: FingerprintInfoGroup;
+}): Promise<{
+    runtimeVersion: string;
+    platforms: UpdatePublishPlatform[];
+    fingerprintInfoGroupWithCompatibleBuilds: {
+        android?: (FingerprintInfo & {
+            build?: BuildFragment;
+        }) | undefined;
+        ios?: (FingerprintInfo & {
+            build?: BuildFragment;
+        }) | undefined;
+    };
+}>;
+export declare const platformDisplayNames: Record<UpdatePublishPlatform, string>;
+export declare function getRuntimeToUpdateRolloutInfoGroupMappingAsync(graphqlClient: ExpoGraphqlClient, { appId, branchName, rolloutPercentage, runtimeToPlatformsAndFingerprintInfoMapping, }: {
+    appId: string;
+    branchName: string;
+    rolloutPercentage: number;
+    runtimeToPlatformsAndFingerprintInfoMapping: (RuntimeVersionInfo & {
+        platforms: UpdatePublishPlatform[];
+    })[];
+}): Promise<Map<string, UpdateRolloutInfoGroup>>;
+export declare function getUpdateRolloutInfoGroupAsync(graphqlClient: ExpoGraphqlClient, { appId, branchName, rolloutPercentage, runtimeVersion, platforms, }: {
+    appId: string;
+    branchName: string;
+    rolloutPercentage: number;
+    runtimeVersion: string;
+    platforms: UpdatePublishPlatform[];
+}): Promise<UpdateRolloutInfoGroup>;
+/**
+ * Get the command line arguments for source map generation in expo export.
+ *
+ * Uses --source-maps if provided, otherwise falls back to --dump-sourcemap.
+ * SDK 55+ supports --source-maps with a value (e.g., 'inline'), but older SDKs
+ * only support it as a boolean flag. Passing a value to older SDKs causes it
+ * to be parsed as the project root positional argument.
+ */
+export declare function getSourceMapExportCommandArgs({ sourceMaps, sdkVersion, }: {
+    sourceMaps: string | undefined;
+    sdkVersion: string | undefined;
+}): string[];
+export {};