@devicecloud.dev/dcd 4.4.9 → 5.0.0-beta.1

package/dist/services/telemetry.service.js

@@ -0,0 +1,252 @@
+/**
+ * Ships CLI lifecycle + error events to Axiom via the API's `/cli/logs`
+ * proxy (forwards to `cli-dev` / `cli-prod`). The proxy authenticates with
+ * the same `auth.headers` every other gateway uses (`x-app-api-key` or
+ * `Authorization: Bearer ...` + `x-dcd-org`), so we never need the Axiom
+ * token client-side.
+ *
+ * Two flush paths:
+ * - `flush()` — async, used after `runMain` returns naturally
+ * - `flushSync()` — sync via `curl`, used inside `logger.error` right before
+ *   `process.exit` (no other way to send HTTP after exit is called)
+ *
+ * Opt out: `DCD_TELEMETRY_DISABLED=1` in the environment.
+ */
+import { execFileSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { getCliVersion, getInstallMethod } from '../utils/cli.js';
+const DEFAULT_API_URL = 'https://api.devicecloud.dev';
+class Telemetry {
+    buffer = [];
+    config = null;
+    command = inferCommandFromArgv();
+    sessionId = randomUUID();
+    startedAt = Date.now();
+    disabled = !!process.env.DCD_TELEMETRY_DISABLED;
+    release = getCliVersion();
+    /**
+     * Called once per invocation by `resolveAuth` after the credential check
+     * succeeds. Before this is called, lifecycle events are buffered but cannot
+     * be sent. Commands that never reach `resolveAuth` (`--help`, `--version`,
+     * `dcd login` before sign-in completes) will skip telemetry entirely — by
+     * design, since those flows have no identity to attach.
+     */
+    configure(opts) {
+        if (this.disabled)
+            return;
+        this.config = {
+            apiUrl: opts.apiUrl ?? inferApiUrlFromArgv(),
+            auth: opts.auth,
+            command: this.command,
+        };
+    }
+    /**
+     * Override the command label attached to telemetry meta. The MCP server is
+     * long-lived and isn't a citty subcommand, so `inferCommandFromArgv` can't
+     * name it — `src/mcp/index.ts` calls this at boot.
+     */
+    setCommand(command) {
+        this.command = command;
+    }
+    recordCommandStart() {
+        this.startedAt = Date.now();
+        this.enqueue('info', 'cli.lifecycle', 'command started', {
+            argv: scrubArgv(process.argv.slice(2)),
+        });
+    }
+    recordMcpToolStart(tool) {
+        this.enqueue('info', 'cli.mcp', 'mcp tool invoked', { tool });
+    }
+    recordMcpToolSuccess(tool, durationMs) {
+        this.enqueue('info', 'cli.mcp', 'mcp tool completed', {
+            tool,
+            duration_ms: durationMs,
+        });
+    }
+    recordMcpToolFailure(tool, error, durationMs) {
+        this.enqueue('error', 'cli.mcp', 'mcp tool failed', {
+            tool,
+            duration_ms: durationMs,
+            error_message: error instanceof Error ? error.message : String(error),
+            error_name: error instanceof Error ? error.name : 'Error',
+        });
+    }
+    recordCommandSuccess() {
+        this.enqueue('info', 'cli.lifecycle', 'command completed', {
+            duration_ms: Date.now() - this.startedAt,
+            exit_code: 0,
+        });
+    }
+    recordCommandFailure(opts) {
+        const message = opts.error instanceof Error ? opts.error.message : String(opts.error);
+        this.enqueue('error', 'cli.lifecycle', 'command failed', {
+            duration_ms: Date.now() - this.startedAt,
+            exit_code: opts.exitCode,
+            error_message: message,
+            error_name: opts.error instanceof Error ? opts.error.name : 'CliError',
+            error_stack: opts.error instanceof Error ? opts.error.stack : undefined,
+        });
+    }
+    enqueue(level, context, message, extra) {
+        if (this.disabled)
+            return;
+        this.buffer.push({
+            timestamp: new Date().toISOString(),
+            level,
+            context,
+            message,
+            extra,
+        });
+    }
+    async flush() {
+        if (this.disabled || !this.config || this.buffer.length === 0)
+            return;
+        const events = this.buffer.splice(0, this.buffer.length);
+        const body = JSON.stringify({ events, meta: this.buildMeta() });
+        try {
+            await fetch(`${this.config.apiUrl}/cli/logs`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    ...this.config.auth.headers,
+                },
+                body,
+            });
+        }
+        catch {
+            // Telemetry failures must never surface — silently drop.
+        }
+    }
+    /**
+     * Synchronous flush via `curl`. Used right before `process.exit` (which
+     * bypasses `beforeExit`, so async `fetch` would be killed mid-flight).
+     * Node has no built-in sync HTTP and `curl` ships with macOS, Linux, and
+     * Windows ≥ 1803 — that's the supported surface for the CLI.
+     */
+    flushSync() {
+        if (this.disabled || !this.config || this.buffer.length === 0)
+            return;
+        const events = this.buffer.splice(0, this.buffer.length);
+        const body = JSON.stringify({ events, meta: this.buildMeta() });
+        // Headers carry the API key / Bearer token, so they must not appear in
+        // curl's argv (world-readable via ps//proc while curl runs). They go in a
+        // 0600 config file inside a fresh 0700 temp dir instead; stdin carries the
+        // body, so it can't double as the config channel.
+        let configDir;
+        try {
+            configDir = mkdtempSync(join(tmpdir(), 'dcd-telemetry-'));
+            const configPath = join(configDir, 'curl.cfg');
+            const headerLines = ['header = "content-type: application/json"'];
+            for (const [k, v] of Object.entries(this.config.auth.headers)) {
+                headerLines.push(`header = "${k}: ${v}"`);
+            }
+            writeFileSync(configPath, headerLines.join('\n'), { mode: 0o600 });
+            execFileSync('curl', [
+                '-sS',
+                '-m',
+                '3',
+                '-X',
+                'POST',
+                '-K',
+                configPath,
+                '--data-binary',
+                '@-',
+                `${this.config.apiUrl}/cli/logs`,
+            ], { input: body, stdio: ['pipe', 'ignore', 'ignore'] });
+        }
+        catch {
+            // Telemetry failures must never surface — silently drop.
+        }
+        finally {
+            if (configDir)
+                rmSync(configDir, { recursive: true, force: true });
+        }
+    }
+    buildMeta() {
+        if (!this.config) {
+            throw new Error('telemetry not configured');
+        }
+        return {
+            release: this.release,
+            command: this.command,
+            sessionId: this.sessionId,
+            authMode: this.config.auth.mode,
+            installMethod: getInstallMethod(),
+            nodeVersion: process.versions.node,
+            platform: process.platform,
+            arch: process.arch,
+            userEmail: this.config.auth.userEmail,
+            orgId: this.config.auth.orgId,
+        };
+    }
+}
+// Flags whose values are credential material (API keys, signed URLs) or
+// user-provided env pairs that routinely carry test-account secrets. Their
+// values must never reach the telemetry backend.
+const SENSITIVE_FLAG_NAMES = new Set([
+    '--api-key',
+    '--apiKey',
+    '--moropo-v1-api-key',
+    '--app-url',
+    '--appUrl',
+    '-e',
+    '--env',
+]);
+function scrubArgv(args) {
+    const scrubbed = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const eqIndex = arg.indexOf('=');
+        const flagName = eqIndex === -1 ? arg : arg.slice(0, eqIndex);
+        if (arg.startsWith('-') && SENSITIVE_FLAG_NAMES.has(flagName)) {
+            if (eqIndex === -1) {
+                scrubbed.push(arg);
+                if (i + 1 < args.length) {
+                    scrubbed.push('<redacted>');
+                    i++;
+                }
+            }
+            else {
+                scrubbed.push(`${flagName}=<redacted>`);
+            }
+        }
+        else {
+            scrubbed.push(arg);
+        }
+    }
+    return scrubbed;
+}
+// argv layout: node|tsx, script, command, ...flags. The first non-flag after
+// the script is the subcommand. Falls back to 'help' for `--help`/`--version`
+// invocations and to 'unknown' if we can't decide.
+function inferCommandFromArgv() {
+    const args = process.argv.slice(2);
+    for (const arg of args) {
+        if (arg.startsWith('-'))
+            continue;
+        return arg;
+    }
+    if (args.some((a) => a === '--help' || a === '-h'))
+        return 'help';
+    if (args.some((a) => a === '--version' || a === '-v'))
+        return 'version';
+    return 'unknown';
+}
+const API_URL_FLAGS = ['--api-url', '--apiURL', '--apiUrl'];
+function inferApiUrlFromArgv() {
+    const args = process.argv.slice(2);
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        for (const flag of API_URL_FLAGS) {
+            if (arg === flag && args[i + 1])
+                return args[i + 1];
+            if (arg.startsWith(`${flag}=`))
+                return arg.slice(flag.length + 1);
+        }
+    }
+    return DEFAULT_API_URL;
+}
+export const telemetry = new Telemetry();

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

