@devicecloud.dev/dcd 5.6.0-beta.3 → 5.6.0

package/dist/services/device-validation.service.js

@@ -1,5 +1,35 @@
+const DEVICES_DOCS_URL = 'https://docs.devicecloud.dev/getting-started/devices-configuration';
+/** `dcd cloud`'s spelling; the MCP tool passes its own parameter names. */
+const CLI_ARG_NAMES = {
+    androidApiLevel: '--android-api-level',
+    androidDevice: '--android-device',
+    iOSDevice: '--ios-device',
+    iOSVersion: '--ios-version',
+};
+/** The versions a lookup offers for one device; empty when it offers none. */
+function versionsFor(lookup, device) {
+    // hasOwn, so a slug like "constructor" can't resolve to a prototype member.
+    if (!lookup || !Object.hasOwn(lookup, device))
+        return [];
+    const versions = lookup[device];
+    return Array.isArray(versions) ? versions : [];
+}
+/**
+ * Devices the lookup can actually run, in the API's order. A rollout gate can
+ * leave a device with no versions (every non-Play device has an empty Google
+ * Play list), and those must not be offered as alternatives.
+ */
+function offeredDevices(lookup) {
+    return Object.keys(lookup ?? {}).filter((device) => versionsFor(lookup, device).length > 0);
+}
 /**
- * Service for validating device configurations against compatibility data
+ * Validates requested devices against the compatibility matrix the API serves
+ * from `GET /results/compatibility/data`, which is the only authority on what
+ * can run. Nothing here consults the CLI's device and OS enums
+ * (src/types/domain/device.types.ts) — those only feed `--help` — so a device
+ * or OS version the API adds is accepted without a CLI release, and one it
+ * withdraws is refused, before anything is uploaded, with the list the API
+ * offers today.
  */
 export class DeviceValidationService {
     /**
@@ -13,6 +43,10 @@ export class DeviceValidationService {
      * @throws Error if device/API level combination is not supported
      */
     validateAndroidDevice(androidApiLevel, androidDevice, googlePlay, compatibilityData, options = {}) {
+        const lookup = googlePlay
+            ? compatibilityData.androidPlay
+            : compatibilityData.android;
+        const argNames = options.argNames ?? CLI_ARG_NAMES;
         this.validateDevice({
             debugLines: (deviceID, version, supportedVersions) => [
                 `[DEBUG] Android device: ${deviceID}`,
@@ -20,16 +54,27 @@ export class DeviceValidationService {
                 `[DEBUG] Google Play enabled: ${googlePlay}`,
                 `[DEBUG] Supported Android versions: ${supportedVersions.join(', ')}`,
             ],
+            // Mirrors the API, which applies these same global defaults to a
+            // request that omits either half (test-request-validator.service.ts)
+            // and then rejects an incompatible pair.
             defaultDevice: 'pixel-7',
             defaultVersion: '34',
             device: androidDevice,
-            lookup: googlePlay
-                ? compatibilityData.androidPlay
-                : compatibilityData.android,
-            noSupportMessage: () => `We don't support that device configuration - please check the docs for supported devices: https://docs.devicecloud.dev/getting-started/devices-configuration`,
+            deviceArg: argNames.androidDevice,
+            deviceKind: googlePlay ? 'Google Play' : 'Android',
+            formatVersion: (version) => `API level ${version}`,
+            lookup,
             options,
+            platform: 'Android',
+            // A real device that merely has no Google Play image deserves a sharper
+            // answer than "not supported".
+            unknownDeviceMessage: (deviceID) => googlePlay && versionsFor(compatibilityData.android, deviceID).length > 0
+                ? `Android device "${deviceID}" is not available with Google Play. Google Play devices: ${offeredDevices(lookup).join(', ')}. See ${DEVICES_DOCS_URL}`
+                : undefined,
             unsupportedVersionMessage: (deviceID, supportedVersions) => `${deviceID} ${googlePlay ? '(Play Store) ' : ''}only supports these Android API levels: ${supportedVersions.join(', ')}`,
             version: androidApiLevel,
+            versionArg: argNames.androidApiLevel,
+            versionName: 'Android API level',
         });
     }
     /**
@@ -42,20 +87,27 @@ export class DeviceValidationService {
      * @throws Error if device/version combination is not supported
      */
     validateiOSDevice(iOSVersion, iOSDevice, compatibilityData, options = {}) {
+        const argNames = options.argNames ?? CLI_ARG_NAMES;
         this.validateDevice({
             debugLines: (deviceID, version, supportedVersions) => [
                 `[DEBUG] iOS device: ${deviceID}`,
                 `[DEBUG] iOS version: ${version}`,
                 `[DEBUG] Supported iOS versions: ${supportedVersions.join(', ')}`,
             ],
+            // Mirrors the API's global defaults, as for Android above.
             defaultDevice: 'iphone-14',
             defaultVersion: '17',
             device: iOSDevice,
+            deviceArg: argNames.iOSDevice,
+            deviceKind: 'iOS',
+            formatVersion: (version) => `iOS ${version}`,
             lookup: compatibilityData?.ios,
-            noSupportMessage: (deviceID) => `Device ${deviceID} is not supported. Please check the docs for supported devices: https://docs.devicecloud.dev/getting-started/devices-configuration`,
             options,
+            platform: 'iOS',
             unsupportedVersionMessage: (deviceID, supportedVersions) => `${deviceID} only supports these iOS versions: ${supportedVersions.join(', ')}`,
             version: iOSVersion,
+            versionArg: argNames.iOSVersion,
+            versionName: 'iOS version',
         });
     }
     /**
@@ -66,20 +118,49 @@ export class DeviceValidationService {
      * @throws Error if device/version combination is not supported
      */
     validateDevice(config) {
-        const { debugLines, defaultDevice, defaultVersion, device, lookup, noSupportMessage, options, unsupportedVersionMessage, version, } = config;
+        const { debugLines, defaultDevice, defaultVersion, device, deviceArg, deviceKind, formatVersion, lookup, options, platform, unknownDeviceMessage, unsupportedVersionMessage, version, versionArg, versionName, } = config;
         const { debug = false, logger } = options;
         if (!version && !device) {
             return;
         }
         const deviceID = device || defaultDevice;
-        const supportedVersions = lookup?.[deviceID] || [];
+        const supportedVersions = versionsFor(lookup, deviceID);
         const requestedVersion = version || defaultVersion;
         if (supportedVersions.length === 0) {
-            throw new Error(noSupportMessage(deviceID));
+            if (!device) {
+                // Only a version was requested, and the API no longer offers the
+                // device the CLI assumes it defaults to. That assumption is what's
+                // stale, not the request: the API resolves and validates its own
+                // default device when the run is submitted.
+                if (debug && logger) {
+                    logger(`[DEBUG] Default ${platform} device ${deviceID} is not in the compatibility data; leaving the ${versionName} check to the API`);
+                }
+                return;
+            }
+            const offered = offeredDevices(lookup);
+            throw new Error(unknownDeviceMessage?.(deviceID) ??
+                (offered.length > 0
+                    ? `${platform} device "${deviceID}" is not supported. Supported ${deviceKind} devices: ${offered.join(', ')}. See ${DEVICES_DOCS_URL}`
+                    : `${platform} device "${deviceID}" is not supported. See ${DEVICES_DOCS_URL}`));
         }
-        if (Array.isArray(supportedVersions) &&
-            !supportedVersions.includes(requestedVersion)) {
-            throw new Error(unsupportedVersionMessage(deviceID, supportedVersions));
+        if (!supportedVersions.includes(requestedVersion)) {
+            const unsupported = unsupportedVersionMessage(deviceID, supportedVersions);
+            if (!version) {
+                // Device-only request. The API fills in the same global default
+                // version rather than one this device runs, so the submission would
+                // be refused there too — say so, and how to avoid it.
+                throw new Error(`${unsupported}. No ${versionName} was given, so the default (${defaultVersion}) was checked: pass one of those explicitly with ${versionArg}`);
+            }
+            if (!device) {
+                // Version-only request: name the device that was assumed, and the
+                // devices that do offer the requested version.
+                const devicesWithVersion = offeredDevices(lookup).filter((d) => versionsFor(lookup, d).includes(requestedVersion));
+                throw new Error(`${unsupported}. No ${platform} device was given, so the default (${deviceID}) was checked: ` +
+                    (devicesWithVersion.length > 0
+                        ? `pass one that offers ${formatVersion(requestedVersion)} with ${deviceArg}: ${devicesWithVersion.join(', ')}`
+                        : `no ${deviceKind} device offers ${formatVersion(requestedVersion)}`));
+            }
+            throw new Error(unsupported);
         }
         if (debug && logger) {
             for (const line of debugLines(deviceID, requestedVersion, supportedVersions)) {

package/dist/services/notices.service.js

@@ -80,6 +80,9 @@ function renderNotice(notice, opts) {
 export function platformFromAppFile(appFile) {
     if (!appFile)
         return undefined;
+    // Expo iOS simulator builds (`dcd cloud` extracts these to a .app first).
+    if (appFile.split('?')[0].toLowerCase().endsWith('.tar.gz'))
+        return 'ios';
     const ext = appFile.split('?')[0].toLowerCase().match(/.([a-z0-9]+)$/)?.[1];
     if (ext === 'apk' || ext === 'aab')
         return 'android';

package/dist/services/report-download.service.js

@@ -1,5 +1,6 @@
 import * as path from 'node:path';
 import { ApiGateway } from '../gateways/api-gateway.js';
+import { refreshAuth } from '../utils/auth.js';
 /**
  * Service for downloading test artifacts and reports
  */
@@ -15,7 +16,9 @@ export class ReportDownloadService {
             if (debug && logger) {
                 logger(`[DEBUG] Downloading artifacts: ${downloadType}`);
             }
-            await ApiGateway.downloadArtifactsZip(apiUrl, auth, uploadId, downloadType, artifactsPath);
+            // `dcd cloud` downloads after polling, which can outlast a `dcd login`
+            // token; a failed refresh lands in the warning below like any failure.
+            await ApiGateway.downloadArtifactsZip(apiUrl, await refreshAuth(auth), uploadId, downloadType, artifactsPath);
             if (logger) {
                 logger('\n');
                 logger(`Test artifacts have been downloaded to ${artifactsPath}`);
@@ -54,7 +57,9 @@ export class ReportDownloadService {
             }
             case 'html':
             case 'html-detailed': {
-                const htmlReportPath = path.resolve(process.cwd(), htmlPath || 'report.html');
+                // The HTML report is a ZIP (report.html plus its screenshots and
+                // assets), so the default name says so. An explicit path is kept as-is.
+                const htmlReportPath = path.resolve(process.cwd(), htmlPath || 'report.zip');
                 await this.downloadReport('html', htmlReportPath, {
                     ...downloadOptions,
                     warnLogger,
@@ -81,7 +86,8 @@ export class ReportDownloadService {
             if (debug && logger) {
                 logger(`[DEBUG] Downloading ${type.toUpperCase()} report`);
             }
-            await ApiGateway.downloadReportGeneric(apiUrl, auth, uploadId, type, filePath);
+            // As for artifacts: this can run after a poll that outlasted the token.
+            await ApiGateway.downloadReportGeneric(apiUrl, await refreshAuth(auth), uploadId, type, filePath);
             if (logger) {
                 logger(`${type.toUpperCase()} test report has been downloaded to ${filePath}`);
             }

package/dist/services/results-polling.service.d.ts

@@ -6,6 +6,14 @@ export declare class RunFailedError extends Error {
     result: PollingResult;
     constructor(result: PollingResult);
 }
+/**
+ * The `dcd login` session behind a poll expired and only a new login can fix
+ * it, so the poll stops at once instead of spending its retry budget — meant
+ * for network blips — on a failure that can't clear.
+ */
+export declare class PollingAuthError extends Error {
+    constructor(message: string);
+}
 export interface PollingOptions {
     auth: AuthContext;
     apiUrl: string;
@@ -115,6 +123,19 @@ export declare class ResultsPollingService {
      * @returns Promise resolving to test results
      */
     private fetchAndLogResults;
+    /**
+     * Swap in a fresh `dcd login` token when the current one is about to
+     * expire, and hand it to the realtime socket too; API-key auth comes back
+     * as-is. A transient refresh failure is thrown as-is, to be retried like
+     * any failed poll; one only `dcd login` can fix becomes a PollingAuthError.
+     * @param auth The credential the previous poll used
+     * @param uploadId Upload being polled, for the reconnect hint
+     * @param subscription Realtime subscription to pass a new token to
+     * @param debug Whether debug logging is enabled
+     * @param logger Optional logger function
+     * @returns The credential for the next poll
+     */
+    private refreshPollingAuth;
     private filterLatestResults;
     /**
      * Handle completed tests and return final result

package/dist/services/results-polling.service.js

@@ -2,6 +2,7 @@ import * as path from 'node:path';
 import { ApiGateway } from '../gateways/api-gateway.js';
 import { RealtimeResultsGateway, } from '../gateways/realtime-gateway.js';
 import { formatDurationSeconds } from '../methods.js';
+import { isDefinitiveAuthFailure, refreshAuth } from '../utils/auth.js';
 import { checkInternetConnectivity } from '../utils/connectivity.js';
 import { isCI } from '../utils/ci.js';
 import { ux } from '../utils/progress.js';
@@ -18,6 +19,17 @@ export class RunFailedError extends Error {
         this.name = 'RunFailedError';
     }
 }
+/**
+ * The `dcd login` session behind a poll expired and only a new login can fix
+ * it, so the poll stops at once instead of spending its retry budget — meant
+ * for network blips — on a failure that can't clear.
+ */
+export class PollingAuthError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PollingAuthError';
+    }
+}
 /**
  * Structured device for a result row. Prefers the friendly deviceName/osVersion
  * the per-flow targeting / matrix fan-out stamps onto each result's config
@@ -115,7 +127,10 @@ export class ResultsPollingService {
         }
     }
     async pollLoop(options, testMetadata) {
-        const { apiUrl, auth, uploadId, consoleUrl, quiet = false, json = false, debug = false, logger } = options;
+        const { apiUrl, uploadId, consoleUrl, quiet = false, json = false, debug = false, logger } = options;
+        // Re-checked before every poll: a run can outlast a `dcd login` access
+        // token (about an hour). API-key auth passes through unchanged.
+        let { auth } = options;
         this.initializePollingDisplay(json, logger);
         let sequentialPollFailures = 0;
         const pollIntervalMs = auth.mode === 'bearer'
@@ -213,6 +228,7 @@ export class ResultsPollingService {
                 try {
                     nextPollAt = null;
                     renderStatus();
+                    auth = await this.refreshPollingAuth(auth, uploadId, subscription, debug, logger);
                     const updatedResults = await this.fetchAndLogResults(apiUrl, auth, uploadId, debug, logger);
                     const { summary } = this.calculateStatusSummary(updatedResults);
                     if (!json) {
@@ -238,8 +254,9 @@ export class ResultsPollingService {
                     await waitForNextPoll(pollIntervalMs);
                 }
                 catch (error) {
-                    // Re-throw RunFailedError immediately (test failures, not polling errors)
-                    if (error instanceof RunFailedError) {
+                    // Re-throw RunFailedError immediately (test failures, not polling
+                    // errors), and an expired login no retry can fix.
+                    if (error instanceof RunFailedError || error instanceof PollingAuthError) {
                         throw error;
                     }
                     sequentialPollFailures++;
@@ -399,6 +416,41 @@ export class ResultsPollingService {
         }
         return updatedResults;
     }
+    /**
+     * Swap in a fresh `dcd login` token when the current one is about to
+     * expire, and hand it to the realtime socket too; API-key auth comes back
+     * as-is. A transient refresh failure is thrown as-is, to be retried like
+     * any failed poll; one only `dcd login` can fix becomes a PollingAuthError.
+     * @param auth The credential the previous poll used
+     * @param uploadId Upload being polled, for the reconnect hint
+     * @param subscription Realtime subscription to pass a new token to
+     * @param debug Whether debug logging is enabled
+     * @param logger Optional logger function
+     * @returns The credential for the next poll
+     */
+    async refreshPollingAuth(auth, uploadId, subscription, debug, logger) {
+        let next;
+        try {
+            next = await refreshAuth(auth);
+        }
+        catch (error) {
+            if (isDefinitiveAuthFailure(error)) {
+                const reason = error instanceof Error ? error.message : String(error);
+                throw new PollingAuthError(`Your dcd login session expired and could not be refreshed: ${reason}\n\n` +
+                    `The test is still running in the cloud. Run \`dcd login\`, then reconnect with:\n  dcd status --upload-id ${uploadId}`);
+            }
+            throw error;
+        }
+        if (next !== auth) {
+            if (debug && logger) {
+                logger('[DEBUG] Refreshed the dcd login session for polling');
+            }
+            if (next.accessToken && next.accessToken !== auth.accessToken) {
+                subscription?.updateAccessToken(next.accessToken);
+            }
+        }
+        return next;
+    }
     filterLatestResults(results) {
         // Resolve each row to the root of its retry chain (a retry's `retry_of`
         // may point at the previous retry rather than the original attempt), then

package/dist/services/test-submission.service.d.ts

@@ -6,6 +6,12 @@ export interface TestSubmissionConfig {
     androidNoSnapshot?: boolean;
     apiUrl?: string;
     appBinaryId: string;
+    /**
+     * Platform of the app binary, when the CLI can tell from a local file
+     * (.apk → android; .app / .zip / Expo .tar.gz → ios). Unknown for
+     * --app-binary-id, which falls back to the device flags.
+     */
+    appPlatform?: 'android' | 'ios';
     /**
      * Ask the API to cancel the still-queued tests of the previous run from
      * the same CI context. Sent as its own field rather than inside `config`,
@@ -19,6 +25,11 @@ export interface TestSubmissionConfig {
     debug?: boolean;
     deviceLocale?: string;
     deviceMatrix?: DeviceMatrixConfig[];
+    /**
+     * --disable-animations as given on the command line: true / false when the
+     * flag (or --no-disable-animations) was passed, undefined when it wasn't —
+     * only then does the workspace config's per-platform value apply.
+     */
     disableAnimations?: boolean;
     /**
      * Encrypt the flow zip and env vars before upload (#1151/#1152), each with its

package/dist/services/test-submission.service.js

@@ -20,7 +20,7 @@ export class TestSubmissionService {
      * @returns The flow zip buffer, its SHA-256, and the string-encoded fields
      */
     async buildTestPayload(config) {
-        const { apiUrl, appBinaryId, encrypt = false, flowFile, executionPlan, commonRoot, cliVersion, env = [], metadata = [], cancelPrevious = false, googlePlay = false, androidApiLevel, androidDevice, androidNoSnapshot, iOSVersion, iOSDevice, name, runnerType, maestroVersion, deviceLocale, orientation, retry, continueOnFailure = true, renderEngine, report, showCrosshairs, maestroChromeOnboarding, raw, disableAnimations, deviceMatrix, debug = false, logger, } = config;
+        const { apiUrl, appBinaryId, appPlatform, encrypt = false, flowFile, executionPlan, commonRoot, cliVersion, env = [], metadata = [], cancelPrevious = false, googlePlay = false, androidApiLevel, androidDevice, androidNoSnapshot, iOSVersion, iOSDevice, name, runnerType, maestroVersion, deviceLocale, orientation, retry, continueOnFailure = true, renderEngine, report, showCrosshairs, maestroChromeOnboarding, raw, disableAnimations, deviceMatrix, debug = false, logger, } = config;
         const { allExcludeTags, allIncludeTags, flowMetadata, flowOverrides, flowsToRun: testFileNames, includedFiles = [], referencedFiles, sequence, workspaceConfig, } = executionPlan;
         const { flows: sequentialFlows = [] } = sequence ?? {};
         const envObject = this.parseKeyValuePairs(env);
@@ -120,18 +120,25 @@ export class TestSubmissionService {
             fields.deviceMatrix = JSON.stringify(deviceMatrix);
         }
         // Platform used only to pick which workspace-config disableAnimations flag
-        // applies. A device matrix is single-platform; its first cell decides. Fall
-        // back to the scalar iOS flags for single-device submissions.
+        // applies. The binary decides when the CLI knows it — otherwise an iOS run
+        // without --ios-device/--ios-version read the android block. For an
+        // --app-binary-id, a device matrix (single-platform; its first cell
+        // decides) or the scalar iOS flags are the best evidence left.
         const matrixPlatform = deviceMatrix && deviceMatrix.length > 0
             ? 'iOSDevice' in deviceMatrix[0]
                 ? 'ios'
                 : 'android'
             : undefined;
-        const targetPlatform = matrixPlatform ?? (iOSDevice || iOSVersion ? 'ios' : 'android');
+        const targetPlatform = appPlatform ??
+            matrixPlatform ??
+            (iOSDevice || iOSVersion ? 'ios' : 'android');
         const configYamlDisableAnimations = targetPlatform === 'ios'
             ? Boolean(workspaceConfig?.platform?.ios?.disableAnimations)
             : Boolean(workspaceConfig?.platform?.android?.disableAnimations);
-        const effectiveDisableAnimations = disableAnimations || configYamlDisableAnimations;
+        // An explicit --disable-animations / --no-disable-animations wins over
+        // config.yaml; previously `flag || config` meant the flag could only ever
+        // turn animations off, never keep them on against the config.
+        const effectiveDisableAnimations = disableAnimations ?? configYamlDisableAnimations;
         const configPayload = {
             allExcludeTags,
             allIncludeTags,

package/dist/types/domain/auth.types.d.ts

@@ -13,6 +13,12 @@ export interface AuthContext {
     accessToken?: string;
     /** Environment the session belongs to — present when mode === 'bearer'. */
     env?: DcdEnvName;
+    /**
+     * Unix epoch seconds at which `accessToken` expires — present when
+     * mode === 'bearer'. Long-lived callers check it (utils/auth.ts
+     * isAuthExpiring / refreshAuth) because the headers below stop working then.
+     */
+    expiresAt?: number;
     /** Present when mode === 'bearer'. */
     orgId?: string;
     /** Present when mode === 'bearer'. */

package/dist/types/domain/device.types.d.ts

@@ -1,17 +1,31 @@
 /**
  * Device type definitions - should be kept in sync with API
- * @see /Users/riglar/repos/dcd/api/src/common/types/device.types.ts
+ * @see dcd/api/src/common/types/device.types.ts
+ *
+ * These drive the `--ios-device` / `--ios-version` / `--android-device` /
+ * `--android-api-level` help text and nothing else: validation runs against
+ * the live compatibility payload (device-validation.service.ts). A value the
+ * API has dropped gets a "not supported" error listing what it offers now, and
+ * one it has added is accepted even if it is missing here — so keeping these
+ * lists current only improves the help text; it never gates a run.
+ *
+ * `iphone-14-pro` and `iphone-15-pro` were listed here but have never existed
+ * in the API enum; removed 2026-09-21 rather than carried forward.
  */
 export declare enum EiOSDevices {
     'ipad-pro-6th-gen' = "ipad-pro-6th-gen",
+    'ipad-pro-m5-11' = "ipad-pro-m5-11",
+    'ipad-pro-m5-13' = "ipad-pro-m5-13",
     'iphone-14' = "iphone-14",
-    'iphone-14-pro' = "iphone-14-pro",
     'iphone-15' = "iphone-15",
-    'iphone-15-pro' = "iphone-15-pro",
     'iphone-16' = "iphone-16",
     'iphone-16-plus' = "iphone-16-plus",
     'iphone-16-pro' = "iphone-16-pro",
-    'iphone-16-pro-max' = "iphone-16-pro-max"
+    'iphone-16-pro-max' = "iphone-16-pro-max",
+    'iphone-17' = "iphone-17",
+    'iphone-18-pro' = "iphone-18-pro",
+    'iphone-18-pro-max' = "iphone-18-pro-max",
+    'iphone-air' = "iphone-air"
 }
 export declare enum EAndroidDevices {
     'generic-tablet' = "generic-tablet",

package/dist/types/domain/device.types.js

@@ -1,18 +1,32 @@
 /**
  * Device type definitions - should be kept in sync with API
- * @see /Users/riglar/repos/dcd/api/src/common/types/device.types.ts
+ * @see dcd/api/src/common/types/device.types.ts
+ *
+ * These drive the `--ios-device` / `--ios-version` / `--android-device` /
+ * `--android-api-level` help text and nothing else: validation runs against
+ * the live compatibility payload (device-validation.service.ts). A value the
+ * API has dropped gets a "not supported" error listing what it offers now, and
+ * one it has added is accepted even if it is missing here — so keeping these
+ * lists current only improves the help text; it never gates a run.
+ *
+ * `iphone-14-pro` and `iphone-15-pro` were listed here but have never existed
+ * in the API enum; removed 2026-09-21 rather than carried forward.
  */
 export var EiOSDevices;
 (function (EiOSDevices) {
     EiOSDevices["ipad-pro-6th-gen"] = "ipad-pro-6th-gen";
+    EiOSDevices["ipad-pro-m5-11"] = "ipad-pro-m5-11";
+    EiOSDevices["ipad-pro-m5-13"] = "ipad-pro-m5-13";
     EiOSDevices["iphone-14"] = "iphone-14";
-    EiOSDevices["iphone-14-pro"] = "iphone-14-pro";
     EiOSDevices["iphone-15"] = "iphone-15";
-    EiOSDevices["iphone-15-pro"] = "iphone-15-pro";
     EiOSDevices["iphone-16"] = "iphone-16";
     EiOSDevices["iphone-16-plus"] = "iphone-16-plus";
     EiOSDevices["iphone-16-pro"] = "iphone-16-pro";
     EiOSDevices["iphone-16-pro-max"] = "iphone-16-pro-max";
+    EiOSDevices["iphone-17"] = "iphone-17";
+    EiOSDevices["iphone-18-pro"] = "iphone-18-pro";
+    EiOSDevices["iphone-18-pro-max"] = "iphone-18-pro-max";
+    EiOSDevices["iphone-air"] = "iphone-air";
 })(EiOSDevices || (EiOSDevices = {}));
 export var EAndroidDevices;
 (function (EAndroidDevices) {