eas-cli 16.15.0 → 16.16.0

package/build/commands/workflow/run.d.ts

@@ -1,3 +1,45 @@
+/**
+ * EAS Workflow Run Command
+ *
+ * This command runs an EAS workflow with support for interactive input prompting.
+ *
+ * Input Sources (in order of precedence):
+ * 1. Command line flags (-F key=value)
+ * 2. STDIN JSON input (echo '{"key": "value"}' | eas workflow:run)
+ * 3. Interactive prompts (when required inputs are missing and not in non-interactive mode)
+ *
+ * Interactive Prompting:
+ * - When running in interactive mode (default), the command will automatically prompt
+ *   for any required inputs that are not provided via flags or STDIN
+ * - Input types supported: string, boolean, number, choice, environment
+ * - Each input type has appropriate validation and default values
+ * - Use --non-interactive flag to disable prompting and require all inputs via flags
+ *
+ * Example workflow with inputs:
+ * ```yaml
+ * on:
+ *   workflow_dispatch:
+ *     inputs:
+ *       environment:
+ *         type: string
+ *         required: true
+ *         description: "Environment to deploy to"
+ *       debug:
+ *         type: boolean
+ *         default: false
+ *         description: "Enable debug mode"
+ *       version:
+ *         type: number
+ *         required: true
+ *         description: "Version number"
+ *       deployment_type:
+ *         type: choice
+ *         options: ["staging", "production"]
+ *         default: "staging"
+ *         description: "Type of deployment"
+ * ```
+ */
+import { z } from 'zod';
 import EasCommand from '../../commandUtils/EasCommand';
 export default class WorkflowRun extends EasCommand {
     static description: string;
@@ -8,6 +50,7 @@ export default class WorkflowRun extends EasCommand {
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         wait: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        input: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined>;
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     static contextDefinition: {
@@ -19,3 +62,65 @@ export default class WorkflowRun extends EasCommand {
     };
     runAsync(): Promise<void>;
 }
+export declare function parseInputs(inputFlags: string[]): Record<string, string>;
+export declare function maybeReadStdinAsync(): Promise<string | null>;
+export declare function parseJsonInputs(jsonString: string): Record<string, string>;
+export declare const WorkflowDispatchInputZ: z.ZodIntersection<z.ZodObject<{
+    description: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodString>>;
+    required: z.ZodDefault<z.ZodUnion<[z.ZodBoolean, z.ZodPipeline<z.ZodNumber, z.ZodBoolean>, z.ZodEffects<z.ZodBoolean, boolean, unknown>]>>;
+}, "strip", z.ZodTypeAny, {
+    required: boolean;
+    description?: string | undefined;
+}, {
+    description?: string | number | undefined;
+    required?: unknown;
+}>, z.ZodUnion<[z.ZodObject<{
+    type: z.ZodDefault<z.ZodLiteral<"string">>;
+    default: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: "string";
+    default?: string | undefined;
+}, {
+    default?: string | number | undefined;
+    type?: "string" | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"boolean">;
+    default: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodPipeline<z.ZodNumber, z.ZodBoolean>, z.ZodEffects<z.ZodBoolean, boolean, unknown>]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "boolean";
+    default?: boolean | undefined;
+}, {
+    type: "boolean";
+    default?: unknown;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"number">;
+    default: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "number";
+    default?: number | undefined;
+}, {
+    type: "number";
+    default?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"choice">;
+    default: z.ZodOptional<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodString>>;
+    options: z.ZodArray<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodString>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "choice";
+    options: string[];
+    default?: string | undefined;
+}, {
+    type: "choice";
+    options: (string | number)[];
+    default?: string | number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"environment">;
+    default: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "environment";
+    default?: string | undefined;
+}, {
+    type: "environment";
+    default?: string | undefined;
+}>]>>;
+export declare function parseWorkflowInputsFromYaml(yamlConfig: string): Record<string, z.infer<typeof WorkflowDispatchInputZ>>;

package/build/commands/workflow/run.js

@@ -1,5 +1,47 @@
 "use strict";
+/**
+ * EAS Workflow Run Command
+ *
+ * This command runs an EAS workflow with support for interactive input prompting.
+ *
+ * Input Sources (in order of precedence):
+ * 1. Command line flags (-F key=value)
+ * 2. STDIN JSON input (echo '{"key": "value"}' | eas workflow:run)
+ * 3. Interactive prompts (when required inputs are missing and not in non-interactive mode)
+ *
+ * Interactive Prompting:
+ * - When running in interactive mode (default), the command will automatically prompt
+ *   for any required inputs that are not provided via flags or STDIN
+ * - Input types supported: string, boolean, number, choice, environment
+ * - Each input type has appropriate validation and default values
+ * - Use --non-interactive flag to disable prompting and require all inputs via flags
+ *
+ * Example workflow with inputs:
+ * ```yaml
+ * on:
+ *   workflow_dispatch:
+ *     inputs:
+ *       environment:
+ *         type: string
+ *         required: true
+ *         description: "Environment to deploy to"
+ *       debug:
+ *         type: boolean
+ *         default: false
+ *         description: "Enable debug mode"
+ *       version:
+ *         type: number
+ *         required: true
+ *         description: "Version number"
+ *       deployment_type:
+ *         type: choice
+ *         options: ["staging", "production"]
+ *         default: "staging"
+ *         description: "Type of deployment"
+ * ```
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWorkflowInputsFromYaml = exports.WorkflowDispatchInputZ = exports.parseJsonInputs = exports.maybeReadStdinAsync = exports.parseInputs = void 0;
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
 const core_2 = require("@urql/core");
@@ -7,6 +49,8 @@ const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const fs = tslib_1.__importStar(require("node:fs"));
 const path = tslib_1.__importStar(require("node:path"));
 const slash_1 = tslib_1.__importDefault(require("slash"));
+const YAML = tslib_1.__importStar(require("yaml"));
+const zod_1 = require("zod");
 const url_1 = require("../../build/utils/url");
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
@@ -19,6 +63,7 @@ const ora_1 = require("../../ora");
 const projectUtils_1 = require("../../project/projectUtils");
 const uploadAccountScopedFileAsync_1 = require("../../project/uploadAccountScopedFileAsync");
 const uploadAccountScopedProjectSourceAsync_1 = require("../../project/uploadAccountScopedProjectSourceAsync");
+const prompts_1 = require("../../prompts");
 const json_1 = require("../../utils/json");
 const promise_1 = require("../../utils/promise");
 const workflowFile_1 = require("../../utils/workflowFile");
@@ -38,6 +83,13 @@ class WorkflowRun extends EasCommand_1.default {
             description: 'Exit codes: 0 = success, 11 = failure, 12 = canceled, 13 = wait aborted.',
             summary: 'Wait for workflow run to complete',
         }),
+        input: core_1.Flags.string({
+            char: 'F',
+            aliases: ['f', 'field'],
+            multiple: true,
+            description: 'Add a parameter in key=value format. Use multiple instances of this flag to set multiple inputs.',
+            summary: 'Set workflow inputs',
+        }),
         ...flags_1.EasJsonOnlyFlag,
     };
     static contextDefinition = {
@@ -86,6 +138,33 @@ class WorkflowRun extends EasCommand_1.default {
                 throw error;
             }
         }
+        let inputs;
+        // Check for stdin input
+        const stdinData = await maybeReadStdinAsync();
+        const inputsFromFlags = [...(flags.input ?? [])];
+        // Validate that both stdin and -F flags are not provided simultaneously
+        if (stdinData && inputsFromFlags.length > 0) {
+            throw new Error('Cannot use both stdin JSON input and -F flags simultaneously. Please use only one input method.');
+        }
+        if (stdinData) {
+            inputs = parseJsonInputs(stdinData);
+        }
+        else if (inputsFromFlags.length > 0) {
+            inputs = parseInputs(inputsFromFlags);
+        }
+        // Parse workflow inputs from YAML and prompt for missing required inputs
+        const inputSpecs = parseWorkflowInputsFromYaml(yamlConfig);
+        if (!flags['non-interactive']) {
+            inputs = await maybePromptForMissingInputsAsync({ inputSpecs, inputs: inputs ?? {} });
+        }
+        if (inputs && Object.keys(inputs).length > 0) {
+            log_1.default.addNewLineIfNone();
+            log_1.default.newLine();
+            log_1.default.log('Running with inputs:');
+            for (const [key, value] of Object.entries(inputs)) {
+                log_1.default.log(`- ${chalk_1.default.bold(key)}: ${JSON.stringify(value)}`);
+            }
+        }
         let projectArchiveBucketKey;
         let easJsonBucketKey = null;
         let packageJsonBucketKey = null;
@@ -134,6 +213,7 @@ class WorkflowRun extends EasCommand_1.default {
                     yamlConfig,
                 },
                 workflowRunInput: {
+                    inputs,
                     projectSource: {
                         type: generated_1.WorkflowProjectSourceType.Gcs,
                         projectArchiveBucketKey,
@@ -226,3 +306,203 @@ async function fileExistsAsync(filePath) {
         .then(() => true)
         .catch(() => false);
 }
+function parseInputs(inputFlags) {
+    const inputs = {};
+    for (const inputFlag of inputFlags) {
+        const equalIndex = inputFlag.indexOf('=');
+        if (equalIndex === -1) {
+            throw new Error(`Invalid input format: ${inputFlag}. Expected key=value format.`);
+        }
+        const key = inputFlag.substring(0, equalIndex);
+        const value = inputFlag.substring(equalIndex + 1);
+        if (!key) {
+            throw new Error(`Invalid input format: ${inputFlag}. Key cannot be empty.`);
+        }
+        inputs[key] = value;
+    }
+    return inputs;
+}
+exports.parseInputs = parseInputs;
+async function maybeReadStdinAsync() {
+    // Check if there's data on stdin
+    if (process.stdin.isTTY) {
+        return null;
+    }
+    return await new Promise((resolve, reject) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('readable', () => {
+            let chunk;
+            while ((chunk = process.stdin.read()) !== null) {
+                data += chunk;
+            }
+        });
+        process.stdin.on('end', () => {
+            const trimmedData = data.trim();
+            resolve(trimmedData || null);
+        });
+        process.stdin.on('error', err => {
+            reject(err);
+        });
+    });
+}
+exports.maybeReadStdinAsync = maybeReadStdinAsync;
+function parseJsonInputs(jsonString) {
+    try {
+        const parsed = JSON.parse(jsonString);
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            throw new Error('JSON input must be an object.');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON input.`, { cause: error });
+    }
+}
+exports.parseJsonInputs = parseJsonInputs;
+// `z.coerce.boolean()` does `Boolean(val)` under the hood,
+// which is not what we want. See:
+// https://github.com/colinhacks/zod/issues/2985#issuecomment-2230692578
+const booleanLike = zod_1.z.union([
+    zod_1.z.boolean(),
+    zod_1.z.number().pipe(zod_1.z.coerce.boolean()),
+    zod_1.z.preprocess(val => {
+        if (typeof val === 'string') {
+            if (val.toLowerCase() === 'true') {
+                return true;
+            }
+            if (val.toLowerCase() === 'false') {
+                return false;
+            }
+        }
+        return val;
+    }, zod_1.z.boolean()),
+]);
+const stringLike = zod_1.z
+    .union([
+    // We're going to coerce numbers and strings into strings.
+    zod_1.z.number(),
+    zod_1.z.string(),
+    // We do not allow other primitives, like:
+    // - bigints, symbols - because YAML does not support them,
+    // - booleans - because YAML accepts `True` and `true` as boolean input
+    //   and parses both as JS `true` -- if we stringified that,
+    //   we would lose the capital "T" which may not be what the user expects,
+    // - nulls - user should do `"null"` or not pass the property at all.
+])
+    .pipe(zod_1.z.coerce.string());
+exports.WorkflowDispatchInputZ = zod_1.z
+    .object({
+    description: stringLike.optional().describe('Description of the input'),
+    required: booleanLike.default(false).describe('Whether the input is required'),
+})
+    .and(zod_1.z.union([
+    zod_1.z.object({
+        type: zod_1.z.literal('string').default('string'),
+        default: stringLike.optional().describe('Default value for the input'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('boolean'),
+        default: booleanLike.optional().describe('Default value for the input'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('number'),
+        default: zod_1.z.number().optional().describe('Default value for the input'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('choice'),
+        default: stringLike.optional().describe('Default value for the input'),
+        options: zod_1.z.array(stringLike).min(1).describe('Options for choice type inputs'),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('environment'),
+        default: zod_1.z.string().optional().describe('Default value for the input'),
+    }),
+]));
+function parseWorkflowInputsFromYaml(yamlConfig) {
+    try {
+        const parsed = YAML.parse(yamlConfig);
+        return zod_1.z
+            .record(zod_1.z.string(), exports.WorkflowDispatchInputZ)
+            .default({})
+            .parse(parsed?.on?.workflow_dispatch?.inputs);
+    }
+    catch (error) {
+        log_1.default.warn('Failed to parse workflow inputs from YAML:', error);
+        return {};
+    }
+}
+exports.parseWorkflowInputsFromYaml = parseWorkflowInputsFromYaml;
+async function maybePromptForMissingInputsAsync({ inputSpecs, inputs, }) {
+    const requiredInputs = Object.entries(inputSpecs).filter(([_, spec]) => spec.required);
+    const missingRequiredInputs = requiredInputs.filter(([key]) => inputs[key] === undefined);
+    if (missingRequiredInputs.length === 0) {
+        return inputs;
+    }
+    log_1.default.addNewLineIfNone();
+    log_1.default.log('Some required inputs are missing. Please provide them:');
+    const nextInputs = { ...inputs };
+    for (const [key, spec] of missingRequiredInputs) {
+        const value = await promptForMissingInputAsync({ key, spec });
+        nextInputs[key] = value;
+    }
+    return nextInputs;
+}
+async function promptForMissingInputAsync({ key, spec, }) {
+    const message = spec.description ? `${key} (${spec.description})` : key;
+    switch (spec.type) {
+        case 'boolean': {
+            const { value } = await (0, prompts_1.promptAsync)({
+                type: 'confirm',
+                name: 'value',
+                message,
+                initial: spec.default,
+            });
+            return value;
+        }
+        case 'number': {
+            const { value } = await (0, prompts_1.promptAsync)({
+                type: 'number',
+                name: 'value',
+                message,
+                initial: spec.default,
+                validate: (val) => {
+                    if (isNaN(val)) {
+                        return 'Please enter a valid number';
+                    }
+                    return true;
+                },
+            });
+            return value;
+        }
+        case 'choice': {
+            const { value } = await (0, prompts_1.promptAsync)({
+                type: 'select',
+                name: 'value',
+                message,
+                choices: spec.options.map(option => ({
+                    title: option,
+                    value: option,
+                })),
+                initial: spec.default,
+            });
+            return value;
+        }
+        case 'string':
+        case 'environment': {
+            const { value } = await (0, prompts_1.promptAsync)({
+                type: 'text',
+                name: 'value',
+                message,
+                initial: spec.default,
+                validate: (val) => {
+                    if (spec.required && (!val || val.trim() === '')) {
+                        return 'This field is required';
+                    }
+                    return true;
+                },
+            });
+            return value;
+        }
+    }
+}

package/build/commands/workflow/runs.js

@@ -5,7 +5,7 @@ const core_1 = require("@oclif/core");
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
 const pagination_1 = require("../../commandUtils/pagination");
-const workflows_1 = require("../../commandUtils/workflows");
+const utils_1 = require("../../commandUtils/workflow/utils");
 const generated_1 = require("../../graphql/generated");
 const AppQuery_1 = require("../../graphql/queries/AppQuery");
 const WorkflowRunQuery_1 = require("../../graphql/queries/WorkflowRunQuery");
@@ -49,7 +49,7 @@ class WorkflowRunList extends EasCommand_1.default {
         else {
             runs = await AppQuery_1.AppQuery.byIdWorkflowRunsFilteredByStatusAsync(graphqlClient, projectId, status, limit);
         }
-        const result = (0, workflows_1.processWorkflowRuns)(runs);
+        const result = (0, utils_1.processWorkflowRuns)(runs);
         if (flags.json) {
             (0, json_1.printJsonOnlyOutput)(result);
             return;
@@ -62,8 +62,9 @@ class WorkflowRunList extends EasCommand_1.default {
                 { label: 'Status', value: run.status },
                 { label: 'Started At', value: run.startedAt },
                 { label: 'Finished At', value: run.finishedAt },
+                { label: 'Trigger Type', value: run.triggerType },
+                { label: 'Trigger', value: run.trigger ?? 'null' },
                 { label: 'Git Commit Message', value: run.gitCommitMessage ?? 'null' },
-                { label: 'Git Commit Hash', value: run.gitCommitHash ?? 'null' },
             ]));
             log_1.default.addNewLineIfNone();
         });

package/build/commands/workflow/view.d.ts

@@ -0,0 +1,17 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class WorkflowView extends EasCommand {
+    static description: string;
+    static flags: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        name: string;
+        description: string;
+    }[];
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/workflow/view.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const url_1 = require("../../build/utils/url");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const stateMachine_1 = require("../../commandUtils/workflow/stateMachine");
+const utils_1 = require("../../commandUtils/workflow/utils");
+const WorkflowRunQuery_1 = require("../../graphql/queries/WorkflowRunQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
+const json_1 = require("../../utils/json");
+class WorkflowView extends EasCommand_1.default {
+    static description = 'view details for a workflow run, including jobs. If no run ID is provided, you will be prompted to select from recent workflow runs for the current project.';
+    static flags = {
+        ...flags_1.EasJsonOnlyFlag,
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static args = [{ name: 'id', description: 'ID of the workflow run to view' }];
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args, flags } = await this.parse(WorkflowView);
+        const nonInteractive = flags['non-interactive'];
+        const { loggedIn: { graphqlClient }, projectId, } = await this.getContextAsync(WorkflowView, {
+            nonInteractive,
+        });
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        if (nonInteractive && !args.id) {
+            throw new Error('If non-interactive, this command requires a workflow run ID as argument');
+        }
+        const actionResult = await (0, stateMachine_1.workflowRunSelectionAction)({
+            graphqlClient,
+            projectId,
+            nonInteractive,
+            allSteps: false,
+            state: stateMachine_1.WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION,
+            runId: args.id,
+        });
+        if (actionResult.state === stateMachine_1.WorkflowCommandSelectionStateValue.ERROR) {
+            log_1.default.error(actionResult.message);
+            return;
+        }
+        const idToQuery = actionResult.runId ?? '';
+        const result = await WorkflowRunQuery_1.WorkflowRunQuery.withJobsByIdAsync(graphqlClient, idToQuery, {
+            useCache: false,
+        });
+        const { triggerType, trigger } = (0, utils_1.computeTriggerInfoForWorkflowRun)(result);
+        result.triggerType = triggerType;
+        result.trigger = trigger;
+        result.jobs.forEach(job => {
+            delete job.turtleJobRun;
+        });
+        result.logURL = (0, url_1.getWorkflowRunUrl)(result.workflow.app.ownerAccount.name, result.workflow.app.name, result.id);
+        if (flags.json) {
+            (0, json_1.printJsonOnlyOutput)(result);
+            return;
+        }
+        log_1.default.log((0, formatFields_1.default)([
+            { label: 'Run ID', value: result.id },
+            { label: 'Workflow', value: result.workflow.fileName },
+            { label: 'Trigger Type', value: result.triggerType },
+            { label: 'Trigger', value: result.trigger ?? 'null' },
+            {
+                label: 'Git Commit Message',
+                value: result.gitCommitMessage?.split('\n')[0] ?? null ?? 'null',
+            },
+            { label: 'Status', value: result.status },
+            { label: 'Errors', value: result.errors.map(error => error.title).join('\n') },
+            { label: 'Created At', value: result.createdAt },
+            { label: 'Updated At', value: result.updatedAt },
+            { label: 'Log URL', value: (0, log_1.link)(result.logURL) },
+        ]));
+        log_1.default.addNewLineIfNone();
+        result.jobs.forEach(job => {
+            log_1.default.log((0, formatFields_1.default)([
+                { label: 'Job ID', value: job.id },
+                { label: '  Key', value: job.key },
+                { label: '  Name', value: job.name },
+                { label: '  Status', value: job.status },
+                { label: '  Type', value: job.type },
+                { label: '  Created At', value: job.createdAt },
+                { label: '  Updated At', value: job.updatedAt },
+                { label: '  Outputs', value: JSON.stringify(job.outputs, null, 2) },
+                { label: '  Errors', value: job.errors.map(error => error.title).join('\n') },
+            ]));
+            log_1.default.addNewLineIfNone();
+        });
+    }
+}
+exports.default = WorkflowView;

package/build/credentials/ios/appstore/bundleIdCapabilities.d.ts

@@ -1,10 +1,8 @@
 /// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
-import { BundleId, CapabilityOptionMap, CapabilityType, MerchantId } from '@expo/apple-utils';
-import { JSONObject, JSONValue } from '@expo/json-file';
+import { BundleId } from '@expo/apple-utils';
+import { JSONObject } from '@expo/json-file';
+import { CapabilityClassifier } from './capabilityList';
 export declare const EXPO_NO_CAPABILITY_SYNC: boolean;
-type GetOptionsMethod<T extends CapabilityType = any> = (entitlement: JSONValue, entitlementsJson: JSONObject, additionalOptions: {
-    usesBroadcastPushNotifications?: boolean;
-}) => CapabilityOptionMap[T];
 /**
  * Given an entitlements JSON object, synchronizes the remote capabilities for a bundle identifier.
  *
@@ -18,6 +16,7 @@ type GetOptionsMethod<T extends CapabilityType = any> = (entitlement: JSONValue,
  *
  * @param bundleId bundle identifier object
  * @param entitlements JSON representation of the entitlements plist
+ * @param additionalOptions Additional options to consider when syncing capabilities.
  * @returns
  */
 export declare function syncCapabilitiesForEntitlementsAsync(bundleId: BundleId, entitlements: JSONObject | undefined, additionalOptions: {
@@ -27,15 +26,3 @@ export declare function syncCapabilitiesForEntitlementsAsync(bundleId: BundleId,
     disabled: string[];
 }>;
 export declare function assertValidOptions(classifier: CapabilityClassifier, value: any): asserts value;
-type CapabilityClassifier = {
-    name: string;
-    entitlement: string;
-    capability: CapabilityType;
-    validateOptions: (options: any) => boolean;
-    getOptions: GetOptionsMethod;
-    capabilityIdModel?: typeof MerchantId;
-    capabilityIdPrefix?: string;
-    options?: undefined;
-};
-export declare const CapabilityMapping: CapabilityClassifier[];
-export {};