@@ -1,4 +1,4 @@
-import { IExecutionPlan } from './execution-plan.service';
+import { IExecutionPlan } from './execution-plan.service.js';
 export interface TestSubmissionConfig {
     androidApiLevel?: string;
     androidDevice?: string;
@@ -35,11 +35,28 @@ export interface TestSubmissionConfig {
  */
 export declare class TestSubmissionService {
     /**
-     * Build FormData for test submission
+     * Build the test-submission payload: the compressed flow zip plus every
+     * non-`file` field, each encoded exactly as it is sent today. The same
+     * `fields` feed both the new JSON `submitFlowTest` body and the legacy
+     * multipart `buildFormData`, guaranteeing byte-identical field encoding
+     * across both paths.
      * @param config Test submission configuration
-     * @returns FormData ready to be submitted to the API
+     * @returns The flow zip buffer, its SHA-256, and the string-encoded fields
      */
-    buildTestFormData(config: TestSubmissionConfig): Promise<FormData>;
+    buildTestPayload(config: TestSubmissionConfig): Promise<{
+        buffer: Buffer;
+        fields: Record<string, string>;
+        sha: string;
+    }>;
+    /**
+     * Wraps the payload fields and flow zip into multipart FormData for the
+     * legacy `POST /uploads/flow` fallback. `file` is set first to preserve the
+     * exact part ordering the old code produced.
+     * @param fields String-encoded fields from {@link buildTestPayload}
+     * @param buffer The compressed flow zip
+     * @returns FormData ready to be submitted to the multipart API
+     */
+    buildFormData(fields: Record<string, string>, buffer: Buffer): FormData;
     private logDebug;
     private normalizeFilePath;
     private normalizePathMap;

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

@@ -1,26 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestSubmissionService = void 0;
-const node_crypto_1 = require("node:crypto");
-const path = require("node:path");
-const methods_1 = require("../methods");
+import { createHash } from 'node:crypto';
+import * as path from 'node:path';
+import { compressFilesFromRelativePath } from '../methods.js';
+import { toPortableRelativePath } from '../utils/paths.js';
 const mimeTypeLookupByExtension = {
     zip: 'application/zip',
 };
 /**
  * Service for building test submission form data
  */
-class TestSubmissionService {
+export class TestSubmissionService {
     /**
-     * Build FormData for test submission
+     * Build the test-submission payload: the compressed flow zip plus every
+     * non-`file` field, each encoded exactly as it is sent today. The same
+     * `fields` feed both the new JSON `submitFlowTest` body and the legacy
+     * multipart `buildFormData`, guaranteeing byte-identical field encoding
+     * across both paths.
      * @param config Test submission configuration
-     * @returns FormData ready to be submitted to the API
+     * @returns The flow zip buffer, its SHA-256, and the string-encoded fields
      */
-    async buildTestFormData(config) {
+    async buildTestPayload(config) {
         const { appBinaryId, flowFile, executionPlan, commonRoot, cliVersion, env = [], metadata = [], googlePlay = false, androidApiLevel, androidDevice, androidNoSnapshot, iOSVersion, iOSDevice, name, runnerType, maestroVersion, deviceLocale, orientation, mitmHost, mitmPath, retry, continueOnFailure = true, report, showCrosshairs, maestroChromeOnboarding, raw, disableAnimations, debug = false, logger, } = config;
         const { allExcludeTags, allIncludeTags, flowMetadata, flowOverrides, flowsToRun: testFileNames, referencedFiles, sequence, workspaceConfig, } = executionPlan;
         const { flows: sequentialFlows = [] } = sequence ?? {};
-        const testFormData = new FormData();
         const envObject = this.parseKeyValuePairs(env);
         const metadataObject = this.parseKeyValuePairs(metadata);
         if (Object.keys(envObject).length > 0) {
@@ -41,7 +42,7 @@ class TestSubmissionService {
             }
         }
         this.logDebug(debug, logger, `[DEBUG] Compressing files from path: ${flowFile}`);
-        const buffer = await (0, methods_1.compressFilesFromRelativePath)(flowFile?.endsWith('.yaml') || flowFile?.endsWith('.yml')
+        const buffer = await compressFilesFromRelativePath(flowFile?.endsWith('.yaml') || flowFile?.endsWith('.yml')
             ? path.dirname(flowFile)
             : flowFile, [
             ...new Set([
@@ -52,19 +53,18 @@ class TestSubmissionService {
         ], commonRoot);
         this.logDebug(debug, logger, `[DEBUG] Compressed file size: ${buffer.length} bytes`);
         // Calculate SHA-256 hash of the flow ZIP
-        const sha = (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
+        const sha = createHash('sha256').update(buffer).digest('hex');
         this.logDebug(debug, logger, `[DEBUG] Flow ZIP SHA-256: ${sha}`);
-        const blob = new Blob([buffer], {
-            type: mimeTypeLookupByExtension.zip,
-        });
-        testFormData.set('file', blob, 'flowFile.zip');
-        testFormData.set('sha', sha);
-        testFormData.set('appBinaryId', appBinaryId);
-        testFormData.set('testFileNames', JSON.stringify(this.normalizePaths(testFileNames, commonRoot)));
-        testFormData.set('flowMetadata', JSON.stringify(this.normalizePathMap(flowMetadata, commonRoot)));
-        testFormData.set('testFileOverrides', JSON.stringify(this.normalizePathMap(flowOverrides, commonRoot)));
-        testFormData.set('sequentialFlows', JSON.stringify(this.normalizePaths(sequentialFlows, commonRoot)));
-        testFormData.set('env', JSON.stringify(envObject));
+        // String-encoded fields, in the same order and with the same encoding as
+        // the legacy multipart FormData. Reused verbatim by both submission paths.
+        const fields = {};
+        fields.sha = sha;
+        fields.appBinaryId = appBinaryId;
+        fields.testFileNames = JSON.stringify(this.normalizePaths(testFileNames, commonRoot));
+        fields.flowMetadata = JSON.stringify(this.normalizePathMap(flowMetadata, commonRoot));
+        fields.testFileOverrides = JSON.stringify(this.normalizePathMap(flowOverrides, commonRoot));
+        fields.sequentialFlows = JSON.stringify(this.normalizePaths(sequentialFlows, commonRoot));
+        fields.env = JSON.stringify(envObject);
         // Note: googlePlay is now included in configPayload below instead of as a separate field
         // to work around a FormData parsing issue in the API
         const targetPlatform = iOSDevice || iOSVersion ? 'ios' : 'android';
@@ -91,13 +91,13 @@ class TestSubmissionService {
             disableAnimations: effectiveDisableAnimations,
             version: cliVersion,
         };
-        testFormData.set('config', JSON.stringify(configPayload));
+        fields.config = JSON.stringify(configPayload);
         if (Object.keys(metadataObject).length > 0) {
             const metadataPayload = { userMetadata: metadataObject };
-            testFormData.set('metadata', JSON.stringify(metadataPayload));
+            fields.metadata = JSON.stringify(metadataPayload);
             this.logDebug(debug, logger, `[DEBUG] Sending metadata to API: ${JSON.stringify(metadataPayload)}`);
         }
-        this.setOptionalFields(testFormData, {
+        this.setOptionalFields(fields, {
             androidApiLevel,
             androidDevice,
             iOSDevice,
@@ -106,9 +106,28 @@ class TestSubmissionService {
             runnerType,
         });
         if (workspaceConfig) {
-            testFormData.set('workspaceConfig', JSON.stringify(workspaceConfig));
+            fields.workspaceConfig = JSON.stringify(workspaceConfig);
+        }
+        return { buffer, fields, sha };
+    }
+    /**
+     * Wraps the payload fields and flow zip into multipart FormData for the
+     * legacy `POST /uploads/flow` fallback. `file` is set first to preserve the
+     * exact part ordering the old code produced.
+     * @param fields String-encoded fields from {@link buildTestPayload}
+     * @param buffer The compressed flow zip
+     * @returns FormData ready to be submitted to the multipart API
+     */
+    buildFormData(fields, buffer) {
+        const formData = new FormData();
+        const blob = new Blob([buffer], {
+            type: mimeTypeLookupByExtension.zip,
+        });
+        formData.set('file', blob, 'flowFile.zip');
+        for (const [key, value] of Object.entries(fields)) {
+            formData.set(key, value);
         }
-        return testFormData;
+        return formData;
     }
     logDebug(debug, logger, message) {
         if (debug && logger) {
@@ -116,7 +135,7 @@ class TestSubmissionService {
         }
     }
     normalizeFilePath(filePath, commonRoot) {
-        return filePath.replaceAll(commonRoot, '.').split(path.sep).join('/');
+        return toPortableRelativePath(filePath, commonRoot);
     }
     normalizePathMap(map, commonRoot) {
         return Object.fromEntries(Object.entries(map).map(([key, value]) => [
@@ -136,12 +155,11 @@ class TestSubmissionService {
             return acc;
         }, {});
     }
-    setOptionalFields(formData, fields) {
+    setOptionalFields(target, fields) {
         for (const [key, value] of Object.entries(fields)) {
             if (value) {
-                formData.set(key, value.toString());
+                target[key] = value.toString();
             }
         }
     }
 }
-exports.TestSubmissionService = TestSubmissionService;

package/dist/services/version.service.d.ts

@@ -1,11 +1,12 @@
-import { CompatibilityData } from '../utils/compatibility';
+import { CompatibilityData } from '../utils/compatibility.js';
 /**
  * Service for handling version validation and checking
  */
 export declare class VersionService {
     /**
-     * Check npm registry for the latest published version of the CLI
-     * @returns Latest version string or null if check fails
+     * Fetch the latest published CLI version from the release manifest.
+     * Works for both npm- and binary-installed users (no `npm` shell-out).
+     * Silently returns null on any failure — this check is informational only.
      */
     checkLatestCliVersion(): Promise<null | string>;
     /**

package/dist/services/version.service.js

@@ -1,27 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VersionService = void 0;
-const node_child_process_1 = require("node:child_process");
+const DEFAULT_MANIFEST_URL = 'https://get.devicecloud.dev/latest.json';
+const MANIFEST_TIMEOUT_MS = 3000;
 /**
  * Service for handling version validation and checking
  */
-class VersionService {
+export class VersionService {
     /**
-     * Check npm registry for the latest published version of the CLI
-     * @returns Latest version string or null if check fails
+     * Fetch the latest published CLI version from the release manifest.
+     * Works for both npm- and binary-installed users (no `npm` shell-out).
+     * Silently returns null on any failure — this check is informational only.
      */
     async checkLatestCliVersion() {
+        const url = process.env.DCD_MANIFEST_URL ?? DEFAULT_MANIFEST_URL;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), MANIFEST_TIMEOUT_MS);
         try {
-            const latestVersion = (0, node_child_process_1.execSync)('npm view @devicecloud.dev/dcd version', {
-                encoding: 'utf8',
-                stdio: ['ignore', 'pipe', 'ignore'],
-            }).trim();
-            return latestVersion;
+            const res = await fetch(url, { signal: controller.signal });
+            if (!res.ok)
+                return null;
+            const data = (await res.json());
+            return typeof data.version === 'string' ? data.version : null;
         }
         catch {
-            // Silently fail - version check is informational only
             return null;
         }
+        finally {
+            clearTimeout(timer);
+        }
     }
     /**
      * Compare two semantic version strings
@@ -30,8 +34,14 @@ class VersionService {
      * @returns true if current is older than latest
      */
     isOutdated(current, latest) {
-        const currentParts = current.split('.').map(Number);
-        const latestParts = latest.split('.').map(Number);
+        // Strip any prerelease suffix ("1.2.3-beta.1" -> "1.2.3") and default
+        // missing segments to 0 so short/prerelease versions still compare.
+        const parts = (version) => {
+            const nums = version.split('-')[0].split('.').map(Number);
+            return [nums[0] || 0, nums[1] || 0, nums[2] || 0];
+        };
+        const currentParts = parts(current);
+        const latestParts = parts(latest);
         for (let i = 0; i < 3; i++) {
             if (currentParts[i] < latestParts[i])
                 return true;
@@ -68,6 +78,9 @@ class VersionService {
                 log(`[DEBUG] Using default Maestro version ${defaultVersion}`);
             }
         }
+        if (!resolvedVersion) {
+            throw new Error('Unable to resolve a Maestro version: compatibility data did not provide a default.');
+        }
         // Validate Maestro version
         if (!supportedVersions.includes(resolvedVersion)) {
             throw new Error(`Maestro version ${resolvedVersion} is not supported. Supported versions: ${supportedVersions.join(', ')}`);
@@ -79,4 +92,3 @@ class VersionService {
         return resolvedVersion;
     }
 }
-exports.VersionService = VersionService;

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

@@ -0,0 +1,20 @@
+import type { DcdEnvName } from '../../config/environments.js';
+/**
+ * Auth context threaded through gateways and services. Callers build this once
+ * (via resolveAuth) and the gateway spreads .headers into every fetch.
+ */
+export interface AuthContext {
+    headers: Record<string, string>;
+    mode: 'apiKey' | 'bearer';
+    /**
+     * Supabase JWT — present when mode === 'bearer'. Lets realtime subscriptions
+     * authenticate the socket (RLS) without re-reading the session from disk.
+     */
+    accessToken?: string;
+    /** Environment the session belongs to — present when mode === 'bearer'. */
+    env?: DcdEnvName;
+    /** Present when mode === 'bearer'. */
+    orgId?: string;
+    /** Present when mode === 'bearer'. */
+    userEmail?: string;
+}

package/dist/types/domain/auth.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,11 +1,8 @@
-"use strict";
 /**
  * Device type definitions - should be kept in sync with API
  * @see /Users/riglar/repos/dcd/api/src/common/types/device.types.ts
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EAndroidApiLevels = exports.EiOSVersions = exports.EAndroidDevices = exports.EiOSDevices = void 0;
-var EiOSDevices;
+export var EiOSDevices;
 (function (EiOSDevices) {
     EiOSDevices["ipad-pro-6th-gen"] = "ipad-pro-6th-gen";
     EiOSDevices["iphone-14"] = "iphone-14";
@@ -16,23 +13,23 @@ var EiOSDevices;
     EiOSDevices["iphone-16-plus"] = "iphone-16-plus";
     EiOSDevices["iphone-16-pro"] = "iphone-16-pro";
     EiOSDevices["iphone-16-pro-max"] = "iphone-16-pro-max";
-})(EiOSDevices || (exports.EiOSDevices = EiOSDevices = {}));
-var EAndroidDevices;
+})(EiOSDevices || (EiOSDevices = {}));
+export var EAndroidDevices;
 (function (EAndroidDevices) {
     EAndroidDevices["generic-tablet"] = "generic-tablet";
     EAndroidDevices["pixel-6"] = "pixel-6";
     EAndroidDevices["pixel-6-pro"] = "pixel-6-pro";
     EAndroidDevices["pixel-7"] = "pixel-7";
     EAndroidDevices["pixel-7-pro"] = "pixel-7-pro";
-})(EAndroidDevices || (exports.EAndroidDevices = EAndroidDevices = {}));
-var EiOSVersions;
+})(EAndroidDevices || (EAndroidDevices = {}));
+export var EiOSVersions;
 (function (EiOSVersions) {
     EiOSVersions["eighteen"] = "18";
     EiOSVersions["seventeen"] = "17";
     EiOSVersions["sixteen"] = "16";
     EiOSVersions["twentySix"] = "26";
-})(EiOSVersions || (exports.EiOSVersions = EiOSVersions = {}));
-var EAndroidApiLevels;
+})(EiOSVersions || (EiOSVersions = {}));
+export var EAndroidApiLevels;
 (function (EAndroidApiLevels) {
     EAndroidApiLevels["thirty"] = "30";
     EAndroidApiLevels["thirtyFive"] = "35";
@@ -42,4 +39,4 @@ var EAndroidApiLevels;
     EAndroidApiLevels["thirtyThree"] = "33";
     EAndroidApiLevels["thirtyTwo"] = "32";
     EAndroidApiLevels["twentyNine"] = "29";
-})(EAndroidApiLevels || (exports.EAndroidApiLevels = EAndroidApiLevels = {}));
+})(EAndroidApiLevels || (EAndroidApiLevels = {}));