eas-cli 18.4.0 → 18.6.0

package/build/metadata/apple/tasks/previews.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreviewsTask = void 0;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const fetch_1 = tslib_1.__importDefault(require("../../../fetch"));
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const log_2 = require("../../utils/log");
+const task_1 = require("../task");
+/**
+ * Normalize preview config to always return an object with path and optional previewFrameTimeCode.
+ */
+function normalizePreviewConfig(config) {
+    if (typeof config === 'string') {
+        return { path: config };
+    }
+    return config;
+}
+/**
+ * Task for managing App Store video previews.
+ * Downloads existing previews and uploads new ones based on store configuration.
+ */
+class PreviewsTask extends task_1.AppleTask {
+    name = () => 'video previews';
+    async prepareAsync({ context }) {
+        // Initialize the preview sets map
+        context.previewSets = new Map();
+        if (!context.versionLocales) {
+            return;
+        }
+        // Fetch preview sets for all locales in parallel
+        await Promise.all(context.versionLocales.map(async (locale) => {
+            const sets = await locale.getAppPreviewSetsAsync();
+            const previewTypeMap = new Map();
+            for (const set of sets) {
+                previewTypeMap.set(set.attributes.previewType, set);
+            }
+            context.previewSets.set(locale.attributes.locale, previewTypeMap);
+        }));
+    }
+    async downloadAsync({ config, context }) {
+        if (!context.previewSets || !context.versionLocales) {
+            return;
+        }
+        for (const locale of context.versionLocales) {
+            const localeCode = locale.attributes.locale;
+            const previewTypeMap = context.previewSets.get(localeCode);
+            if (!previewTypeMap || previewTypeMap.size === 0) {
+                continue;
+            }
+            const previews = {};
+            for (const [previewType, set] of previewTypeMap) {
+                const previewModels = set.attributes.appPreviews;
+                if (!previewModels || previewModels.length === 0) {
+                    continue;
+                }
+                // For now, we only handle the first preview per set (App Store allows up to 3)
+                // We can extend this later to support multiple previews
+                const preview = previewModels[0];
+                const downloaded = await downloadPreviewAsync(context.projectDir, localeCode, previewType, preview, 0);
+                // When the download succeeds, write the real path. When it fails
+                // (e.g. the preview is in a broken AWAITING_UPLOAD state with no
+                // rendered videoUrl), preserve the entry in config so the user can
+                // either drop in a replacement file or remove the entry to delete
+                // the broken ASC record.
+                const fileName = preview.attributes.fileName || 'preview.mp4';
+                const relativePath = downloaded || path_1.default.join('store', 'apple', 'preview', localeCode, previewType, fileName);
+                if (preview.attributes.previewFrameTimeCode) {
+                    previews[previewType] = {
+                        path: relativePath,
+                        previewFrameTimeCode: preview.attributes.previewFrameTimeCode,
+                    };
+                }
+                else {
+                    previews[previewType] = relativePath;
+                }
+            }
+            if (Object.keys(previews).length > 0) {
+                config.setPreviews(localeCode, previews);
+            }
+        }
+    }
+    async uploadAsync({ config, context }) {
+        if (!context.previewSets || !context.versionLocales) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped video previews, no version available}`);
+            return;
+        }
+        const locales = config.getLocales();
+        if (locales.length <= 0) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped video previews, no locales configured}`);
+            return;
+        }
+        for (const localeCode of locales) {
+            const previews = config.getPreviews(localeCode);
+            if (!previews || Object.keys(previews).length === 0) {
+                continue;
+            }
+            const localization = context.versionLocales.find(l => l.attributes.locale === localeCode);
+            if (!localization) {
+                log_1.default.warn((0, chalk_1.default) `{yellow Skipping video previews for ${localeCode} - locale not found}`);
+                continue;
+            }
+            for (const [previewType, previewConfig] of Object.entries(previews)) {
+                if (!previewConfig) {
+                    continue;
+                }
+                await syncPreviewSetAsync(context.projectDir, localization, previewType, normalizePreviewConfig(previewConfig), context.previewSets.get(localeCode));
+            }
+        }
+    }
+}
+exports.PreviewsTask = PreviewsTask;
+/**
+ * Sync a preview set - upload new preview, delete old one if changed.
+ */
+async function syncPreviewSetAsync(projectDir, localization, previewType, previewConfig, existingSets) {
+    const locale = localization.attributes.locale;
+    const absolutePath = path_1.default.resolve(projectDir, previewConfig.path);
+    const fileName = path_1.default.basename(absolutePath);
+    if (!fs_1.default.existsSync(absolutePath)) {
+        log_1.default.warn((0, chalk_1.default) `{yellow Video preview not found: ${absolutePath}}`);
+        return;
+    }
+    // Get or create the preview set
+    let previewSet = existingSets?.get(previewType);
+    if (!previewSet) {
+        previewSet = await (0, log_2.logAsync)(() => localization.createAppPreviewSetAsync({
+            previewType,
+        }), {
+            pending: `Creating preview set for ${chalk_1.default.bold(previewType)} (${locale})...`,
+            success: `Created preview set for ${chalk_1.default.bold(previewType)} (${locale})`,
+            failure: `Failed creating preview set for ${chalk_1.default.bold(previewType)} (${locale})`,
+        });
+    }
+    const existingPreviews = previewSet.attributes.appPreviews || [];
+    // Check if we need to update (different filename, size, or no existing preview)
+    const existingPreview = existingPreviews.find(p => p.attributes.fileName === fileName);
+    const localSize = fs_1.default.statSync(absolutePath).size;
+    if (existingPreview &&
+        existingPreview.isComplete() &&
+        existingPreview.attributes.fileSize === localSize) {
+        // Preview with same filename exists, check if we need to update preview frame time code
+        if (previewConfig.previewFrameTimeCode &&
+            existingPreview.attributes.previewFrameTimeCode !== previewConfig.previewFrameTimeCode) {
+            await (0, log_2.logAsync)(() => existingPreview.updateAsync({
+                previewFrameTimeCode: previewConfig.previewFrameTimeCode,
+            }), {
+                pending: `Updating preview frame time code for ${chalk_1.default.bold(fileName)} (${locale})...`,
+                success: `Updated preview frame time code for ${chalk_1.default.bold(fileName)} (${locale})`,
+                failure: `Failed updating preview frame time code for ${chalk_1.default.bold(fileName)} (${locale})`,
+            });
+        }
+        log_1.default.log((0, chalk_1.default) `{dim Preview ${fileName} already exists, skipping upload}`);
+        return;
+    }
+    // Delete existing previews that don't match
+    for (const preview of existingPreviews) {
+        if (preview.attributes.fileName !== fileName) {
+            await (0, log_2.logAsync)(() => preview.deleteAsync(), {
+                pending: `Deleting old preview ${chalk_1.default.bold(preview.attributes.fileName)} (${locale})...`,
+                success: `Deleted old preview ${chalk_1.default.bold(preview.attributes.fileName)} (${locale})`,
+                failure: `Failed deleting old preview ${chalk_1.default.bold(preview.attributes.fileName)} (${locale})`,
+            });
+        }
+    }
+    // Upload new preview
+    await (0, log_2.logAsync)(() => apple_utils_1.AppPreview.uploadAsync(localization.context, {
+        id: previewSet.id,
+        filePath: absolutePath,
+        waitForProcessing: true,
+        previewFrameTimeCode: previewConfig.previewFrameTimeCode,
+    }), {
+        pending: `Uploading video preview ${chalk_1.default.bold(fileName)} (${locale})...`,
+        success: `Uploaded video preview ${chalk_1.default.bold(fileName)} (${locale})`,
+        failure: `Failed uploading video preview ${chalk_1.default.bold(fileName)} (${locale})`,
+    });
+}
+/**
+ * Download a video preview to the local filesystem.
+ * Returns the relative path to the downloaded file.
+ */
+async function downloadPreviewAsync(projectDir, locale, previewType, preview, index) {
+    const videoUrl = preview.getVideoUrl();
+    if (!videoUrl) {
+        log_1.default.warn((0, chalk_1.default) `{yellow Could not get download URL for preview ${preview.attributes.fileName}}`);
+        return null;
+    }
+    // Create directory structure: store/apple/preview/{locale}/{previewType}/
+    const previewsDir = path_1.default.join(projectDir, 'store', 'apple', 'preview', locale, previewType);
+    await fs_1.default.promises.mkdir(previewsDir, { recursive: true });
+    // Use original filename for matching during sync
+    const fileName = preview.attributes.fileName || `${String(index + 1).padStart(2, '0')}.mp4`;
+    const outputPath = path_1.default.join(previewsDir, fileName);
+    const relativePath = path_1.default.relative(projectDir, outputPath);
+    try {
+        const response = await (0, fetch_1.default)(videoUrl);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const buffer = await response.buffer();
+        await fs_1.default.promises.writeFile(outputPath, buffer);
+        log_1.default.log((0, chalk_1.default) `{dim Downloaded video preview: ${relativePath}}`);
+        return relativePath;
+    }
+    catch (error) {
+        log_1.default.warn((0, chalk_1.default) `{yellow Failed to download video preview ${fileName}: ${error.message}}`);
+        return null;
+    }
+}

