@mpgd/cli 0.67.0 → 0.68.0

package/dist/play-release-options.js

@@ -142,14 +142,25 @@ export function assertPlayUserFraction(fraction) {
     }
 }
 export function readPlayReleaseNotesFile(file) {
+    const notes = readLocalizedNotesFile(file);
+    assertPlayReleaseNoteLengths(notes);
+    return notes;
+}
+/**
+ * A per-language notes file in the release-notes format below, without a
+ * store's length limit; `label` names the notes in errors. TestFlight's
+ * "What to Test" (`mpgd deploy testflight distribute --what-to-test`) reads
+ * the same file format as Google Play release notes.
+ */
+export function readLocalizedNotesFile(file, label = 'Release notes') {
     const resolved = path.resolve(file);
     if (!existsSync(resolved) || !statSync(resolved).isFile()) {
-        throw new Error(`Release notes file is missing: ${resolved}`);
+        throw new Error(`${label} file is missing: ${resolved}`);
     }
     if (statSync(resolved).size > maximumReleaseNotesFileBytes) {
-        throw new Error('Release notes file is larger than 256 KiB.');
+        throw new Error(`${label} file is larger than 256 KiB.`);
     }
-    return parsePlayReleaseNotes(readFileSync(resolved, 'utf8'));
+    return parseLocalizedNotes(readFileSync(resolved, 'utf8'), label);
 }
 /**
  * Accepts the Play Console's own language-tag format, one block per language:
@@ -161,10 +172,16 @@ export function readPlayReleaseNotesFile(file) {
  * or JSON: `{ "en-US": "Bug fixes." }` or `[{ "language": "en-US", "text": "Bug fixes." }]`.
  */
 export function parsePlayReleaseNotes(source) {
+    const notes = parseLocalizedNotes(source);
+    assertPlayReleaseNoteLengths(notes);
+    return notes;
+}
+/** `parsePlayReleaseNotes` without Google Play's length limit. */
+export function parseLocalizedNotes(source, label = 'Release notes') {
     const content = source.replace(/^/u, '');
     const trimmed = content.trim();
     if (trimmed === '') {
-        throw new Error('Release notes file is empty.');
+        throw new Error(`${label} file is empty.`);
     }
     let notes;
     if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
@@ -173,7 +190,7 @@ export function parsePlayReleaseNotes(source) {
             parsed = JSON.parse(trimmed);
         }
         catch {
-            throw new Error('Release notes JSON is malformed.');
+            throw new Error(`${label} JSON is malformed.`);
         }
         notes = Array.isArray(parsed)
             ? parsed.map((entry) => {
@@ -181,7 +198,7 @@ export function parsePlayReleaseNotes(source) {
                     || typeof entry.language !== 'string'
                     || typeof entry.text !== 'string'
                     || Object.keys(entry).some((key) => key !== 'language' && key !== 'text')) {
-                    throw new Error('Release notes JSON array entries need only string language and text.');
+                    throw new Error(`${label} JSON array entries need only string language and text.`);
                 }
                 const { language, text } = entry;
                 return { language, text: text.trim() };
@@ -189,7 +206,7 @@ export function parsePlayReleaseNotes(source) {
             : typeof parsed === 'object' && parsed !== null
                 ? Object.entries(parsed).map(([language, text]) => {
                     if (typeof text !== 'string') {
-                        throw new Error(`Release notes for ${language} must be a string.`);
+                        throw new Error(`${label} for ${language} must be a string.`);
                     }
                     return { language, text: text.trim() };
                 })
@@ -201,35 +218,44 @@ export function parsePlayReleaseNotes(source) {
         let consumed = 0;
         for (const match of content.matchAll(block)) {
             if (content.slice(consumed, match.index).trim() !== '') {
-                throw new Error('Release notes text must sit between <language> and </language> tags.');
+                throw new Error(`${label} text must sit between <language> and </language> tags.`);
             }
             notes.push({ language: match[1] ?? '', text: (match[2] ?? '').trim() });
             consumed = match.index + match[0].length;
         }
         if (content.slice(consumed).trim() !== '') {
-            throw new Error('Release notes text must sit between <language> and </language> tags.');
+            throw new Error(`${label} text must sit between <language> and </language> tags.`);
         }
     }
-    assertPlayReleaseNotes(notes);
+    assertLocalizedNotes(notes, label);
     return notes;
 }
 export function assertPlayReleaseNotes(notes) {
+    assertLocalizedNotes(notes, 'Release notes');
+    assertPlayReleaseNoteLengths(notes);
+}
+/** One non-empty text per BCP-47 language, each language once. */
+export function assertLocalizedNotes(notes, label) {
     if (notes.length === 0) {
-        throw new Error('Release notes need at least one language.');
+        throw new Error(`${label} need at least one language.`);
     }
     const seen = new Set();
     for (const note of notes) {
         if (!languageTagPattern.test(note.language)) {
-            throw new Error(`Release notes language is not a BCP-47 tag: ${note.language}`);
+            throw new Error(`${label} language is not a BCP-47 tag: ${note.language}`);
         }
         const key = note.language.toLowerCase();
         if (seen.has(key)) {
-            throw new Error(`Release notes repeat the language ${note.language}.`);
+            throw new Error(`${label} repeat the language ${note.language}.`);
         }
         seen.add(key);
         if (note.text.trim() === '') {
-            throw new Error(`Release notes for ${note.language} are empty.`);
+            throw new Error(`${label} for ${note.language} are empty.`);
         }
+    }
+}
+function assertPlayReleaseNoteLengths(notes) {
+    for (const note of notes) {
         const length = [...note.text].length;
         if (length > maximumPlayReleaseNoteCharacters) {
             throw new Error(`Release notes for ${note.language} are ${length} characters; Google Play allows `

package/dist/store-presence-app-store.js

@@ -98,8 +98,9 @@ async function planWithLocal(input, appStore, local, port) {
     // App Store Connect takes what's new only once a version has been released.
     const first = version !== undefined && !versions.some((candidate) => releasedVersionStates.has(String(candidate.state)) || releasedVersionStates.has(String(candidate.appStoreState)));
     if (version === undefined) {
-        manual.push('No iOS version is editable (PREPARE_FOR_SUBMISSION or rejected): create the next version in App Store '
-            + 'Connect, then plan again. The sync never creates or submits a version.');
+        manual.push('No iOS version is editable (PREPARE_FOR_SUBMISSION or rejected): create the next version with '
+            + '"mpgd store release plan" and apply (or in App Store Connect), then plan again. The sync never creates or '
+            + 'submits a version.');
     }
     const versionLocalizations = version === undefined
         ? []
@@ -139,8 +140,9 @@ async function planWithLocal(input, appStore, local, port) {
     const remoteOnlyLocales = [...new Set([...appInfoLocalizations, ...versionLocalizations].map((entry) => entry.locale))]
         .filter((locale) => !named.has(locale.toLowerCase()))
         .sort();
-    manual.push('App Privacy answers, the age rating, App Review notes and demo account, pricing, availability, release '
-        + 'settings and submitting for review stay in App Store Connect.');
+    manual.push('App Privacy answers, the age rating, pricing and availability stay in App Store Connect; creating the '
+        + 'version, its build, App Review information, release settings and submitting for review are '
+        + '"mpgd store release".');
     const imageRemovals = planned.reduce((sum, locale) => sum + locale.screenshots.reduce((count, set) => count + (set.action === 'replace' ? set.deleteIds.length : 0), 0), 0);
     const blocked = planned.reduce((sum, locale) => sum + [locale.appInfo.action, locale.version.action].filter((action) => action === 'blocked').length
         + locale.screenshots.filter((set) => set.blocked === true).length, 0);

package/dist/store-products-app-store.js

@@ -87,9 +87,9 @@ export async function planAppStoreProducts(input, port) {
         .filter((productId) => !named.has(productId))
         .sort();
     if (products.some((product) => product.action !== 'unchanged' || product.state !== 'APPROVED')) {
-        manual.push('Submit the in-app purchases for App Review in App Store Connect. The first consumable and the '
-            + 'first non-consumable must each go with a new app version (version page > In-App Purchases); '
-            + 'the sync never submits.');
+        manual.push('Submit the in-app purchases for App Review with "mpgd store release": it adds every purchase that is '
+            + "READY_TO_SUBMIT to the app version's review submission (the first consumable and the first "
+            + 'non-consumable must each go with a new app version). The sync never submits.');
     }
     return {
         schemaVersion: 1,

package/dist/testflight-distribution-asc.d.ts

@@ -0,0 +1,35 @@
+import { type AscCommandRunner, type AscCredential } from './asc-session.js';
+import type { TestFlightDistributionPort } from './testflight-distribution-port.js';
+/**
+* The TestFlight distribution port on the pinned `asc` 5.5.0 CLI. Commands
+* (5.5.0 source, `internal/cli/...`):
+*
+* - `apps view`, `builds list` (`builds/builds_commands.go`)
+* - `testflight groups list --app` (App Store Connect `BetaGroup` resources) and
+*   `testflight groups list --build-id`, which prints asc's own membership
+*   result `{ buildId, appId, complete, groups: [{ id, type }] }`
+*   (`testflight/build_group_membership.go`)
+* - `builds build-beta-detail view` (`BuildBetaDetail`: `internalBuildState`,
+*   `externalBuildState`)
+* - `builds add-groups --build-id --group` without `--submit`
+*   (`builds/builds.go`); asc refuses an external group while the build waits
+*   for or failed TestFlight App Review
+* - `builds test-notes list|create` (`builds/build_test_notes.go`): the
+*   build's `BetaBuildLocalization` "What to Test"; create updates the locale
+*   when it exists
+* - `testflight review view|edit` (`testflight/testflight_review.go`): the app's
+*   `BetaAppReviewDetail`; asc prints a stored demo account password as
+*   `(redacted)`
+* - `testflight review submissions list` and `testflight review submit
+*   --confirm`: the build's `BetaAppReviewSubmission`
+*/
+/** Copy and verify the pinned binary; `close` removes it. */
+export declare function openAscTestFlightDistributionSession(credential: AscCredential, options?: {
+  readonly signal?: AbortSignal;
+  readonly secretValues?: readonly string[];
+}): Promise<{
+  readonly port: TestFlightDistributionPort;
+  close(): void;
+}>;
+/** The port over any runner; the tests drive it with recorded asc output. */
+export declare function createAscTestFlightDistributionPort(run: AscCommandRunner): TestFlightDistributionPort;

package/dist/testflight-distribution-asc.js

@@ -0,0 +1,170 @@
+import { ascListTimeoutMs, ascLookupTimeoutMs, isRecord, list, openAscSession, optionalString, requiredString, single, } from './asc-session.js';
+import { readBuildGroupMembership } from './testflight-submission.js';
+/**
+ * The TestFlight distribution port on the pinned `asc` 5.5.0 CLI. Commands
+ * (5.5.0 source, `internal/cli/...`):
+ *
+ * - `apps view`, `builds list` (`builds/builds_commands.go`)
+ * - `testflight groups list --app` (App Store Connect `BetaGroup` resources) and
+ *   `testflight groups list --build-id`, which prints asc's own membership
+ *   result `{ buildId, appId, complete, groups: [{ id, type }] }`
+ *   (`testflight/build_group_membership.go`)
+ * - `builds build-beta-detail view` (`BuildBetaDetail`: `internalBuildState`,
+ *   `externalBuildState`)
+ * - `builds add-groups --build-id --group` without `--submit`
+ *   (`builds/builds.go`); asc refuses an external group while the build waits
+ *   for or failed TestFlight App Review
+ * - `builds test-notes list|create` (`builds/build_test_notes.go`): the
+ *   build's `BetaBuildLocalization` "What to Test"; create updates the locale
+ *   when it exists
+ * - `testflight review view|edit` (`testflight/testflight_review.go`): the app's
+ *   `BetaAppReviewDetail`; asc prints a stored demo account password as
+ *   `(redacted)`
+ * - `testflight review submissions list` and `testflight review submit
+ *   --confirm`: the build's `BetaAppReviewSubmission`
+ */
+/** Copy and verify the pinned binary; `close` removes it. */
+export async function openAscTestFlightDistributionSession(credential, options = {}) {
+    const session = await openAscSession(credential, options.signal, options.secretValues ?? []);
+    return { port: createAscTestFlightDistributionPort(session.run), close: () => session.close() };
+}
+/** The port over any runner; the tests drive it with recorded asc output. */
+export function createAscTestFlightDistributionPort(run) {
+    return {
+        async readAppBundleId(appId) {
+            const app = single(await run(['apps', 'view', '--id', appId], ascLookupTimeoutMs), 'apps view');
+            const bundleId = app.attributes.bundleId;
+            if (app.id !== appId || typeof bundleId !== 'string') {
+                throw new Error('asc apps view returned no bundle ID for the app.');
+            }
+            return bundleId;
+        },
+        async findBuild(appId, marketingVersion, buildNumber) {
+            const builds = list(await run([
+                'builds', 'list',
+                '--app', appId,
+                '--version', marketingVersion,
+                '--build-number', buildNumber,
+                '--platform', 'IOS',
+                '--paginate',
+            ], ascListTimeoutMs), 'builds list').filter((build) => build.attributes.version === buildNumber);
+            if (builds.length > 1) {
+                throw new Error('App Store Connect returned more than one build for this version and build number.');
+            }
+            const build = builds[0];
+            return build === undefined ? undefined : {
+                id: build.id,
+                processingState: requiredString(build.attributes.processingState, 'build processing state'),
+            };
+        },
+        async listGroups(appId) {
+            return list(await run(['testflight', 'groups', 'list', '--app', appId, '--paginate'], ascListTimeoutMs), 'testflight groups list').map((group) => {
+                if (typeof group.attributes.isInternalGroup !== 'boolean') {
+                    throw new Error('asc testflight groups list returned a group without isInternalGroup.');
+                }
+                return {
+                    id: group.id,
+                    name: requiredString(group.attributes.name, 'TestFlight group name'),
+                    isInternal: group.attributes.isInternalGroup,
+                };
+            });
+        },
+        async readBuildBetaState(buildId) {
+            const detail = single(await run(['builds', 'build-beta-detail', 'view', '--build-id', buildId], ascLookupTimeoutMs), 'builds build-beta-detail view');
+            return {
+                internalBuildState: requiredString(detail.attributes.internalBuildState, 'internal build state'),
+                externalBuildState: requiredString(detail.attributes.externalBuildState, 'external build state'),
+            };
+        },
+        async listBuildGroupIds(appId, buildId) {
+            const result = await run(['testflight', 'groups', 'list', '--build-id', buildId, '--app', appId], ascListTimeoutMs);
+            return readBuildGroupMembership(result, buildId).map((group) => group.id);
+        },
+        async addBuildToGroups(buildId, groupIds) {
+            const result = await run(['builds', 'add-groups', '--build-id', buildId, '--group', groupIds.join(',')], ascLookupTimeoutMs);
+            if (!isRecord(result) || result.action !== 'added' || result.buildId !== buildId
+                || !Array.isArray(result.groupIds)
+                || result.groupIds.some((id) => typeof id !== 'string' || !groupIds.includes(id))) {
+                throw new Error('asc builds add-groups returned an unexpected result.');
+            }
+        },
+        async listWhatToTest(buildId) {
+            return list(await run(['builds', 'test-notes', 'list', '--build-id', buildId, '--paginate'], ascListTimeoutMs), 'builds test-notes list').map((localization) => ({
+                id: localization.id,
+                locale: requiredString(localization.attributes.locale, 'What to Test locale'),
+                ...optionalString('whatsNew', localization.attributes.whatsNew),
+            }));
+        },
+        async putWhatToTest(buildId, locale, text) {
+            single(await run([
+                'builds', 'test-notes', 'create',
+                '--build-id', buildId,
+                '--locale', locale,
+                '--whats-new', text,
+            ], ascLookupTimeoutMs), 'builds test-notes create');
+        },
+        async readBetaReviewDetail(appId) {
+            const details = list(await run(['testflight', 'review', 'view', '--app', appId], ascLookupTimeoutMs), 'testflight review view');
+            const detail = details[0];
+            if (detail === undefined || details.length > 1) {
+                throw new Error("asc testflight review view did not return the app's one review detail.");
+            }
+            const attributes = detail.attributes;
+            return {
+                id: detail.id,
+                ...optionalString('contactFirstName', attributes.contactFirstName),
+                ...optionalString('contactLastName', attributes.contactLastName),
+                ...optionalString('contactEmail', attributes.contactEmail),
+                ...optionalString('contactPhone', attributes.contactPhone),
+                ...optionalString('notes', attributes.notes),
+                ...optionalString('demoAccountName', attributes.demoAccountName),
+                demoAccountPasswordSet: typeof attributes.demoAccountPassword === 'string'
+                    && attributes.demoAccountPassword !== '',
+                // asc omits a false demoAccountRequired from its JSON.
+                demoAccountRequired: attributes.demoAccountRequired === true,
+            };
+        },
+        async updateBetaReviewDetail(detailId, changes) {
+            single(await run(['testflight', 'review', 'edit', '--id', detailId, ...reviewDetailFlags(changes)], ascLookupTimeoutMs), 'testflight review edit');
+        },
+        async listBetaReviewSubmissions(buildId) {
+            return list(await run(['testflight', 'review', 'submissions', 'list', '--build-id', buildId, '--paginate'], ascLookupTimeoutMs), 'testflight review submissions list').map(readSubmission);
+        },
+        async submitForBetaReview(buildId) {
+            return readSubmission(single(await run(['testflight', 'review', 'submit', '--build-id', buildId, '--confirm'], ascLookupTimeoutMs), 'testflight review submit'));
+        },
+    };
+}
+function readSubmission(resource) {
+    return {
+        id: resource.id,
+        betaReviewState: requiredString(resource.attributes.betaReviewState, 'beta review state'),
+        ...optionalString('submittedDate', resource.attributes.submittedDate),
+    };
+}
+function reviewDetailFlags(changes) {
+    const flags = [];
+    const text = [
+        ['--contact-first-name', changes.contactFirstName],
+        ['--contact-last-name', changes.contactLastName],
+        ['--contact-email', changes.contactEmail],
+        ['--contact-phone', changes.contactPhone],
+        ['--notes', changes.notes],
+        ['--demo-account-name', changes.demoAccountName],
+        // asc 5.5.0 takes the password only as a flag value; the session redacts
+        // it from asc's output.
+        ['--demo-account-password', changes.demoAccountPassword],
+    ];
+    for (const [flag, value] of text) {
+        if (value !== undefined) {
+            flags.push(flag, value);
+        }
+    }
+    if (changes.demoAccountRequired !== undefined) {
+        flags.push(`--demo-account-required=${String(changes.demoAccountRequired)}`);
+    }
+    if (flags.length === 0) {
+        throw new Error('A TestFlight review detail update needs at least one change.');
+    }
+    return flags;
+}

package/dist/testflight-distribution-port.d.ts

@@ -0,0 +1,73 @@
+/**
+* The App Store Connect operations TestFlight distribution needs, as data the
+* planner can compare. `testflight-distribution-asc.ts` implements it on the
+* pinned `asc` 5.5.0; the tests use an in-memory fake.
+*/
+export interface TestFlightBuild {
+  readonly id: string;
+  /** App Store Connect `Build.processingState`: PROCESSING, FAILED, INVALID or VALID. */
+  readonly processingState: string;
+}
+export interface TestFlightGroup {
+  readonly id: string;
+  readonly name: string;
+  readonly isInternal: boolean;
+}
+/** App Store Connect `BuildBetaDetail` states (`InternalBetaState`, `ExternalBetaState`). */
+export interface TestFlightBuildBetaState {
+  readonly internalBuildState: string;
+  readonly externalBuildState: string;
+}
+/** One `BetaBuildLocalization`: the build's "What to Test" text in one locale. */
+export interface TestFlightWhatToTest {
+  readonly id: string;
+  readonly locale: string;
+  readonly whatsNew?: string;
+}
+/** The app's `BetaAppReviewDetail`; asc never prints the demo account password. */
+export interface TestFlightBetaReviewDetail {
+  readonly id: string;
+  readonly contactFirstName?: string;
+  readonly contactLastName?: string;
+  readonly contactEmail?: string;
+  readonly contactPhone?: string;
+  readonly notes?: string;
+  readonly demoAccountName?: string;
+  /** asc 5.5.0 replaces a stored password with a placeholder; only its presence is known. */
+  readonly demoAccountPasswordSet: boolean;
+  readonly demoAccountRequired: boolean;
+}
+export interface TestFlightBetaReviewDetailChanges {
+  readonly contactFirstName?: string;
+  readonly contactLastName?: string;
+  readonly contactEmail?: string;
+  readonly contactPhone?: string;
+  readonly notes?: string;
+  readonly demoAccountName?: string;
+  readonly demoAccountPassword?: string;
+  readonly demoAccountRequired?: boolean;
+}
+/** A `BetaAppReviewSubmission`; `betaReviewState` is a `BetaReviewState`. */
+export interface TestFlightBetaReviewSubmission {
+  readonly id: string;
+  readonly betaReviewState: string;
+  readonly submittedDate?: string;
+}
+export interface TestFlightDistributionPort {
+  readAppBundleId(appId: string): Promise<string>;
+  /** The build with this marketing version and build number, if App Store Connect has it. */
+  findBuild(appId: string, marketingVersion: string, buildNumber: string): Promise<TestFlightBuild | undefined>;
+  listGroups(appId: string): Promise<readonly TestFlightGroup[]>;
+  readBuildBetaState(buildId: string): Promise<TestFlightBuildBetaState>;
+  /** IDs of the groups that contain the build; throws when the lookup is incomplete. */
+  listBuildGroupIds(appId: string, buildId: string): Promise<readonly string[]>;
+  /** Adds the build to these groups; never submits it for review. */
+  addBuildToGroups(buildId: string, groupIds: readonly string[]): Promise<void>;
+  listWhatToTest(buildId: string): Promise<readonly TestFlightWhatToTest[]>;
+  /** Creates or updates the "What to Test" text of one locale. */
+  putWhatToTest(buildId: string, locale: string, text: string): Promise<void>;
+  readBetaReviewDetail(appId: string): Promise<TestFlightBetaReviewDetail>;
+  updateBetaReviewDetail(detailId: string, changes: TestFlightBetaReviewDetailChanges): Promise<void>;
+  listBetaReviewSubmissions(buildId: string): Promise<readonly TestFlightBetaReviewSubmission[]>;
+  submitForBetaReview(buildId: string): Promise<TestFlightBetaReviewSubmission>;
+}

package/dist/testflight-distribution-port.js

@@ -0,0 +1,6 @@
+/**
+ * The App Store Connect operations TestFlight distribution needs, as data the
+ * planner can compare. `testflight-distribution-asc.ts` implements it on the
+ * pinned `asc` 5.5.0; the tests use an in-memory fake.
+ */
+export {};

package/dist/testflight-distribution.d.ts

@@ -0,0 +1,162 @@
+import { type PlayReleaseNote } from './play-release-options.js';
+import type { TestFlightBetaReviewSubmission, TestFlightDistributionPort } from './testflight-distribution-port.js';
+/**
+* TestFlight distribution of an already uploaded iOS build beyond the
+* internal group of `mpgd deploy submit`: more internal or external groups,
+* the build's "What to Test" per locale, the app's TestFlight review details
+* and, for an external group, the TestFlight App Review submission.
+*
+* Every run reads App Store Connect first and writes only what differs, so a
+* re-run never adds a group twice or submits a build again.
+*/
+/**
+* The build's TestFlight App Review state for external testers:
+*
+* - `not-needed`: no external group was asked for, or App Store Connect lets
+*   external testers have the build without a review submission (Apple: "the
+*   first build you submit requires a full review, but later builds for the
+*   same version might not")
+* - `not-submitted`: the build can be submitted (dry run, or a status read)
+* - `waiting-for-review`, `in-review`, `approved`, `rejected`
+* - `action-required`: TestFlight waits for the export-compliance answer
+*/
+export type TestFlightBetaReviewStatus = 'not-needed' | 'not-submitted' | 'waiting-for-review' | 'in-review' | 'approved' | 'rejected' | 'action-required';
+export interface TestFlightBuildTarget {
+  /** Numeric App Store Connect app ID. */
+  readonly appStoreAppId: string;
+  readonly bundleId: string;
+  readonly marketingVersion: string;
+  readonly buildNumber: string;
+  /**
+  * The build ID the release state recorded once the submission found the
+  * build. `distribute` requires it; `status` matches by version and build
+  * number without it and says so (`buildIdRecorded: false`).
+  */
+  readonly expectedBuildId?: string;
+}
+export interface TestFlightBetaReviewInput {
+  readonly contactFirstName?: string;
+  readonly contactLastName?: string;
+  readonly contactEmail?: string;
+  readonly contactPhone?: string;
+  readonly notes?: string;
+  readonly demoAccount?: {
+    readonly required: boolean;
+    /** Read from the environment variable the review file names. */
+    readonly name?: string;
+    /** Read from the environment variable the review file names; never printed. */
+    readonly password?: string;
+    readonly nameEnv?: string;
+    readonly passwordEnv?: string;
+    /**
+    * Variables a dry run found unset (`requireValues: false`). A plan lists
+    * them; `applyTestFlightDistribution` refuses them before any call.
+    */
+    readonly unresolvedEnv?: readonly string[];
+  };
+}
+export interface TestFlightBetaReviewReadOptions {
+  /** False for a dry run: unset demo account variables are reported, not refused. Default true. */
+  readonly requireValues?: boolean;
+}
+export interface TestFlightDistributionOptions {
+  /** Waits between membership reads after adding groups; tests pass a no-op. */
+  readonly sleep?: (milliseconds: number) => Promise<void>;
+}
+export interface TestFlightDistributionRequest extends TestFlightBuildTarget {
+  /** Group IDs or exact group names; internal and external groups may be mixed. */
+  readonly groups: readonly string[];
+  readonly whatToTest?: readonly PlayReleaseNote[];
+  readonly betaReview?: TestFlightBetaReviewInput;
+}
+export type TestFlightGroupMembership = 'present' | 'add' | 'added' | 'after-review' | 'blocked';
+export interface TestFlightDistributionReport {
+  readonly dryRun: boolean;
+  readonly appStoreAppId: string;
+  readonly marketingVersion: string;
+  readonly buildNumber: string;
+  readonly buildId: string;
+  readonly internalBuildState: string;
+  readonly externalBuildState: string;
+  readonly groups: readonly {
+    readonly id: string;
+    readonly name: string;
+    readonly external: boolean;
+    /**
+    * `after-review`: App Store Connect accepts the group once the open review
+    * ends. `blocked`: not added until the `action-required` step is done.
+    */
+    readonly membership: TestFlightGroupMembership;
+  }[];
+  readonly whatToTest: readonly {
+    readonly locale: string;
+    readonly action: 'unchanged' | 'create' | 'update';
+  }[];
+  /** Names of the review detail fields this run writes (or would write); never their values. */
+  readonly reviewDetailFields: readonly string[];
+  /** Inputs a dry run could not resolve, e.g. `demo account values: missing NAME`; apply needs them. */
+  readonly pendingInputs?: readonly string[];
+  readonly betaReview: {
+    readonly status: TestFlightBetaReviewStatus;
+    /** True when this run submits (dry run: would submit) the build. */
+    readonly submit: boolean;
+    readonly submissionId?: string;
+  };
+  readonly detail?: string;
+}
+export interface TestFlightStatusReport {
+  readonly appStoreAppId: string;
+  readonly marketingVersion: string;
+  readonly buildNumber: string;
+  readonly buildId?: string;
+  /**
+  * False when the release state has no build ID yet, so the build was
+  * matched by app, version and build number only.
+  */
+  readonly buildIdRecorded: boolean;
+  readonly processingState?: string;
+  readonly internalBuildState?: string;
+  readonly externalBuildState?: string;
+  /** Groups that contain the build. */
+  readonly groups: readonly {
+    readonly id: string;
+    readonly name: string;
+    readonly external: boolean;
+  }[];
+  /**
+  * `build-not-ready`: not uploaded or still processing; poll again.
+  * `build-unusable`: failed processing, expired or internal-only; it never
+  * becomes testable, so stop polling.
+  */
+  readonly betaReview: TestFlightBetaReviewStatus | 'build-not-ready' | 'build-unusable';
+  readonly submission?: TestFlightBetaReviewSubmission;
+  readonly detail?: string;
+}
+/** App Store Connect `BetaAppReviewDetail.notes`: "a maximum of 4,000 characters". */
+export declare const maximumBetaReviewNotesCharacters = 4000;
+/** Read App Store Connect and print what `applyTestFlightDistribution` would write. */
+export declare function planTestFlightDistribution(port: TestFlightDistributionPort, request: TestFlightDistributionRequest): Promise<TestFlightDistributionReport>;
+/** Write the differences the plan found: What to Test, groups, review details, submission. */
+export declare function applyTestFlightDistribution(port: TestFlightDistributionPort, request: TestFlightDistributionRequest, options?: TestFlightDistributionOptions): Promise<TestFlightDistributionReport>;
+/** A read-only status of the build's TestFlight groups and App Review, for CI polling. */
+export declare function readTestFlightBuildStatus(port: TestFlightDistributionPort, target: TestFlightBuildTarget): Promise<TestFlightStatusReport>;
+/**
+* Read a TestFlight review details file. Contact fields and notes are plain
+* values; the demo account only names environment variables, which are read
+* here so a sign-in never sits in a committed file.
+*
+*     {
+*       "contactFirstName": "Ada", "contactLastName": "Kim",
+*       "contactEmail": "qa@example.com", "contactPhone": "+82 10 0000 0000",
+*       "notes": "Guest play; no sign-in needed.",
+*       "demoAccount": { "required": false }
+*     }
+*
+* With `"required": true`, `nameEnv` and `passwordEnv` name the variables.
+*/
+export declare function readTestFlightBetaReviewFile(file: string, environment?: NodeJS.ProcessEnv, options?: TestFlightBetaReviewReadOptions): TestFlightBetaReviewInput;
+export declare function parseTestFlightBetaReview(value: unknown, environment?: NodeJS.ProcessEnv, options?: TestFlightBetaReviewReadOptions): TestFlightBetaReviewInput;
+/** The "What to Test" file: the release-notes format of `--release-notes`, without Play's length limit. */
+export declare function readTestFlightWhatToTestFile(file: string): PlayReleaseNote[];
+/** Split a `--groups` value into group IDs or names. */
+export declare function parseTestFlightGroups(value: string): string[];