rn-update-cli 1.0.0

package/lib/versions.js

@@ -0,0 +1,402 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionCommands = exports.describePpkBundleForTests = exports.normalizeDeps = exports.fetchVersions = exports.bindVersionToPackages = void 0;
+/**
+ * [INPUT]: 依赖 Hermes bundle 摘要、对象上传、渠道版本组 API 与旧绑定 API
+ * [OUTPUT]: 对外提供 full 发布、批量渠道组投放、逐构建 pdiff 登记、版本查询和兼容绑定命令，并上报 Hermes 校验结果
+ * [POS]: CLI 发布编排层，独立服务按 (channel, packageVersion) 原子生成草稿并发布，pdiff 始终绑定精确 nativeVersion
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const compare_versions_1 = require("compare-versions");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const api_1 = require("./api");
+const app_1 = require("./app");
+const package_1 = require("./package");
+const standalone_publish_1 = require("./standalone-publish");
+const utils_1 = require("./utils");
+const dep_versions_1 = require("./utils/dep-versions");
+const git_1 = require("./utils/git");
+const hbcTransform_1 = require("./utils/hbcTransform");
+const hermes_base_1 = require("./utils/hermes-base");
+const http_helper_1 = require("./utils/http-helper");
+const i18n_1 = require("./utils/i18n");
+const options_1 = require("./utils/options");
+const slim_sourcemap_1 = require("./utils/slim-sourcemap");
+const zip_range_1 = require("./utils/zip-range");
+const version_operations_1 = require("./version-operations");
+var version_operations_2 = require("./version-operations");
+Object.defineProperty(exports, "bindVersionToPackages", { enumerable: true, get: function () { return version_operations_2.bindVersionToPackages; } });
+Object.defineProperty(exports, "fetchVersions", { enumerable: true, get: function () { return version_operations_2.fetchVersions; } });
+Object.defineProperty(exports, "normalizeDeps", { enumerable: true, get: function () { return version_operations_2.normalizeDeps; } });
+/**
+ * Content identity of the ppk's bundle for the server (bundleHash, HBC version)
+ * plus the base used to compile it, and a copy of the bundle in the local
+ * cache so it can serve as a future base without a download.
+ */
+async function describePpkBundle(ppkPath, base) {
+    // Only known values are sent: the server's optional-field parsers treat an
+    // explicit JSON null as invalid (that contract broke 2.22.0/2.22.1 publishes
+    // with "Expected baseHash string"), and omitting a field is what every
+    // server version — strict, tolerant or too old to know the field — accepts.
+    const meta = {};
+    try {
+        // one pass over the ppk: the bundle itself plus where its compressed
+        // bytes live, so the next build can fetch just them with one HTTP Range
+        // request
+        const found = ppkPath.toLowerCase().endsWith('.ppk')
+            ? await (0, zip_range_1.readZipEntryWithLocation)(ppkPath, (name) => hermes_base_1.BUNDLE_ENTRY_NAMES.includes(name)).catch(() => null)
+            : null;
+        const bundle = found?.data ?? (await (0, hermes_base_1.extractBundleFromArchive)(ppkPath));
+        if (bundle) {
+            const bundleHash = (0, hermes_base_1.sha256Hex)(bundle);
+            meta.bundleHash = bundleHash;
+            const hbcVersion = (0, hbcTransform_1.getHbcVersion)(bundle) ?? base?.bytecodeVersion;
+            if (hbcVersion != null)
+                meta.bytecodeVersion = hbcVersion;
+            await (0, hermes_base_1.cachePut)(bundle, undefined, bundleHash).catch(() => { });
+            Object.assign(meta, (0, zip_range_1.bundleLocationFields)(found?.location));
+        }
+    }
+    catch {
+        // best effort: metadata never blocks a publish
+    }
+    if (base?.baseVersionId != null)
+        meta.baseVersionId = base.baseVersionId;
+    if (base?.baseHash)
+        meta.baseHash = base.baseHash;
+    if (base?.hermesBaseOutcome)
+        meta.hermesBaseOutcome = base.hermesBaseOutcome;
+    if (base?.hermesBaseDetail) {
+        meta.hermesBaseDetail = (0, hermes_base_1.truncateHermesBaseDetail)(base.hermesBaseDetail);
+    }
+    return meta;
+}
+/** Exported for tests: the version/create fields derived from a ppk + base. */
+exports.describePpkBundleForTests = describePpkBundle;
+exports.versionCommands = {
+    registerPdiff: async ({ args, options }) => {
+        return (0, standalone_publish_1.registerStandalonePdiff)(args[0] || '', options);
+    },
+    publish: async ({ args, options, }) => {
+        if ((0, http_helper_1.isStandaloneService)() && (options.deploymentIds || options.releaseIds)) {
+            const appId = await (0, app_1.resolveAppId)(options);
+            return (0, standalone_publish_1.retryStandalonePublish)(appId, String(options.deploymentIds || options.releaseIds), options.dryRun);
+        }
+        const fn = args[0];
+        const { name, description, metaInfo, diffFromHash, channel } = options;
+        if (!fn?.endsWith('.ppk')) {
+            throw new Error((0, i18n_1.t)('publishUsage'));
+        }
+        if ((0, http_helper_1.isStandaloneService)()) {
+            // The Go service resolves the application directly from --appId. A
+            // platform prompt is only needed by the legacy numeric service; keeping
+            // it out of this branch makes CI publish/dry-run usable with targets.json
+            // and an explicit app id.
+            const appId = await (0, app_1.resolveAppId)(options);
+            return (0, standalone_publish_1.publishStandalone)(fn, appId, options);
+        }
+        const platform = await (0, app_1.getPlatform)(options.platform);
+        const appId = await (0, app_1.resolveAppId)({ ...options, platform });
+        const nonInteractive = (0, options_1.getBooleanOption)(options, 'no-interactive', false) || (0, utils_1.isNonInteractive)();
+        // The source map is archived with the version so `pakta symbolicate` can
+        // map crashes back to source. An explicit path that does not exist is a
+        // publish error; no path at all is a loud warning (custom pipelines that
+        // never produced a map keep working).
+        const sourcemapPath = typeof options.sourcemap === 'string' && options.sourcemap
+            ? options.sourcemap
+            : undefined;
+        if (sourcemapPath && !fs_1.default.existsSync(sourcemapPath)) {
+            throw new Error((0, i18n_1.t)('sourceMapNotFound', { path: sourcemapPath }));
+        }
+        if (!sourcemapPath) {
+            console.log(chalk_1.default.yellow((0, i18n_1.t)('sourceMapMissingWarning')));
+        }
+        // Archive a slimmed, gzipped copy (see packSourceMap): relative paths, no
+        // dependency sourcesContent, ~5x smaller on the wire. Frames keep
+        // symbolicating everywhere; only inline snippets of node_modules code are
+        // dropped. The temp file keeps the .map extension because /upload routes
+        // by extension; readers detect gzip by magic bytes.
+        let uploadSourcemapPath = sourcemapPath;
+        let packTempDir;
+        if (sourcemapPath) {
+            packTempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'rnu-sourcemap-'));
+            uploadSourcemapPath = path_1.default.join(packTempDir, path_1.default.basename(sourcemapPath));
+            fs_1.default.writeFileSync(uploadSourcemapPath, (0, slim_sourcemap_1.packSourceMap)(fs_1.default.readFileSync(sourcemapPath, 'utf8'), process.cwd()));
+        }
+        // Hashing/caching the bundle and asking git for the commit are independent
+        // of the upload, so they overlap with it instead of running afterwards.
+        // describePpkBundle never rejects (best effort); a failed upload still
+        // fails the publish exactly as before.
+        // A server that predates source-map archiving (self-hosted, or a SaaS
+        // region not yet rolled) rejects the .map upload with 400; that must not
+        // fail the publish, only lose the archive.
+        let sourceMapUploadError;
+        const [{ hash }, bundleMeta, commit, sourceMapUpload] = await Promise.all([
+            (0, api_1.uploadFile)(fn, undefined, appId),
+            describePpkBundle(fn, options.hermesBase),
+            (0, git_1.getCommitInfo)(),
+            uploadSourcemapPath
+                ? (0, api_1.uploadFile)(uploadSourcemapPath, undefined, appId).catch((error) => {
+                    sourceMapUploadError = error;
+                    return undefined;
+                })
+                : Promise.resolve(undefined),
+        ]).finally(() => {
+            // the packed copy only exists for the upload; a failed ppk upload must
+            // not leave it behind in the OS temp dir
+            if (packTempDir) {
+                fs_1.default.rmSync(packTempDir, { recursive: true, force: true });
+            }
+        });
+        const sourceMapKey = sourceMapUpload?.hash;
+        if (sourcemapPath && !sourceMapKey) {
+            console.log(chalk_1.default.yellow((0, i18n_1.t)('sourceMapUploadFailedWarning', {
+                error: sourceMapUploadError instanceof Error
+                    ? sourceMapUploadError.message
+                    : String(sourceMapUploadError),
+            })));
+        }
+        const depVersions = (0, dep_versions_1.getDepVersions)();
+        const versionName = name ||
+            (nonInteractive ? '' : await (0, utils_1.question)((0, i18n_1.t)('versionNameQuestion'))) ||
+            (0, i18n_1.t)('unnamed');
+        const { id } = await (0, api_1.post)(`/app/${appId}/version/create`, {
+            name: versionName,
+            hash,
+            description: description ??
+                (nonInteractive ? '' : await (0, utils_1.question)((0, i18n_1.t)('versionDescriptionQuestion'))),
+            metaInfo: metaInfo ??
+                (nonInteractive ? '' : await (0, utils_1.question)((0, i18n_1.t)('versionMetaInfoQuestion'))),
+            ...(diffFromHash ? { diffFromHash } : {}),
+            deps: depVersions,
+            commit,
+            ...(channel ? { channel } : {}),
+            // Hermes delta-mode chain metadata (old servers drop unknown fields)
+            ...bundleMeta,
+            // archived source map (old servers drop unknown fields)
+            ...(sourceMapKey ? { sourceMapKey } : {}),
+        });
+        console.log((0, i18n_1.t)('packageUploadSuccess', { id }));
+        if (sourceMapKey) {
+            console.log((0, i18n_1.t)('sourceMapArchived', { id }));
+        }
+        const { packageId, packageVersion, packageVersionRange, minPackageVersion, maxPackageVersion, rollout, dryRun, } = options;
+        if (packageId ||
+            packageVersion ||
+            packageVersionRange ||
+            minPackageVersion ||
+            maxPackageVersion) {
+            await exports.versionCommands.update({
+                options: {
+                    versionId: id,
+                    platform,
+                    appId,
+                    packageId,
+                    packageVersion,
+                    packageVersionRange,
+                    minPackageVersion,
+                    maxPackageVersion,
+                    rollout,
+                    channel,
+                    dryRun,
+                    versionDeps: depVersions,
+                    warnDepsChanges: true,
+                },
+            });
+        }
+        else if (!nonInteractive) {
+            const q = await (0, utils_1.question)((0, i18n_1.t)('updateNativePackageQuestion'));
+            if (q.toLowerCase() === 'y') {
+                await exports.versionCommands.update({
+                    options: {
+                        versionId: id,
+                        platform,
+                        appId,
+                        versionDeps: depVersions,
+                        warnDepsChanges: true,
+                    },
+                });
+            }
+        }
+        return versionName;
+    },
+    versions: async ({ options }) => {
+        const appId = await (0, app_1.resolveAppId)(options);
+        const interactive = !((0, options_1.getBooleanOption)(options, 'no-interactive', false) || (0, utils_1.isNonInteractive)());
+        await (0, version_operations_1.listVersions)(appId, interactive);
+    },
+    update: async ({ options }) => {
+        const nonInteractive = (0, options_1.getBooleanOption)(options, 'no-interactive', false) || (0, utils_1.isNonInteractive)();
+        const appId = await (0, app_1.resolveAppId)(options);
+        let versionId = options.versionId;
+        if (!versionId) {
+            if (nonInteractive) {
+                throw new Error((0, i18n_1.t)('versionIdRequired'));
+            }
+            versionId = String((await (0, version_operations_1.chooseVersion)(appId)).id);
+        }
+        if (versionId === 'null') {
+            versionId = null;
+        }
+        let pkgId = options.packageId;
+        let pkgVersion = options.packageVersion;
+        let minPkgVersion = options.minPackageVersion;
+        let maxPkgVersion = options.maxPackageVersion;
+        let packageVersionRange = options.packageVersionRange;
+        let rollout;
+        if (options.rollout !== undefined) {
+            rollout = Number.parseInt(String(options.rollout), 10);
+            if (Number.isNaN(rollout) || rollout < 1 || rollout > 100) {
+                throw new Error((0, i18n_1.t)('rolloutRangeError'));
+            }
+        }
+        const allPkgs = await (0, api_1.getAllPackages)(appId);
+        if (!allPkgs) {
+            throw new Error((0, i18n_1.t)('noPackagesFound', { appId }));
+        }
+        const pkgMap = new Map(allPkgs.map((pkg) => [String(pkg.id), pkg]));
+        let pkgsToBind = [];
+        const selectorGroups = [
+            pkgId,
+            pkgVersion,
+            packageVersionRange,
+            minPkgVersion || maxPkgVersion,
+        ].filter(Boolean);
+        if (selectorGroups.length > 1) {
+            throw new Error((0, i18n_1.t)('conflictingPackageSelectors'));
+        }
+        if (minPkgVersion || maxPkgVersion) {
+            minPkgVersion = minPkgVersion && String(minPkgVersion).trim();
+            maxPkgVersion = maxPkgVersion && String(maxPkgVersion).trim();
+            pkgsToBind = allPkgs.filter((pkg) => {
+                const aboveMin = !minPkgVersion || (0, compare_versions_1.compare)(pkg.name, minPkgVersion, '>=');
+                const belowMax = !maxPkgVersion || (0, compare_versions_1.compare)(pkg.name, maxPkgVersion, '<=');
+                return aboveMin && belowMax;
+            });
+            if (pkgsToBind.length === 0) {
+                if (minPkgVersion && maxPkgVersion) {
+                    throw new Error((0, i18n_1.t)('nativeVersionNotFoundBetween', {
+                        min: minPkgVersion,
+                        max: maxPkgVersion,
+                    }));
+                }
+                if (minPkgVersion) {
+                    throw new Error((0, i18n_1.t)('nativeVersionNotFoundGte', { version: minPkgVersion }));
+                }
+                throw new Error((0, i18n_1.t)('nativeVersionNotFoundLte', { version: maxPkgVersion }));
+            }
+        }
+        else if (pkgVersion) {
+            pkgVersion = pkgVersion.trim();
+            const pkg = allPkgs.find((pkg) => pkg.name === pkgVersion);
+            if (pkg) {
+                pkgsToBind = [pkg];
+            }
+            else {
+                throw new Error((0, i18n_1.t)('nativeVersionNotFoundMatch', { version: pkgVersion }));
+            }
+        }
+        else if (packageVersionRange) {
+            packageVersionRange = packageVersionRange.trim();
+            pkgsToBind = allPkgs.filter((pkg) => (0, compare_versions_1.satisfies)(pkg.name, packageVersionRange));
+            if (pkgsToBind.length === 0) {
+                throw new Error((0, i18n_1.t)('nativeVersionNotFoundMatch', { version: packageVersionRange }));
+            }
+        }
+        else {
+            if (!pkgId) {
+                if (nonInteractive) {
+                    throw new Error((0, i18n_1.t)('packageIdRequired'));
+                }
+                // the package list was already fetched above: no second round trip
+                pkgId = String((await (0, package_1.choosePackage)(appId, allPkgs)).id);
+            }
+            if (!pkgId) {
+                throw new Error((0, i18n_1.t)('packageIdRequired'));
+            }
+            const pkg = pkgMap.get(String(pkgId));
+            if (pkg) {
+                pkgsToBind = [pkg];
+            }
+            else {
+                throw new Error((0, i18n_1.t)('nativePackageIdNotFound', { id: pkgId }));
+            }
+        }
+        if (options.warnDepsChanges && versionId) {
+            await (0, version_operations_1.printDepsChangesForPublish)({
+                appId,
+                versionId: String(versionId),
+                pkgs: pkgsToBind,
+                providedVersionDeps: options.versionDeps,
+            });
+        }
+        await (0, version_operations_1.bindVersionToPackages)({
+            appId,
+            // keep null as-is: `--versionId null` means unbinding the version
+            versionId: versionId ?? null,
+            pkgs: pkgsToBind,
+            rollout,
+            dryRun: options.dryRun,
+        });
+    },
+    updateVersionInfo: async ({ options, }) => {
+        const nonInteractive = (0, options_1.getBooleanOption)(options, 'no-interactive', false) || (0, utils_1.isNonInteractive)();
+        const appId = await (0, app_1.resolveAppId)(options);
+        let versionId = options.versionId;
+        if (!versionId) {
+            if (nonInteractive) {
+                throw new Error((0, i18n_1.t)('versionIdRequired'));
+            }
+            versionId = String((await (0, version_operations_1.chooseVersion)(appId)).id);
+        }
+        const updateParams = {};
+        if (options.name)
+            updateParams.name = options.name;
+        if (options.description)
+            updateParams.description = options.description;
+        if (options.metaInfo)
+            updateParams.metaInfo = options.metaInfo;
+        await (0, api_1.put)(`/app/${appId}/version/${versionId}`, updateParams);
+        console.log((0, i18n_1.t)('operationSuccess'));
+    },
+    deleteVersion: async ({ options }) => {
+        const nonInteractive = (0, options_1.getBooleanOption)(options, 'no-interactive', false) || (0, utils_1.isNonInteractive)();
+        const appId = await (0, app_1.resolveAppId)(options);
+        const parsedVersionIds = (0, options_1.getStringListOption)(options, 'versionIds') ??
+            (0, options_1.getStringListOption)(options, 'versionId');
+        let versionIds = parsedVersionIds;
+        if (!versionIds) {
+            if (nonInteractive) {
+                throw new Error((0, i18n_1.t)('versionIdRequired'));
+            }
+            versionIds = [String((await (0, version_operations_1.chooseVersion)(appId)).id)];
+        }
+        try {
+            if (versionIds.length === 1) {
+                const [versionId] = versionIds;
+                await (0, api_1.doDelete)(`/app/${appId}/version/${versionId}`);
+                console.log((0, i18n_1.t)('deleteVersionSuccess', { versionId }));
+            }
+            else {
+                await (0, api_1.doDelete)(`/app/${appId}/version`, {
+                    versionIds: (0, version_operations_1.toNumericIds)(versionIds),
+                });
+                console.log((0, i18n_1.t)('deleteVersionsSuccess', {
+                    count: versionIds.length,
+                    versionIds: versionIds.join(', '),
+                }));
+            }
+        }
+        catch (error) {
+            throw new Error((0, i18n_1.t)('deleteVersionError', {
+                versionId: versionIds.join(', '),
+                error: error.message,
+            }));
+        }
+    },
+};

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "rn-update-cli",
+  "version": "1.0.0",
+  "description": "command line tool for rn-update (remote updates for react native)",
+  "main": "lib/exports.js",
+  "types": "lib/exports.d.ts",
+  "bin": {
+    "pakta": "lib/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/exports.d.ts",
+      "require": "./lib/exports.js",
+      "default": "./lib/exports.js"
+    },
+    "./diff": {
+      "types": "./lib/diff.d.ts",
+      "require": "./lib/diff.js",
+      "default": "./lib/diff.js"
+    },
+    "./lib/diff": {
+      "types": "./lib/diff.d.ts",
+      "require": "./lib/diff.js",
+      "default": "./lib/diff.js"
+    }
+  },
+  "files": [
+    "lib",
+    "proto",
+    "cli.json",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node scripts/build.js",
+    "prepublishOnly": "bun run build",
+    "typecheck": "tsc --noEmit",
+    "typecheck:build": "tsc -p tsconfig.build.json",
+    "lint": "bun run typecheck && biome check .",
+    "lint:fix": "bun run typecheck && biome check --write .",
+    "test": "bun test",
+    "smoke": "node scripts/smoke-lib.js",
+    "test:coverage": "bun test --coverage --coverage-reporter=text --coverage-reporter=lcov",
+    "benchmark:diff-stream": "bun scripts/benchmark-diff-stream.ts",
+    "fuzz:hermes-base": "bun scripts/fuzz-hermes-base.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pakta-team/rn-update-cli.git"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "harmony",
+    "update"
+  ],
+  "author": "Yoghourt Technology(BeiJing) Company Limited",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pakta-team/rn-update-cli/issues"
+  },
+  "homepage": "https://pakta.site",
+  "dependencies": {
+    "bplist-parser": "^0.3.2",
+    "bytebuffer": "^5.0.1",
+    "cgbi-to-png": "^1.0.7",
+    "chalk": "4",
+    "cli-arguments": "^0.2.1",
+    "compare-versions": "^6.1.1",
+    "filesize-parser": "^1.5.2",
+    "form-data": "^4.0.6",
+    "fs-extra": "^11.4.0",
+    "global-dirs": "^4.0.0",
+    "gradle-to-js": "^2.0.1",
+    "https-proxy-agent": "^7.0.6",
+    "i18next": "^26.4.0",
+    "node-fetch": "^2.6.1",
+    "plist": "^5.0.0",
+    "progress": "^2.0.3",
+    "properties": "^1.2.1",
+    "protobufjs": "^8.7.2",
+    "read": "^4.1.0",
+    "registry-auth-token": "^5.1.1",
+    "source-map": "0.6.1",
+    "tty-table": "5.0",
+    "undici": "^6.28.0",
+    "yauzl": "^3.4.0",
+    "yazl": "3.3.1"
+  },
+  "overrides": {
+    "@xmldom/xmldom": "0.8.13"
+  },
+  "engines": {
+    "node": ">= 18.17.0"
+  },
+  "devDependencies": {
+    "@babel/parser": "^8.0.4",
+    "@biomejs/biome": "^2.5.10",
+    "@types/bun": "^1.4.0",
+    "@types/filesize-parser": "^1.5.3",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^26.3.0",
+    "@types/node-fetch": "^2.6.13",
+    "@types/progress": "^2.0.7",
+    "@types/yauzl": "^3.4.0",
+    "@types/yazl": "^3.3.1",
+    "node-hdiffpatch": "^2.4.0",
+    "typescript": "^7.0.2"
+  },
+  "trustedDependencies": [
+    "@biomejs/biome"
+  ]
+}