package/build/metadata/apple/tasks/screenshots.d.ts

@@ -0,0 +1,18 @@
+import { AppScreenshotSet, ScreenshotDisplayType } from '@expo/apple-utils';
+import { AppleTask, TaskDownloadOptions, TaskPrepareOptions, TaskUploadOptions } from '../task';
+/** Locale -> ScreenshotDisplayType -> AppScreenshotSet */
+export type ScreenshotSetsMap = Map<string, Map<ScreenshotDisplayType, AppScreenshotSet>>;
+export type ScreenshotsData = {
+    /** Map of locales to their screenshot sets */
+    screenshotSets: ScreenshotSetsMap;
+};
+/**
+ * Task for managing App Store screenshots.
+ * Downloads existing screenshots and uploads new ones based on store configuration.
+ */
+export declare class ScreenshotsTask extends AppleTask {
+    name: () => string;
+    prepareAsync({ context }: TaskPrepareOptions): Promise<void>;
+    downloadAsync({ config, context }: TaskDownloadOptions): Promise<void>;
+    uploadAsync({ config, context }: TaskUploadOptions): Promise<void>;
+}

package/build/metadata/apple/tasks/screenshots.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScreenshotsTask = void 0;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const fetch_1 = tslib_1.__importDefault(require("../../../fetch"));
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const log_2 = require("../../utils/log");
+const task_1 = require("../task");
+/**
+ * Task for managing App Store screenshots.
+ * Downloads existing screenshots and uploads new ones based on store configuration.
+ */
+class ScreenshotsTask extends task_1.AppleTask {
+    name = () => 'screenshots';
+    async prepareAsync({ context }) {
+        // Initialize the screenshot sets map
+        context.screenshotSets = new Map();
+        if (!context.versionLocales) {
+            return;
+        }
+        // Fetch screenshot sets for all locales in parallel
+        await Promise.all(context.versionLocales.map(async (locale) => {
+            const sets = await locale.getAppScreenshotSetsAsync();
+            const displayTypeMap = new Map();
+            for (const set of sets) {
+                displayTypeMap.set(set.attributes.screenshotDisplayType, set);
+            }
+            context.screenshotSets.set(locale.attributes.locale, displayTypeMap);
+        }));
+    }
+    async downloadAsync({ config, context }) {
+        if (!context.screenshotSets || !context.versionLocales) {
+            return;
+        }
+        for (const locale of context.versionLocales) {
+            const localeCode = locale.attributes.locale;
+            const displayTypeMap = context.screenshotSets.get(localeCode);
+            if (!displayTypeMap || displayTypeMap.size === 0) {
+                continue;
+            }
+            const screenshots = {};
+            for (const [displayType, set] of displayTypeMap) {
+                const screenshotModels = set.attributes.appScreenshots;
+                if (!screenshotModels || screenshotModels.length === 0) {
+                    continue;
+                }
+                // Download screenshots and save to local filesystem. When a screenshot
+                // is in a broken state (AWAITING_UPLOAD with no rendered imageAsset)
+                // the download will fail, but we still preserve the entry pointing at
+                // its expected local path so users can either drop in a replacement
+                // file or remove the entry to delete the broken ASC record.
+                const paths = [];
+                for (let i = 0; i < screenshotModels.length; i++) {
+                    const screenshot = screenshotModels[i];
+                    const downloaded = await downloadScreenshotAsync(context.projectDir, localeCode, displayType, screenshot, i);
+                    if (downloaded) {
+                        paths.push(downloaded);
+                        continue;
+                    }
+                    // Fall back to a placeholder path so the entry isn't lost from
+                    // config. Push will detect that the existing screenshot isn't
+                    // complete and either re-upload (if a local file exists at this
+                    // path) or warn and skip (if it doesn't).
+                    const fileName = screenshot.attributes.fileName || `${String(i + 1).padStart(2, '0')}.png`;
+                    paths.push(path_1.default.join('store', 'apple', 'screenshot', localeCode, displayType, fileName));
+                }
+                if (paths.length > 0) {
+                    screenshots[displayType] = paths;
+                }
+            }
+            if (Object.keys(screenshots).length > 0) {
+                config.setScreenshots(localeCode, screenshots);
+            }
+        }
+    }
+    async uploadAsync({ config, context }) {
+        if (!context.screenshotSets || !context.versionLocales) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped screenshots, no version available}`);
+            return;
+        }
+        const locales = config.getLocales();
+        if (locales.length <= 0) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped screenshots, no locales configured}`);
+            return;
+        }
+        for (const localeCode of locales) {
+            const screenshots = config.getScreenshots(localeCode);
+            if (!screenshots || Object.keys(screenshots).length === 0) {
+                continue;
+            }
+            const localization = context.versionLocales.find(l => l.attributes.locale === localeCode);
+            if (!localization) {
+                log_1.default.warn((0, chalk_1.default) `{yellow Skipping screenshots for ${localeCode} - locale not found}`);
+                continue;
+            }
+            for (const [displayType, paths] of Object.entries(screenshots)) {
+                if (!paths || paths.length === 0) {
+                    continue;
+                }
+                await syncScreenshotSetAsync(context.projectDir, localization, displayType, paths, context.screenshotSets.get(localeCode));
+            }
+        }
+    }
+}
+exports.ScreenshotsTask = ScreenshotsTask;
+/**
+ * Sync a screenshot set - upload new screenshots, delete removed ones, reorder if needed.
+ */
+async function syncScreenshotSetAsync(projectDir, localization, displayType, paths, existingSets) {
+    const locale = localization.attributes.locale;
+    // Get or create the screenshot set
+    let screenshotSet = existingSets?.get(displayType);
+    if (!screenshotSet) {
+        screenshotSet = await (0, log_2.logAsync)(() => localization.createAppScreenshotSetAsync({
+            screenshotDisplayType: displayType,
+        }), {
+            pending: `Creating screenshot set for ${chalk_1.default.bold(displayType)} (${locale})...`,
+            success: `Created screenshot set for ${chalk_1.default.bold(displayType)} (${locale})`,
+            failure: `Failed creating screenshot set for ${chalk_1.default.bold(displayType)} (${locale})`,
+        });
+    }
+    const existingScreenshots = screenshotSet.attributes.appScreenshots || [];
+    // Build a map of existing screenshots by filename for comparison
+    const existingByFilename = new Map();
+    for (const screenshot of existingScreenshots) {
+        existingByFilename.set(screenshot.attributes.fileName, screenshot);
+    }
+    // Track which screenshots to keep, upload, and delete
+    const screenshotIdsToKeep = [];
+    const pathsToUpload = [];
+    for (const relativePath of paths) {
+        const absolutePath = path_1.default.resolve(projectDir, relativePath);
+        const fileName = path_1.default.basename(absolutePath);
+        // Check if screenshot already exists with same name and file size
+        const existing = existingByFilename.get(fileName);
+        const localSize = fs_1.default.existsSync(absolutePath) ? fs_1.default.statSync(absolutePath).size : null;
+        if (existing &&
+            existing.isComplete() &&
+            (localSize === null || existing.attributes.fileSize === localSize)) {
+            screenshotIdsToKeep.push(existing.id);
+            existingByFilename.delete(fileName);
+        }
+        else {
+            pathsToUpload.push(absolutePath);
+        }
+    }
+    // Delete screenshots that are no longer in config
+    for (const screenshot of existingByFilename.values()) {
+        await (0, log_2.logAsync)(() => screenshot.deleteAsync(), {
+            pending: `Deleting screenshot ${chalk_1.default.bold(screenshot.attributes.fileName)} (${locale})...`,
+            success: `Deleted screenshot ${chalk_1.default.bold(screenshot.attributes.fileName)} (${locale})`,
+            failure: `Failed deleting screenshot ${chalk_1.default.bold(screenshot.attributes.fileName)} (${locale})`,
+        });
+    }
+    // Upload new screenshots
+    for (const absolutePath of pathsToUpload) {
+        const fileName = path_1.default.basename(absolutePath);
+        if (!fs_1.default.existsSync(absolutePath)) {
+            log_1.default.warn((0, chalk_1.default) `{yellow Screenshot not found: ${absolutePath}}`);
+            continue;
+        }
+        const newScreenshot = await (0, log_2.logAsync)(() => apple_utils_1.AppScreenshot.uploadAsync(localization.context, {
+            id: screenshotSet.id,
+            filePath: absolutePath,
+            waitForProcessing: true,
+        }), {
+            pending: `Uploading screenshot ${chalk_1.default.bold(fileName)} (${locale})...`,
+            success: `Uploaded screenshot ${chalk_1.default.bold(fileName)} (${locale})`,
+            failure: `Failed uploading screenshot ${chalk_1.default.bold(fileName)} (${locale})`,
+        });
+        screenshotIdsToKeep.push(newScreenshot.id);
+    }
+    // Reorder screenshots to match config order
+    if (screenshotIdsToKeep.length > 0) {
+        const refreshedSet = await apple_utils_1.AppScreenshotSet.infoAsync(localization.context, {
+            id: screenshotSet.id,
+        });
+        const refreshedScreenshots = refreshedSet.attributes.appScreenshots || [];
+        const screenshotsByFilename = new Map();
+        for (const s of refreshedScreenshots) {
+            screenshotsByFilename.set(s.attributes.fileName, s);
+        }
+        // Build the desired order based on config paths
+        const orderedIds = [];
+        for (const relativePath of paths) {
+            const fileName = path_1.default.basename(relativePath);
+            const screenshot = screenshotsByFilename.get(fileName);
+            if (screenshot) {
+                orderedIds.push(screenshot.id);
+            }
+        }
+        // Only call reorder if the order actually differs from current
+        const currentIds = refreshedScreenshots.map(s => s.id);
+        if (orderedIds.length > 0 &&
+            (orderedIds.length !== currentIds.length || orderedIds.some((id, i) => id !== currentIds[i]))) {
+            await screenshotSet.reorderScreenshotsAsync({ appScreenshots: orderedIds });
+        }
+    }
+}
+/**
+ * Download a screenshot to the local filesystem.
+ * Returns the relative path to the downloaded file.
+ */
+async function downloadScreenshotAsync(projectDir, locale, displayType, screenshot, index) {
+    const imageUrl = screenshot.getImageAssetUrl({ type: 'png' });
+    if (!imageUrl) {
+        log_1.default.warn((0, chalk_1.default) `{yellow Could not get download URL for screenshot ${screenshot.attributes.fileName}}`);
+        return null;
+    }
+    // Create directory structure: store/apple/screenshot/{locale}/{displayType}/
+    const screenshotsDir = path_1.default.join(projectDir, 'store', 'apple', 'screenshot', locale, displayType);
+    await fs_1.default.promises.mkdir(screenshotsDir, { recursive: true });
+    // Use original filename for matching during sync
+    const fileName = screenshot.attributes.fileName || `${String(index + 1).padStart(2, '0')}.png`;
+    const outputPath = path_1.default.join(screenshotsDir, fileName);
+    const relativePath = path_1.default.relative(projectDir, outputPath);
+    try {
+        const response = await (0, fetch_1.default)(imageUrl);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const buffer = await response.buffer();
+        await fs_1.default.promises.writeFile(outputPath, buffer);
+        log_1.default.log((0, chalk_1.default) `{dim Downloaded screenshot: ${relativePath}}`);
+        return relativePath;
+    }
+    catch (error) {
+        log_1.default.warn((0, chalk_1.default) `{yellow Failed to download screenshot ${fileName}: ${error.message}}`);
+        return null;
+    }
+}

