@invarn/cibuild 2.9.5 → 2.9.7

package/dist/src/yaml/steps/git-fetch-retry-exec.test.js

@@ -1,162 +0,0 @@
-/**
- * Executes the generated shell rather than grepping it.
- *
- * The retry lives entirely in emitted bash, so string assertions prove only
- * that the text was written. These run it: a first-attempt refusal followed by
- * a second-attempt success has to actually pass, and a non-refusal has to fail
- * without burning the retry budget.
- */
-import { describe, test, expect } from '@jest/globals';
-import { execFileSync } from 'child_process';
-import { mkdtempSync, writeFileSync, rmSync, readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { refusedFetchHelpers, retryOnRefusedFetch } from './git-fetch-retry.js';
-const REFUSAL = "fatal: could not read Username for 'https://github.com': terminal prompts disabled";
-/** Wraps the emitted block in the same preamble the real step scripts use. */
-function buildScript(command, attempts = 3) {
-    return [
-        '#!/bin/bash',
-        'set -e',
-        'set -o pipefail',
-        '',
-        ...refusedFetchHelpers(),
-        ...retryOnRefusedFetch({
-            label: 'Package resolution',
-            command,
-            attempts,
-            backoffSeconds: [0, 0, 0, 0],
-        }),
-        'echo "REACHED_THE_END"',
-    ].join('\n');
-}
-function run(command, attempts = 3) {
-    const dir = mkdtempSync(join(tmpdir(), 'cibuild-fetch-retry-'));
-    const scriptPath = join(dir, 'step.sh');
-    writeFileSync(scriptPath, buildScript(command, attempts), { mode: 0o755 });
-    try {
-        const output = execFileSync('bash', [scriptPath], {
-            encoding: 'utf-8',
-            stdio: ['ignore', 'pipe', 'pipe'],
-            cwd: dir,
-            env: { ...process.env, COUNTER: join(dir, 'attempts') },
-        });
-        return { status: 0, output };
-    }
-    catch (e) {
-        return {
-            status: e.status ?? -1,
-            output: `${e.stdout ?? ''}${e.stderr ?? ''}`,
-        };
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-}
-/**
- * A command that records each invocation and refuses the first `n` of them the
- * way git does, then succeeds.
- */
-function refuseFirst(n) {
-    return (`bash -c 'echo x >> "$COUNTER"; ` +
-        `if [ "$(wc -l < "$COUNTER")" -le ${n} ]; then echo "${REFUSAL}" >&2; exit 128; fi; ` +
-        `echo RESOLVED_OK'`);
-}
-describe('retryOnRefusedFetch, executed', () => {
-    test('a first-attempt refusal and a second-attempt success still passes', () => {
-        const r = run(refuseFirst(1));
-        expect(r.status).toBe(0);
-        expect(r.output).toContain('RESOLVED_OK');
-        expect(r.output).toContain('REACHED_THE_END');
-        expect(r.output).toContain('was refused by the server (attempt 1 of 3)');
-    });
-    test('a command that succeeds first time is run exactly once', () => {
-        const r = run(refuseFirst(0));
-        expect(r.status).toBe(0);
-        expect(r.output).toContain('RESOLVED_OK');
-        expect(r.output).not.toContain('was refused by the server');
-    });
-    test('a refusal that never clears fails with the original exit code', () => {
-        const r = run(refuseFirst(99));
-        expect(r.status).toBe(128);
-        expect(r.output).not.toContain('REACHED_THE_END');
-        // and it explains itself rather than blaming a package
-        expect(r.output).toContain('A dependency fetch was refused.');
-        expect(r.output).toContain('HTTP 401');
-    });
-    test('it gives up after exactly the configured number of attempts', () => {
-        const r = run(refuseFirst(99), 3);
-        expect(r.output).toContain('(attempt 1 of 3)');
-        expect(r.output).toContain('(attempt 2 of 3)');
-        // the third attempt runs but is not announced as a retry
-        expect(r.output).not.toContain('(attempt 3 of 3)');
-    });
-    test('a failure that is NOT a refused fetch fails immediately', () => {
-        const r = run(`bash -c 'echo x >> "$COUNTER"; echo "error: no such module" >&2; exit 65'`);
-        expect(r.status).toBe(65);
-        // no retry, and no misleading refused-fetch diagnostic
-        expect(r.output).not.toContain('was refused by the server');
-        expect(r.output).not.toContain('A dependency fetch was refused.');
-    });
-    test('a non-refusal failure is attempted once, not three times', () => {
-        const dir = mkdtempSync(join(tmpdir(), 'cibuild-fetch-count-'));
-        const counter = join(dir, 'attempts');
-        const scriptPath = join(dir, 'step.sh');
-        writeFileSync(scriptPath, buildScript(`bash -c 'echo x >> "${counter}"; exit 65'`), { mode: 0o755 });
-        try {
-            execFileSync('bash', [scriptPath], { stdio: 'ignore', cwd: dir });
-        }
-        catch {
-            /* expected */
-        }
-        const attempts = existsSync(counter)
-            ? readFileSync(counter, 'utf-8').trim().split('\n').length
-            : 0;
-        expect(attempts).toBe(1);
-        rmSync(dir, { recursive: true, force: true });
-    });
-    test('the command output still reaches the log while being captured', () => {
-        const r = run(`bash -c 'echo x >> "$COUNTER"; echo VISIBLE_TO_THE_USER'`);
-        expect(r.output).toContain('VISIBLE_TO_THE_USER');
-    });
-});
-describe('the steps that embed it emit syntactically valid bash', () => {
-    // A syntax error in generated shell is not caught by any string assertion
-    // and would break every build of that type on the first run.
-    const parses = async (script) => {
-        const dir = mkdtempSync(join(tmpdir(), 'cibuild-syntax-'));
-        const p = join(dir, 'step.sh');
-        writeFileSync(p, script);
-        try {
-            execFileSync('bash', ['-n', p], { stdio: 'pipe' });
-        }
-        finally {
-            rmSync(dir, { recursive: true, force: true });
-        }
-    };
-    test('xcode-build-for-test', async () => {
-        const { XcodeBuildForTestStepExecutor } = await import('./xcode.js');
-        const { testConfig } = await import('./test-config.js');
-        const r = await new XcodeBuildForTestStepExecutor().execute({ project_path: "My App.xcworkspace", scheme: "My Scheme", xcconfig_content: 'ARCHS = arm64' }, {}, testConfig);
-        await parses(r.script);
-    });
-    test('xcodebuild', async () => {
-        const { XcodeBuildStepExecutor } = await import('./xcode.js');
-        const { testConfig } = await import('./test-config.js');
-        const r = await new XcodeBuildStepExecutor().execute({ project_path: 'MyApp.xcodeproj', scheme: 'MyApp', is_clean_build: true }, {}, testConfig);
-        await parses(r.script);
-    });
-    test('xcode-build-for-simulator', async () => {
-        const { XcodeBuildForSimulatorStepExecutor } = await import('./xcode.js');
-        const { testConfig } = await import('./test-config.js');
-        const r = await new XcodeBuildForSimulatorStepExecutor().execute({ project_path: "My App.xcworkspace", scheme: "My Scheme", perform_clean_action: 'yes' }, {}, testConfig);
-        await parses(r.script);
-    });
-    test('cocoapods-install', async () => {
-        const { CocoapodsInstallStepExecutor } = await import('./ios-deps.js');
-        const { testConfig } = await import('./test-config.js');
-        const r = await new CocoapodsInstallStepExecutor().execute({ verbose: true }, {}, testConfig);
-        await parses(r.script);
-    });
-});
-//# sourceMappingURL=git-fetch-retry-exec.test.js.map

package/dist/src/yaml/steps/git-fetch-retry.d.ts

@@ -1,62 +0,0 @@
-/**
- * Retrying a refused third-party dependency fetch, and naming the reason when
- * the retry does not save it.
- *
- * A build that resolves its dependencies from public git repositories fetches
- * them anonymously. When a host answers one of those fetches with HTTP 401,
- * git has no credential to fall back on and prints
- *
- *     fatal: could not read Username for 'https://<host>': terminal prompts disabled
- *     fatal: expected flush after ref listing
- *
- * Those two lines are one failure, not two: the transport child asks for a
- * username, cannot prompt, and dies; the parent then finds the ref listing
- * truncated. git asks for a username *only* on a 401, which makes the first
- * line an exact signature for "the server refused this fetch".
- *
- * Such a refusal has been observed to be transient — the same repository
- * readable again a minute or two later, from the same machine and the same
- * address — while landing in the middle of a dependency resolution and taking
- * a multi-minute build down with it.
- *
- * Two things are emitted here, and they are deliberately separate:
- *
- *   - a retry around the fetch, gated on that signature, so a compile error
- *     still fails on the first attempt instead of three attempts later; and
- *   - a diagnostic that re-probes every refused URL and prints the HTTP status
- *     it gets back. Nothing else in the pipeline records that status, so a
- *     build failing this way otherwise reports a missing package rather than a
- *     refused fetch, and a recurrence is unattributable after the fact. The
- *     probe is the whole reason the second occurrence will be cheaper to
- *     explain than the first.
- *
- * The emitted shell is bash and runs under `set -e` / `set -o pipefail`, which
- * is why the exit code is measured explicitly rather than inferred.
- */
-/**
- * The line git prints when, and only when, a server answers a fetch with
- * HTTP 401 and no credential is available.
- */
-export declare const REFUSED_FETCH_SIGNATURE = "could not read Username for";
-export interface RefusedFetchRetryOptions {
-    /** What is being fetched, as it should read in a log line. */
-    label: string;
-    /** The command to run, exactly as it would appear on one shell line. */
-    command: string;
-    /** Total attempts, including the first. Defaults to 3. */
-    attempts?: number;
-    /** Seconds to wait before each retry. Defaults to 15s then 45s. */
-    backoffSeconds?: number[];
-}
-/**
- * Shell functions and state the retry depends on. Emit once per script, before
- * the first `retryOnRefusedFetch` block.
- */
-export declare function refusedFetchHelpers(): string[];
-/**
- * Runs `command`, retrying it while the failure looks like a refused fetch.
- * On the last failure the diagnostic runs and the step exits with the
- * command's own status, so the reported exit code is still the real one.
- */
-export declare function retryOnRefusedFetch(options: RefusedFetchRetryOptions): string[];
-//# sourceMappingURL=git-fetch-retry.d.ts.map

package/dist/src/yaml/steps/git-fetch-retry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"git-fetch-retry.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/git-fetch-retry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB,gCAAgC,CAAC;AAErE,MAAM,WAAW,wBAAwB;IACvC,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAiE9C;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,wBAAwB,GAAG,MAAM,EAAE,CAuC/E"}

package/dist/src/yaml/steps/git-fetch-retry.js

@@ -1,155 +0,0 @@
-/**
- * Retrying a refused third-party dependency fetch, and naming the reason when
- * the retry does not save it.
- *
- * A build that resolves its dependencies from public git repositories fetches
- * them anonymously. When a host answers one of those fetches with HTTP 401,
- * git has no credential to fall back on and prints
- *
- *     fatal: could not read Username for 'https://<host>': terminal prompts disabled
- *     fatal: expected flush after ref listing
- *
- * Those two lines are one failure, not two: the transport child asks for a
- * username, cannot prompt, and dies; the parent then finds the ref listing
- * truncated. git asks for a username *only* on a 401, which makes the first
- * line an exact signature for "the server refused this fetch".
- *
- * Such a refusal has been observed to be transient — the same repository
- * readable again a minute or two later, from the same machine and the same
- * address — while landing in the middle of a dependency resolution and taking
- * a multi-minute build down with it.
- *
- * Two things are emitted here, and they are deliberately separate:
- *
- *   - a retry around the fetch, gated on that signature, so a compile error
- *     still fails on the first attempt instead of three attempts later; and
- *   - a diagnostic that re-probes every refused URL and prints the HTTP status
- *     it gets back. Nothing else in the pipeline records that status, so a
- *     build failing this way otherwise reports a missing package rather than a
- *     refused fetch, and a recurrence is unattributable after the fact. The
- *     probe is the whole reason the second occurrence will be cheaper to
- *     explain than the first.
- *
- * The emitted shell is bash and runs under `set -e` / `set -o pipefail`, which
- * is why the exit code is measured explicitly rather than inferred.
- */
-/**
- * The line git prints when, and only when, a server answers a fetch with
- * HTTP 401 and no credential is available.
- */
-export const REFUSED_FETCH_SIGNATURE = 'could not read Username for';
-/**
- * Shell functions and state the retry depends on. Emit once per script, before
- * the first `retryOnRefusedFetch` block.
- */
-export function refusedFetchHelpers() {
-    return [
-        '# --- refused dependency fetch: retry, then explain -------------------------',
-        'CIBUILD_FETCH_LOG="$(mktemp -t cibuild-fetch)"',
-        '',
-        '# git asks for a username only when a server answers with HTTP 401, so this',
-        '# line means the fetch was refused, not that a package is missing.',
-        'cibuild_fetch_was_refused() {',
-        `  grep -q '${REFUSED_FETCH_SIGNATURE}' "$CIBUILD_FETCH_LOG" 2>/dev/null`,
-        '}',
-        '',
-        '# The status that caused the refusal is recorded nowhere, so ask again and',
-        '# put it in the build log where the next person will find it.',
-        'cibuild_diagnose_refused_fetch() {',
-        '  echo ""',
-        '  echo "──────────────────────────────────────────────────────────────"',
-        '  echo "A dependency fetch was refused."',
-        '  echo ""',
-        '  echo "git asked for a username, which it does only when the server answered"',
-        '  echo "with HTTP 401. That is an authentication refusal, not a missing"',
-        '  echo "package. Re-probing each repository named above:"',
-        '  echo ""',
-        // Every stage here can legitimately match nothing, and under `set -e` with
-        // `pipefail` an empty grep would abort the step and replace the command's
-        // real exit code with 1. The diagnostic must never do that: it runs on the
-        // failure path, and its whole job is to explain a failure it did not cause.
-        `  grep -oE 'https://[^ "'"'"']+' "$CIBUILD_FETCH_LOG" 2>/dev/null \\`,
-        `    | sed -e "s/[.,:;')]*$//" -e 's/\\.git$//' \\`,
-        `    | grep -E '^https://[^/]+/[^/]+/[^/]+$' \\`,
-        '    | sort -u | head -20 \\',
-        '    | while IFS= read -r CIBUILD_FETCH_PROBE_URL; do',
-        '        CIBUILD_FETCH_PROBE_CODE="$(curl -sS -o /dev/null -m 20 \\',
-        `          -w '%{http_code}' \\`,
-        '          "$CIBUILD_FETCH_PROBE_URL/info/refs?service=git-upload-pack" 2>/dev/null)" \\',
-        '          || CIBUILD_FETCH_PROBE_CODE="000"',
-        '        case "$CIBUILD_FETCH_PROBE_CODE" in',
-        '          200)',
-        '            echo "  200  $CIBUILD_FETCH_PROBE_URL"',
-        '            echo "       readable anonymously now — the refusal was transient"',
-        '            ;;',
-        '          401|403)',
-        '            echo "  $CIBUILD_FETCH_PROBE_CODE  $CIBUILD_FETCH_PROBE_URL"',
-        '            echo "       still refused — this repository needs a credential, or the"',
-        '            echo "       host is refusing anonymous reads from this machine"',
-        '            ;;',
-        '          404)',
-        '            echo "  404  $CIBUILD_FETCH_PROBE_URL"',
-        '            echo "       no such repository — check the dependency URL"',
-        '            ;;',
-        '          000)',
-        '            echo "  ---  $CIBUILD_FETCH_PROBE_URL"',
-        '            echo "       unreachable from this machine — network, DNS or TLS"',
-        '            ;;',
-        '          *)',
-        '            echo "  $CIBUILD_FETCH_PROBE_CODE  $CIBUILD_FETCH_PROBE_URL"',
-        '            ;;',
-        '        esac',
-        '      done || true',
-        '  echo ""',
-        '  echo "A 200 above means the fetch would succeed if it ran again now."',
-        '  echo "──────────────────────────────────────────────────────────────"',
-        '  echo ""',
-        '}',
-        '',
-    ];
-}
-/**
- * Runs `command`, retrying it while the failure looks like a refused fetch.
- * On the last failure the diagnostic runs and the step exits with the
- * command's own status, so the reported exit code is still the real one.
- */
-export function retryOnRefusedFetch(options) {
-    const attempts = options.attempts ?? 3;
-    const backoff = options.backoffSeconds ?? [15, 45];
-    const label = options.label.replace(/"/g, '\\"');
-    return [
-        `CIBUILD_FETCH_MAX_ATTEMPTS=${attempts}`,
-        `CIBUILD_FETCH_BACKOFF=(${backoff.join(' ')})`,
-        'CIBUILD_FETCH_ATTEMPT=1',
-        'while :; do',
-        '  set +e',
-        `  ${options.command} 2>&1 | tee "$CIBUILD_FETCH_LOG"`,
-        '  CIBUILD_FETCH_RC=${PIPESTATUS[0]}',
-        '  set -e',
-        '  if [ "$CIBUILD_FETCH_RC" -eq 0 ]; then',
-        '    break',
-        '  fi',
-        // Anything that is not a refused fetch is a real failure: fail now.
-        '  if ! cibuild_fetch_was_refused; then',
-        '    break',
-        '  fi',
-        '  if [ "$CIBUILD_FETCH_ATTEMPT" -ge "$CIBUILD_FETCH_MAX_ATTEMPTS" ]; then',
-        '    break',
-        '  fi',
-        '  CIBUILD_FETCH_WAIT="${CIBUILD_FETCH_BACKOFF[$((CIBUILD_FETCH_ATTEMPT - 1))]:-30}"',
-        `  echo "⚠️  ${label} was refused by the server (attempt $CIBUILD_FETCH_ATTEMPT of $CIBUILD_FETCH_MAX_ATTEMPTS)."`,
-        '  echo "   A refused anonymous fetch is usually transient. Retrying in ${CIBUILD_FETCH_WAIT}s..."',
-        '  sleep "$CIBUILD_FETCH_WAIT"',
-        '  CIBUILD_FETCH_ATTEMPT=$((CIBUILD_FETCH_ATTEMPT + 1))',
-        'done',
-        '',
-        'if [ "$CIBUILD_FETCH_RC" -ne 0 ]; then',
-        '  if cibuild_fetch_was_refused; then',
-        '    cibuild_diagnose_refused_fetch',
-        '  fi',
-        '  exit "$CIBUILD_FETCH_RC"',
-        'fi',
-        '',
-    ];
-}
-//# sourceMappingURL=git-fetch-retry.js.map

package/dist/src/yaml/steps/git-fetch-retry.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tests for retrying a refused third-party dependency fetch.
- */
-export {};
-//# sourceMappingURL=git-fetch-retry.test.d.ts.map

package/dist/src/yaml/steps/git-fetch-retry.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"git-fetch-retry.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/git-fetch-retry.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/src/yaml/steps/git-fetch-retry.test.js

@@ -1,86 +0,0 @@
-/**
- * Tests for retrying a refused third-party dependency fetch.
- */
-import { describe, test, expect } from '@jest/globals';
-import { REFUSED_FETCH_SIGNATURE, refusedFetchHelpers, retryOnRefusedFetch, } from './git-fetch-retry.js';
-const helpers = () => refusedFetchHelpers().join('\n');
-const retry = (o) => retryOnRefusedFetch(o).join('\n');
-describe('refusedFetchHelpers', () => {
-    test('keys off the line git prints only for an HTTP 401', () => {
-        expect(REFUSED_FETCH_SIGNATURE).toBe('could not read Username for');
-        expect(helpers()).toContain(REFUSED_FETCH_SIGNATURE);
-    });
-    test('captures output to a log the diagnostic can re-read', () => {
-        const script = helpers();
-        expect(script).toContain('CIBUILD_FETCH_LOG=');
-        expect(script).toContain('mktemp');
-    });
-    test('re-probes each refused URL for its HTTP status', () => {
-        const script = helpers();
-        // The whole point: the 401 is recorded nowhere, so ask again and print it.
-        expect(script).toContain('info/refs?service=git-upload-pack');
-        expect(script).toContain("-w '%{http_code}'");
-        expect(script).toContain('cibuild_diagnose_refused_fetch()');
-    });
-    test('explains each status it can get back', () => {
-        const script = helpers();
-        expect(script).toContain('200)');
-        expect(script).toContain('401|403)');
-        expect(script).toContain('404)');
-        // An unreachable host must not be reported as a refusal.
-        expect(script).toContain('000)');
-        expect(script).toContain('unreachable from this machine');
-    });
-    test('never lets a probe failure abort the step', () => {
-        // The diagnostic runs on the failure path; it must not mask the real error.
-        expect(helpers()).toContain('|| CIBUILD_FETCH_PROBE_CODE="000"');
-    });
-});
-describe('retryOnRefusedFetch', () => {
-    const opts = { label: 'Package resolution', command: 'xcodebuild -resolvePackageDependencies' };
-    test('runs the command it was given', () => {
-        expect(retry(opts)).toContain('xcodebuild -resolvePackageDependencies');
-    });
-    test('streams output live while still capturing it', () => {
-        const script = retry(opts);
-        expect(script).toContain('| tee "$CIBUILD_FETCH_LOG"');
-        // tee would otherwise mask the command's own exit code.
-        expect(script).toContain('${PIPESTATUS[0]}');
-    });
-    test('retries only when the failure is a refused fetch', () => {
-        const script = retry(opts);
-        // A compile error must fail on the first attempt, not after three.
-        expect(script).toContain('if ! cibuild_fetch_was_refused; then');
-        expect(script).toContain('break');
-    });
-    test('backs off between attempts', () => {
-        const script = retry({ ...opts, attempts: 3, backoffSeconds: [15, 45] });
-        expect(script).toContain('CIBUILD_FETCH_BACKOFF=(15 45)');
-        expect(script).toContain('sleep');
-    });
-    test('defaults to three attempts', () => {
-        expect(retry(opts)).toContain('CIBUILD_FETCH_MAX_ATTEMPTS=3');
-    });
-    test('honours a custom attempt count', () => {
-        expect(retry({ ...opts, attempts: 5 })).toContain('CIBUILD_FETCH_MAX_ATTEMPTS=5');
-    });
-    test('diagnoses and then fails with the original exit code', () => {
-        const script = retry(opts);
-        expect(script).toContain('cibuild_diagnose_refused_fetch');
-        expect(script).toContain('exit "$CIBUILD_FETCH_RC"');
-    });
-    test('names the thing being fetched in its retry message', () => {
-        expect(retry(opts)).toContain('Package resolution');
-    });
-    test('does not use a bare && before break, which set -e would trip on', () => {
-        // `[ x ] && break` returns 1 when the test is false and aborts under set -e.
-        expect(retry(opts)).not.toMatch(/\]\s*&&\s*break/);
-    });
-    test('restores set -e after measuring the exit code', () => {
-        const script = retry(opts);
-        expect(script).toContain('set +e');
-        expect(script).toContain('set -e');
-        expect(script.indexOf('set +e')).toBeLessThan(script.lastIndexOf('set -e'));
-    });
-});
-//# sourceMappingURL=git-fetch-retry.test.js.map

package/dist/src/yaml/steps/google-play-deploy.d.ts

@@ -1,37 +0,0 @@
-/**
- * Google Play deploy step implementation
- * Uploads APK/AAB to Google Play using fastlane supply
- */
-import { BaseStepExecutor } from './base.js';
-import type { StepDef, CIConfig } from '../../types.js';
-import type { ValidationRequirement } from '../validation-types.js';
-/**
- * Inputs for google-play-deploy step
- */
-export interface GooglePlayDeployInputs {
-    artifact_type?: string;
-    service_account_json_key_path?: string;
-    service_account_json_var?: string;
-    package_name?: string;
-    app_path?: string;
-    track?: string;
-    user_fraction?: string;
-    status?: string;
-    update_priority?: string;
-    whatsnews_dir?: string;
-    mapping_file?: string;
-    retry_without_sending_to_review?: string;
-    ack_bundle_installation_warning?: string;
-    dry_run?: string;
-    verbose_log?: string;
-}
-/**
- * Google Play deploy step executor
- * Maps google-play-deploy to fastlane supply
- */
-export declare class GooglePlayDeployStepExecutor extends BaseStepExecutor {
-    isSkippedInLocalMode(): boolean;
-    getValidationRequirements(inputs: GooglePlayDeployInputs, env: Record<string, string>, _config: CIConfig): ValidationRequirement[];
-    execute(inputs: GooglePlayDeployInputs, env: Record<string, string>, config: CIConfig): Promise<StepDef>;
-}
-//# sourceMappingURL=google-play-deploy.d.ts.map

package/dist/src/yaml/steps/google-play-deploy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"google-play-deploy.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/google-play-deploy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,6BAA6B,CAAC,EAAE,MAAM,CAAC;IACvC,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+BAA+B,CAAC,EAAE,MAAM,CAAC;IACzC,+BAA+B,CAAC,EAAE,MAAM,CAAC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,qBAAa,4BAA6B,SAAQ,gBAAgB;IAChE,oBAAoB,IAAI,OAAO;IAI/B,yBAAyB,CACvB,MAAM,EAAE,sBAAsB,EAC9B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,OAAO,EAAE,QAAQ,GAChB,qBAAqB,EAAE;IAoBpB,OAAO,CAAC,MAAM,EAAE,sBAAsB,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;CAsL/G"}