package/proto/Configuration.proto

@@ -0,0 +1,183 @@
+syntax = "proto3";
+
+package aapt.pb;
+
+option java_package = "com.android.aapt";
+
+message Configuration {
+  enum LayoutDirection {
+    LAYOUT_DIRECTION_UNSET = 0;
+    LAYOUT_DIRECTION_LTR = 1;
+    LAYOUT_DIRECTION_RTL = 2;
+  }
+
+  enum ScreenLayoutSize {
+    SCREEN_LAYOUT_SIZE_UNSET = 0;
+    SCREEN_LAYOUT_SIZE_SMALL = 1;
+    SCREEN_LAYOUT_SIZE_NORMAL = 2;
+    SCREEN_LAYOUT_SIZE_LARGE = 3;
+    SCREEN_LAYOUT_SIZE_XLARGE = 4;
+  }
+
+  enum ScreenLayoutLong {
+    SCREEN_LAYOUT_LONG_UNSET = 0;
+    SCREEN_LAYOUT_LONG_LONG = 1;
+    SCREEN_LAYOUT_LONG_NOTLONG = 2;
+  }
+
+  enum ScreenRound {
+    SCREEN_ROUND_UNSET = 0;
+    SCREEN_ROUND_ROUND = 1;
+    SCREEN_ROUND_NOTROUND = 2;
+  }
+
+  enum WideColorGamut {
+    WIDE_COLOR_GAMUT_UNSET = 0;
+    WIDE_COLOR_GAMUT_WIDECG = 1;
+    WIDE_COLOR_GAMUT_NOWIDECG = 2;
+  }
+
+  enum Hdr {
+    HDR_UNSET = 0;
+    HDR_HIGHDR = 1;
+    HDR_LOWDR = 2;
+  }
+
+  enum Orientation {
+    ORIENTATION_UNSET = 0;
+    ORIENTATION_PORT = 1;
+    ORIENTATION_LAND = 2;
+    ORIENTATION_SQUARE = 3;
+  }
+
+  enum UiModeType {
+    UI_MODE_TYPE_UNSET = 0;
+    UI_MODE_TYPE_NORMAL = 1;
+    UI_MODE_TYPE_DESK = 2;
+    UI_MODE_TYPE_CAR = 3;
+    UI_MODE_TYPE_TELEVISION = 4;
+    UI_MODE_TYPE_APPLIANCE = 5;
+    UI_MODE_TYPE_WATCH = 6;
+    UI_MODE_TYPE_VR_HEADSET = 7;
+  }
+
+  enum UiModeNight {
+    UI_MODE_NIGHT_UNSET = 0;
+    UI_MODE_NIGHT_NIGHT = 1;
+    UI_MODE_NIGHT_NOTNIGHT = 2;
+  }
+
+  enum Touchscreen {
+    TOUCHSCREEN_UNSET = 0;
+    TOUCHSCREEN_NOTOUCH = 1;
+    TOUCHSCREEN_STYLUS = 2;
+    TOUCHSCREEN_FINGER = 3;
+  }
+
+  enum KeysHidden {
+    KEYS_HIDDEN_UNSET = 0;
+    KEYS_HIDDEN_KEYSEXPOSED = 1;
+    KEYS_HIDDEN_KEYSHIDDEN = 2;
+    KEYS_HIDDEN_KEYSSOFT = 3;
+  }
+
+  enum Keyboard {
+    KEYBOARD_UNSET = 0;
+    KEYBOARD_NOKEYS = 1;
+    KEYBOARD_QWERTY = 2;
+    KEYBOARD_12KEY = 3;
+  }
+
+  enum NavHidden {
+    NAV_HIDDEN_UNSET = 0;
+    NAV_HIDDEN_NAVEXPOSED = 1;
+    NAV_HIDDEN_NAVHIDDEN = 2;
+  }
+
+  enum Navigation {
+    NAVIGATION_UNSET = 0;
+    NAVIGATION_NONAV = 1;
+    NAVIGATION_DPAD = 2;
+    NAVIGATION_TRACKBALL = 3;
+    NAVIGATION_WHEEL = 4;
+  }
+
+  enum GrammaticalGender {
+    GRAMMATICAL_GENDER_UNSET = 0;
+    GRAMMATICAL_GENDER_NEUTER = 1;
+    GRAMMATICAL_GENDER_FEMININE = 2;
+    GRAMMATICAL_GENDER_MASCULINE = 3;
+  }
+
+  // Mobile country code.
+  uint32 mcc = 1;
+
+  // Mobile network code.
+  uint32 mnc = 2;
+
+  // Locale.
+  string locale = 3;
+
+  // Layout direction.
+  LayoutDirection layout_direction = 4;
+
+  // Screen width in dp.
+  uint32 screen_width = 5;
+
+  // Screen height in dp.
+  uint32 screen_height = 6;
+
+  // Smallest screen width in dp.
+  uint32 smallest_screen_width = 7;
+
+  // Screen layout size.
+  ScreenLayoutSize screen_layout_size = 8;
+
+  // Screen layout long.
+  ScreenLayoutLong screen_layout_long = 9;
+
+  // Screen round.
+  ScreenRound screen_round = 10;
+
+  // Wide color gamut.
+  WideColorGamut wide_color_gamut = 11;
+
+  // HDR.
+  Hdr hdr = 12;
+
+  // Orientation.
+  Orientation orientation = 13;
+
+  // UI mode type.
+  UiModeType ui_mode_type = 14;
+
+  // UI mode night.
+  UiModeNight ui_mode_night = 15;
+
+  // Density in dpi.
+  uint32 density = 16;
+
+  // Touchscreen.
+  Touchscreen touchscreen = 17;
+
+  // Keys hidden.
+  KeysHidden keys_hidden = 18;
+
+  // Keyboard.
+  Keyboard keyboard = 19;
+
+  // Nav hidden.
+  NavHidden nav_hidden = 20;
+
+  // Navigation.
+  Navigation navigation = 21;
+
+  // SDK version.
+  uint32 sdk_version = 22;
+
+  // Product.
+  string product = 23;
+
+  // Grammatical gender.
+  GrammaticalGender grammatical_gender = 24;
+}