package/build/metadata/apple/types.d.ts

@@ -1,5 +1,33 @@
-import type { AgeRatingDeclarationProps } from '@expo/apple-utils';
+import type { AgeRatingDeclarationProps, AppClipAction, PreviewType, ScreenshotDisplayType } from '@expo/apple-utils';
 export type AppleLocale = string;
+/** Screenshot display type enum values from App Store Connect API */
+export type AppleScreenshotDisplayType = `${ScreenshotDisplayType}`;
+/** Preview display type enum values from App Store Connect API */
+export type ApplePreviewType = `${PreviewType}`;
+/**
+ * Screenshots organized by display type.
+ * Key is the display type (e.g., 'APP_IPHONE_67'), value is array of file paths.
+ * @example { "APP_IPHONE_67": ["./screenshots/home.png", "./screenshots/profile.png"] }
+ */
+export type AppleScreenshots = Partial<Record<AppleScreenshotDisplayType, string[]>>;
+/**
+ * Video preview configuration - either a simple path string or an object with options.
+ * @example "./previews/demo.mp4"
+ * @example { path: "./previews/demo.mp4", previewFrameTimeCode: "00:05:00" }
+ */
+export type ApplePreviewConfig = string | {
+    /** Video file path (relative to project root) */
+    path: string;
+    /** Optional preview frame time code (e.g., '00:05:00' for 5 seconds) */
+    previewFrameTimeCode?: string;
+};
+/**
+ * Video previews organized by display type.
+ * Key is the display type (e.g., 'IPHONE_67'), value is the preview config.
+ * @example { "IPHONE_67": "./previews/demo.mp4" }
+ * @example { "IPHONE_67": { path: "./previews/demo.mp4", previewFrameTimeCode: "00:05:00" } }
+ */
+export type ApplePreviews = Partial<Record<ApplePreviewType, ApplePreviewConfig>>;
 export interface AppleMetadata {
     version?: string;
     copyright?: string;
@@ -7,8 +35,36 @@ export interface AppleMetadata {
     categories?: AppleCategory;
     release?: AppleRelease;
     advisory?: AppleAdvisory;
+    /** @deprecated Use screenshots/previews in AppleInfo instead */
     preview?: Record<string, string[]>;
     review?: AppleReview;
+    /** App Clip metadata. Only applies to apps that ship an App Clip target. */
+    appClip?: AppleAppClip;
+}
+/** App Clip action enum values from App Store Connect API */
+export type AppleAppClipAction = `${AppClipAction}`;
+export interface AppleAppClip {
+    /** The default experience for this App Clip. There is exactly one per app. */
+    defaultExperience?: AppleAppClipDefaultExperience;
+}
+export interface AppleAppClipDefaultExperience {
+    /** Action button shown in the App Clip card. Defaults to OPEN if unset. */
+    action?: AppleAppClipAction;
+    /** Whether to release this default experience alongside the next App Store version. */
+    releaseWithAppStoreVersion?: boolean;
+    /** App Store review invocation URLs (used by App Review to launch the clip). */
+    reviewDetail?: AppleAppClipReviewDetail;
+    /** Per-locale subtitle and header image. */
+    info?: Record<AppleLocale, AppleAppClipLocalizedInfo>;
+}
+export interface AppleAppClipReviewDetail {
+    invocationUrls: string[];
+}
+export interface AppleAppClipLocalizedInfo {
+    /** Subtitle shown in the App Clip card. Apple limits this to 43 characters. */
+    subtitle?: string;
+    /** Relative path (from project root) to the App Clip header image PNG. */
+    headerImage?: string;
 }
 export type AppleAdvisory = Omit<Partial<AgeRatingDeclarationProps>, 'seventeenPlus' | 'gamblingAndContests'>;
 /** Apps can define up to two categories, or categories with up to two subcategories */
@@ -30,6 +86,10 @@ export interface AppleInfo {
     privacyPolicyText?: string;
     privacyChoicesUrl?: string;
     supportUrl?: string;
+    /** Screenshots for this locale, organized by display type */
+    screenshots?: AppleScreenshots;
+    /** Video previews for this locale, organized by display type */
+    previews?: ApplePreviews;
 }
 export interface AppleReview {
     firstName: string;

package/build/metadata/auth.d.ts

@@ -1,6 +1,7 @@
 import { App, Session } from '@expo/apple-utils';
 import { ExpoConfig } from '@expo/config';
 import { SubmitProfile } from '@expo/eas-json';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { CredentialsContext } from '../credentials/context';
 export type MetadataAppStoreAuthentication = {
     /** The root entity of the App store */
@@ -11,10 +12,19 @@ export type MetadataAppStoreAuthentication = {
 /**
  * To start syncing ASC entities, we need access to the apple utils App instance.
  * This resolves both the authentication and that App instance.
+ *
+ * Resolution order for authentication:
+ * 1. ASC API key from environment variables (EXPO_ASC_API_KEY_PATH, etc.)
+ * 2. ASC API key from submit profile (ascApiKeyPath, etc. in eas.json)
+ * 3. ASC API key from EAS credentials service
+ * 4. Interactive cookie auth (only when not in non-interactive mode)
  */
-export declare function getAppStoreAuthAsync({ projectDir, profile, exp, credentialsCtx, }: {
+export declare function getAppStoreAuthAsync({ projectDir, profile, exp, credentialsCtx, nonInteractive, graphqlClient, projectId, }: {
     projectDir: string;
     profile: SubmitProfile;
     exp: ExpoConfig;
     credentialsCtx: CredentialsContext;
+    nonInteractive: boolean;
+    graphqlClient: ExpoGraphqlClient;
+    projectId: string;
 }): Promise<MetadataAppStoreAuthentication>;