import { b as Platform, C as CertificateType, a as ProfileState, P as ProfileType, D as DeviceClass, c as DeviceStatus, B as BundleIdPlatform, d as CapabilityType, g as ContentRightsDeclaration, h as BuildProcessingState, A as AppStoreVersionState, R as ReleaseType } from './enums-B609j2rb.cjs';

interface TokenConfig {
    keyId: string;
    /** Issuer ID. When absent, the key is treated as an individual key (sub='user'). */
    issuerId?: string;
    privateKey: string;
    enterprise?: boolean;
    duration?: number;
}
declare class TokenManager {
    private config;
    private currentToken;
    private expiresAt;
    constructor(config: TokenConfig);
    getToken(): Promise<string>;
    refresh(): Promise<string>;
    invalidate(): void;
}

interface JsonApiResource<T extends string = string, A = Record<string, unknown>> {
    id: string;
    type: T;
    attributes: A;
    relationships?: Record<string, JsonApiRelationship>;
    links?: {
        self?: string;
    };
}
interface JsonApiRelationship {
    data: {
        type: string;
        id: string;
    } | Array<{
        type: string;
        id: string;
    }> | null;
    links?: {
        self?: string;
        related?: string;
    };
}
interface JsonApiResponse<T = JsonApiResource> {
    data: T;
    included?: JsonApiResource[];
    links?: {
        self?: string;
        next?: string;
        first?: string;
    };
    meta?: {
        paging?: {
            total: number;
            limit: number;
        };
    };
}
interface JsonApiListResponse<T = JsonApiResource> {
    data: T[];
    included?: JsonApiResource[];
    links?: {
        self?: string;
        next?: string;
        first?: string;
    };
    meta?: {
        paging?: {
            total: number;
            limit: number;
        };
    };
}
interface JsonApiErrorResponse {
    errors: JsonApiError[];
}
interface JsonApiError {
    id?: string;
    status: string;
    code: string;
    title: string;
    detail: string;
    source?: {
        pointer?: string;
        parameter?: string;
    };
}
interface RequestOptions {
    method?: "GET" | "POST" | "PATCH" | "DELETE";
    body?: unknown;
    params?: Record<string, string | string[] | number | undefined>;
    headers?: Record<string, string>;
}
interface ListParams {
    filter?: Record<string, string | string[]>;
    include?: string;
    fields?: Record<string, string>;
    limit?: number;
    sort?: string;
    cursor?: string;
}
interface AppStoreConnectConfig {
    keyId: string;
    /** Issuer ID. When absent, the key is treated as an individual key (JWT sub='user'). */
    issuerId?: string;
    privateKey: string;
    enterprise?: boolean;
    tokenDuration?: number;
}

declare class AppStoreConnectError extends Error {
    status: number;
    errors: JsonApiErrorResponse["errors"];
    constructor(message: string, status: number, errors?: JsonApiErrorResponse["errors"]);
}
declare class RateLimitError extends AppStoreConnectError {
    retryAfter: number;
    constructor(retryAfter: number);
}
declare class RequestClient {
    private baseUrl;
    private tokenManager;
    constructor(tokenManager: TokenManager, enterprise?: boolean);
    request<T>(path: string, options?: RequestOptions): Promise<T>;
    get<T>(path: string, params?: Record<string, string | string[] | number | undefined>): Promise<T>;
    post<T>(path: string, body: unknown): Promise<T>;
    patch<T>(path: string, body: unknown): Promise<T>;
    delete(path: string): Promise<void>;
    buildListParams(params: ListParams): Record<string, string | undefined>;
    list<T>(path: string, params?: ListParams): Promise<JsonApiListResponse<T>>;
    paginate<T>(path: string, params?: ListParams): AsyncGenerator<T, void, undefined>;
    all<T>(path: string, params?: ListParams): Promise<T[]>;
}

interface Certificate {
    id: string;
    type: "certificates";
    attributes: {
        certificateContent: string;
        displayName: string;
        expirationDate: string;
        name: string;
        platform: Platform | null;
        serialNumber: string;
        certificateType: CertificateType;
        requesterEmail: string | null;
        requesterFirstName: string | null;
        requesterLastName: string | null;
    };
}

declare class CertificatesResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            certificateType?: CertificateType | CertificateType[];
            serialNumber?: string;
            displayName?: string;
            id?: string | string[];
        };
        fields?: string[];
        limit?: number;
        sort?: string;
    }): Promise<Certificate[]>;
    get(id: string): Promise<Certificate>;
    create(params: {
        certificateType: CertificateType;
        csrContent: string;
    }): Promise<Certificate>;
    revoke(id: string): Promise<void>;
    paginate(params?: {
        filter?: {
            certificateType?: CertificateType | CertificateType[];
        };
        limit?: number;
    }): AsyncGenerator<Certificate>;
}

interface Profile {
    id: string;
    type: "profiles";
    attributes: {
        name: string;
        platform: Platform | null;
        profileContent: string;
        uuid: string;
        createdDate: string;
        profileState: ProfileState;
        profileType: ProfileType;
        expirationDate: string;
    };
    relationships?: {
        bundleId?: {
            data: {
                type: "bundleIds";
                id: string;
            };
        };
        certificates?: {
            data: Array<{
                type: "certificates";
                id: string;
            }>;
        };
        devices?: {
            data: Array<{
                type: "devices";
                id: string;
            }>;
        };
    };
}

interface Device {
    id: string;
    type: "devices";
    attributes: {
        deviceClass: DeviceClass;
        model: string | null;
        name: string;
        platform: Platform;
        status: DeviceStatus;
        udid: string;
        addedDate: string;
    };
}

interface BundleId {
    id: string;
    type: "bundleIds";
    attributes: {
        identifier: string;
        name: string;
        seedId: string;
        platform: BundleIdPlatform;
    };
    relationships?: {
        bundleIdCapabilities?: {
            data: Array<{
                type: "bundleIdCapabilities";
                id: string;
            }>;
        };
        profiles?: {
            data: Array<{
                type: "profiles";
                id: string;
            }>;
        };
    };
}

declare class ProfilesResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            profileType?: ProfileType | ProfileType[];
            profileState?: ProfileState;
            name?: string;
            id?: string | string[];
        };
        include?: string;
        fields?: {
            profiles?: string[];
            certificates?: string[];
            devices?: string[];
            bundleIds?: string[];
        };
        limit?: number;
        sort?: string;
    }): Promise<Profile[]>;
    get(id: string, params?: {
        include?: string;
    }): Promise<Profile>;
    create(params: {
        name: string;
        profileType: ProfileType;
        bundleIdId: string;
        certificateIds: string[];
        deviceIds?: string[];
    }): Promise<Profile>;
    delete(id: string): Promise<void>;
    getCertificates(profileId: string): Promise<Certificate[]>;
    getDevices(profileId: string): Promise<Device[]>;
    getBundleId(profileId: string): Promise<BundleId>;
}

interface BundleIdCapability {
    id: string;
    type: "bundleIdCapabilities";
    attributes: {
        capabilityType: CapabilityType;
        settings: CapabilitySetting[] | null;
    };
}
/**
 * Input shape for setting a capability's settings on POST/PATCH
 * `/v1/bundleIdCapabilities`. Matches the payload Fastlane's
 * `Produce::Service#build_settings_for` emits (service.rb lines 81-88).
 */
interface CapabilitySettingInput {
    key: string;
    options: Array<{
        key: string;
    }>;
}
interface CapabilitySetting {
    key: string;
    name: string;
    description: string;
    enabledByDefault: boolean;
    visible: boolean;
    allowedInstances: string;
    minInstances: number;
    options: CapabilityOption[];
}
interface CapabilityOption {
    key: string;
    name: string;
    description: string;
    enabledByDefault: boolean;
    enabled: boolean;
    supportsWildcard: boolean;
}

declare class BundleIdsResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            identifier?: string;
            name?: string;
            platform?: BundleIdPlatform;
            seedId?: string;
            id?: string | string[];
        };
        include?: string;
        fields?: {
            bundleIds?: string[];
            bundleIdCapabilities?: string[];
        };
        limit?: number;
        sort?: string;
    }): Promise<BundleId[]>;
    get(id: string, params?: {
        include?: string;
    }): Promise<BundleId>;
    create(params: {
        identifier: string;
        name: string;
        platform: BundleIdPlatform;
        seedId?: string;
    }): Promise<BundleId>;
    find(identifier: string): Promise<BundleId | null>;
    getCapabilities(bundleIdId: string): Promise<BundleIdCapability[]>;
}

declare class DevicesResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            name?: string;
            platform?: Platform | Platform[];
            status?: DeviceStatus;
            udid?: string;
            id?: string | string[];
        };
        fields?: string[];
        limit?: number;
        sort?: string;
    }): Promise<Device[]>;
    get(id: string): Promise<Device>;
    register(params: {
        name: string;
        platform: Platform;
        udid: string;
    }): Promise<Device>;
    update(id: string, params: {
        name?: string;
        status?: DeviceStatus;
    }): Promise<Device>;
    findByUdid(udid: string): Promise<Device | null>;
}

interface App {
    id: string;
    type: "apps";
    attributes: {
        name: string;
        bundleId: string;
        sku: string;
        primaryLocale: string;
        removed: boolean;
        isAAG: boolean;
        availableInNewTerritories: boolean;
        contentRightsDeclaration: ContentRightsDeclaration | null;
    };
    relationships?: {
        appStoreVersions?: {
            data: Array<{
                type: "appStoreVersions";
                id: string;
            }>;
        };
        betaGroups?: {
            data: Array<{
                type: "betaGroups";
                id: string;
            }>;
        };
    };
}

declare class AppsResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            bundleId?: string;
            name?: string;
            sku?: string;
            id?: string | string[];
        };
        include?: string;
        fields?: {
            apps?: string[];
        };
        limit?: number;
        sort?: string;
    }): Promise<App[]>;
    get(id: string, params?: {
        include?: string;
    }): Promise<App>;
    findByBundleId(bundleId: string): Promise<App | null>;
    /**
     * Create an App Store Connect **app record** (the thing that shows up
     * under "My Apps" and that TestFlight / App Store uploads require).
     *
     * This is distinct from registering an App ID in the Developer Portal —
     * you need BOTH. The Developer Portal App ID unlocks provisioning
     * profiles and entitlements; the App Store Connect app record unlocks
     * uploads. `upload_to_testflight` fails with "Couldn't find app
     * 'com.foo.bar' on the account…" when this record is missing.
     *
     * `bundleIdId` is the REST API primary key of the bundle id resource
     * (not the identifier string) — fetch it via `bundleIds.find(identifier)`
     * or from the response of `bundleIds.create()`.
     *
     * `sku` is an arbitrary unique string Apple uses to identify the app in
     * their internal records. If you don't have a meaningful one, pass the
     * bundle identifier itself or append a timestamp for uniqueness.
     */
    create(params: {
        bundleIdentifier: string;
        bundleIdId: string;
        appName: string;
        sku: string;
        primaryLocale?: string;
    }): Promise<App>;
}

interface Build {
    id: string;
    type: "builds";
    attributes: {
        version: string;
        uploadedDate: string;
        expirationDate: string;
        expired: boolean;
        minOsVersion: string | null;
        iconAssetToken: unknown | null;
        processingState: BuildProcessingState;
        buildAudienceType: string | null;
        usesNonExemptEncryption: boolean | null;
        computedMinMacOsVersion: string | null;
    };
    relationships?: {
        app?: {
            data: {
                type: "apps";
                id: string;
            };
        };
        preReleaseVersion?: {
            data: {
                type: "preReleaseVersions";
                id: string;
            } | null;
        };
        buildBetaDetail?: {
            data: {
                type: "buildBetaDetails";
                id: string;
            } | null;
        };
        betaGroups?: {
            data: Array<{
                type: "betaGroups";
                id: string;
            }>;
        };
    };
}
interface BetaGroup {
    id: string;
    type: "betaGroups";
    attributes: {
        name: string;
        isInternalGroup: boolean;
        publicLinkEnabled: boolean;
        publicLinkId: string | null;
        publicLinkLimit: number | null;
        publicLink: string | null;
        feedbackEnabled: boolean;
        hasAccessToAllBuilds: boolean;
        iosBuildsAvailableForAppleSiliconMac: boolean;
    };
    relationships?: {
        app?: {
            data: {
                type: "apps";
                id: string;
            };
        };
        builds?: {
            data: Array<{
                type: "builds";
                id: string;
            }>;
        };
        betaTesters?: {
            data: Array<{
                type: "betaTesters";
                id: string;
            }>;
        };
    };
}
interface BetaBuildLocalization {
    id: string;
    type: "betaBuildLocalizations";
    attributes: {
        whatsNew: string | null;
        locale: string;
    };
}
interface BuildBetaDetail {
    id: string;
    type: "buildBetaDetails";
    attributes: {
        autoNotifyEnabled: boolean;
        internalBuildState: string;
        externalBuildState: string;
    };
}
interface PreReleaseVersion$1 {
    id: string;
    type: "preReleaseVersions";
    attributes: {
        version: string;
        platform: string;
    };
}

declare class BuildsResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            app?: string;
            version?: string;
            processingState?: string;
            "preReleaseVersion.version"?: string;
            expired?: string;
            id?: string | string[];
        };
        include?: string;
        fields?: {
            builds?: string[];
        };
        limit?: number;
        sort?: string;
    }): Promise<Build[]>;
    get(id: string, params?: {
        include?: string;
    }): Promise<Build>;
    getBetaDetail(buildId: string): Promise<BuildBetaDetail>;
    getLocalizations(buildId: string): Promise<BetaBuildLocalization[]>;
    createLocalization(params: {
        buildId: string;
        locale: string;
        whatsNew: string;
    }): Promise<BetaBuildLocalization>;
    updateLocalization(localizationId: string, params: {
        whatsNew: string;
    }): Promise<BetaBuildLocalization>;
    getPreReleaseVersion(buildId: string): Promise<PreReleaseVersion$1 | null>;
    submitForBetaReview(buildId: string): Promise<void>;
    expireBuild(buildId: string): Promise<void>;
}

declare class BetaGroupsResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            app?: string;
            name?: string;
            isInternalGroup?: string;
            id?: string | string[];
        };
        fields?: string[];
        limit?: number;
        sort?: string;
    }): Promise<BetaGroup[]>;
    get(id: string): Promise<BetaGroup>;
    listForApp(appId: string): Promise<BetaGroup[]>;
    addBuilds(groupId: string, buildIds: string[]): Promise<void>;
    removeBuilds(groupId: string, buildIds: string[]): Promise<void>;
    findByName(appId: string, name: string): Promise<BetaGroup | null>;
}

declare class CapabilitiesResource {
    private http;
    constructor(http: RequestClient);
    listForBundleId(bundleIdId: string): Promise<BundleIdCapability[]>;
    enable(params: {
        bundleIdId: string;
        capabilityType: CapabilityType;
        settings?: CapabilitySettingInput[];
    }): Promise<BundleIdCapability>;
    update(capabilityId: string, params: {
        capabilityType: CapabilityType;
        settings?: CapabilitySettingInput[];
    }): Promise<BundleIdCapability>;
    disable(capabilityId: string): Promise<void>;
}

interface AppStoreVersion {
    id: string;
    type: "appStoreVersions";
    attributes: {
        platform: Platform;
        versionString: string;
        appStoreState: AppStoreVersionState;
        copyright: string | null;
        releaseType: ReleaseType | null;
        earliestReleaseDate: string | null;
        downloadable: boolean;
        createdDate: string;
    };
    relationships?: {
        app?: {
            data: {
                type: "apps";
                id: string;
            };
        };
        build?: {
            data: {
                type: "builds";
                id: string;
            } | null;
        };
        appStoreVersionLocalizations?: {
            data: Array<{
                type: "appStoreVersionLocalizations";
                id: string;
            }>;
        };
    };
}
interface AppStoreVersionLocalization {
    id: string;
    type: "appStoreVersionLocalizations";
    attributes: {
        description: string | null;
        locale: string;
        keywords: string | null;
        marketingUrl: string | null;
        promotionalText: string | null;
        supportUrl: string | null;
        whatsNew: string | null;
    };
}
declare class AppStoreVersionsResource {
    private http;
    constructor(http: RequestClient);
    listForApp(appId: string, params?: {
        filter?: {
            appStoreState?: AppStoreVersionState | AppStoreVersionState[];
            platform?: Platform;
        };
        include?: string;
        limit?: number;
    }): Promise<AppStoreVersion[]>;
    get(id: string, params?: {
        include?: string;
    }): Promise<AppStoreVersion>;
    create(params: {
        appId: string;
        versionString: string;
        platform: Platform;
        releaseType?: ReleaseType;
        earliestReleaseDate?: string;
        copyright?: string;
    }): Promise<AppStoreVersion>;
    update(id: string, params: {
        versionString?: string;
        copyright?: string;
        releaseType?: ReleaseType;
        earliestReleaseDate?: string | null;
    }): Promise<AppStoreVersion>;
    setBuild(versionId: string, buildId: string): Promise<void>;
    getLocalizations(versionId: string): Promise<AppStoreVersionLocalization[]>;
    createLocalization(params: {
        versionId: string;
        locale: string;
        description?: string;
        keywords?: string;
        marketingUrl?: string;
        promotionalText?: string;
        supportUrl?: string;
        whatsNew?: string;
    }): Promise<AppStoreVersionLocalization>;
    updateLocalization(localizationId: string, params: {
        description?: string;
        keywords?: string;
        marketingUrl?: string;
        promotionalText?: string;
        supportUrl?: string;
        whatsNew?: string;
    }): Promise<AppStoreVersionLocalization>;
}

interface AppScreenshotSet {
    id: string;
    type: "appScreenshotSets";
    attributes: {
        screenshotDisplayType: string;
    };
}
interface AppScreenshot {
    id: string;
    type: "appScreenshots";
    attributes: {
        fileSize: number;
        fileName: string;
        sourceFileChecksum: string | null;
        imageAsset: {
            templateUrl: string;
            width: number;
            height: number;
        } | null;
        assetToken: string | null;
        assetType: string | null;
        uploadOperations: UploadOperation[] | null;
        assetDeliveryState: {
            state: string;
            errors: unknown[];
        } | null;
    };
}
interface UploadOperation {
    method: string;
    url: string;
    length: number;
    offset: number;
    requestHeaders: Array<{
        name: string;
        value: string;
    }>;
}
declare class AppScreenshotsResource {
    private http;
    constructor(http: RequestClient);
    listSetsForLocalization(localizationId: string): Promise<AppScreenshotSet[]>;
    createSet(params: {
        localizationId: string;
        screenshotDisplayType: string;
    }): Promise<AppScreenshotSet>;
    listScreenshots(setId: string): Promise<AppScreenshot[]>;
    reserveScreenshot(params: {
        setId: string;
        fileName: string;
        fileSize: number;
    }): Promise<AppScreenshot>;
    commitScreenshot(screenshotId: string, params: {
        sourceFileChecksum: string;
        uploaded: boolean;
    }): Promise<AppScreenshot>;
    deleteScreenshot(screenshotId: string): Promise<void>;
    deleteSet(setId: string): Promise<void>;
}

interface ReviewSubmission {
    id: string;
    type: "reviewSubmissions";
    attributes: {
        state: string;
        submittedDate: string | null;
        platform: string;
    };
}
interface AppStoreVersionSubmission {
    id: string;
    type: "appStoreVersionSubmissions";
}
declare class ReviewSubmissionsResource {
    private http;
    constructor(http: RequestClient);
    submitVersion(versionId: string): Promise<AppStoreVersionSubmission>;
    createReviewSubmission(params: {
        appId: string;
        platform: string;
    }): Promise<ReviewSubmission>;
    confirmReviewSubmission(submissionId: string): Promise<ReviewSubmission>;
}

/**
 * App Info is the metadata container that holds an app's categories, age
 * ratings, and localisations for a single submission cycle. Ported from
 * `spaceship/connect_api/models/app_info.rb`.
 */
interface AppInfoAttributes {
    appStoreState?: string | null;
    state?: string | null;
    appStoreAgeRating?: string | null;
    brazilAgeRating?: string | null;
    kidsAgeBand?: string | null;
}
type AppInfo = JsonApiResource<"appInfos", AppInfoAttributes>;
declare class AppInfosResource {
    private http;
    constructor(http: RequestClient);
    listForApp(appId: string, params?: {
        include?: string;
        limit?: number;
    }): Promise<AppInfo[]>;
    get(id: string, params?: {
        include?: string;
    }): Promise<AppInfo>;
    update(id: string, relationships?: Record<string, {
        type: string;
        id: string;
    } | null>): Promise<AppInfo>;
    delete(id: string): Promise<void>;
}

interface AppInfoLocalizationAttributes {
    locale: string;
    name?: string | null;
    subtitle?: string | null;
    privacyPolicyUrl?: string | null;
    privacyChoicesUrl?: string | null;
    privacyPolicyText?: string | null;
}
type AppInfoLocalization = JsonApiResource<"appInfoLocalizations", AppInfoLocalizationAttributes>;
declare class AppInfoLocalizationsResource {
    private http;
    constructor(http: RequestClient);
    listForAppInfo(appInfoId: string, params?: {
        limit?: number;
    }): Promise<AppInfoLocalization[]>;
    get(id: string): Promise<AppInfoLocalization>;
    create(params: {
        appInfoId: string;
        attributes: AppInfoLocalizationAttributes;
    }): Promise<AppInfoLocalization>;
    update(id: string, attributes: Partial<AppInfoLocalizationAttributes>): Promise<AppInfoLocalization>;
    delete(id: string): Promise<void>;
}

interface AppStoreReviewDetailAttributes {
    contactFirstName?: string | null;
    contactLastName?: string | null;
    contactPhone?: string | null;
    contactEmail?: string | null;
    demoAccountName?: string | null;
    demoAccountPassword?: string | null;
    demoAccountRequired?: boolean | null;
    notes?: string | null;
}
type AppStoreReviewDetail = JsonApiResource<"appStoreReviewDetails", AppStoreReviewDetailAttributes>;
declare class AppStoreReviewDetailsResource {
    private http;
    constructor(http: RequestClient);
    getForAppStoreVersion(appStoreVersionId: string): Promise<AppStoreReviewDetail>;
    get(id: string): Promise<AppStoreReviewDetail>;
    create(params: {
        appStoreVersionId: string;
        attributes: AppStoreReviewDetailAttributes;
    }): Promise<AppStoreReviewDetail>;
    update(id: string, attributes: Partial<AppStoreReviewDetailAttributes>): Promise<AppStoreReviewDetail>;
}

interface BetaTesterAttributes {
    firstName?: string | null;
    lastName?: string | null;
    email: string;
    inviteType?: "EMAIL" | "PUBLIC_LINK" | null;
    state?: string | null;
}
type BetaTester = JsonApiResource<"betaTesters", BetaTesterAttributes>;
declare class BetaTestersResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            email?: string;
            firstName?: string;
            lastName?: string;
            inviteType?: string;
            apps?: string | string[];
            betaGroups?: string | string[];
        };
        include?: string;
        limit?: number;
        sort?: string;
    }): Promise<BetaTester[]>;
    get(id: string): Promise<BetaTester>;
    create(params: {
        email: string;
        firstName?: string;
        lastName?: string;
        betaGroupIds?: string[];
        appIds?: string[];
    }): Promise<BetaTester>;
    delete(id: string): Promise<void>;
    findByEmail(email: string): Promise<BetaTester | null>;
}

interface BetaAppReviewSubmissionAttributes {
    betaReviewState?: string | null;
    submittedDate?: string | null;
}
type BetaAppReviewSubmission = JsonApiResource<"betaAppReviewSubmissions", BetaAppReviewSubmissionAttributes>;
declare class BetaAppReviewSubmissionsResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            build?: string | string[];
            betaReviewState?: string;
        };
        limit?: number;
    }): Promise<BetaAppReviewSubmission[]>;
    get(id: string): Promise<BetaAppReviewSubmission>;
    create(buildId: string): Promise<BetaAppReviewSubmission>;
}

interface BetaAppReviewDetailAttributes {
    contactFirstName?: string | null;
    contactLastName?: string | null;
    contactPhone?: string | null;
    contactEmail?: string | null;
    demoAccountName?: string | null;
    demoAccountPassword?: string | null;
    demoAccountRequired?: boolean | null;
    notes?: string | null;
}
type BetaAppReviewDetail = JsonApiResource<"betaAppReviewDetails", BetaAppReviewDetailAttributes>;
declare class BetaAppReviewDetailsResource {
    private http;
    constructor(http: RequestClient);
    getForApp(appId: string): Promise<BetaAppReviewDetail>;
    get(id: string): Promise<BetaAppReviewDetail>;
    update(id: string, attributes: Partial<BetaAppReviewDetailAttributes>): Promise<BetaAppReviewDetail>;
}

interface BetaTesterInvitationAttributes {
    [key: string]: unknown;
}
type BetaTesterInvitation = JsonApiResource<"betaTesterInvitations", BetaTesterInvitationAttributes>;
declare class BetaInvitationsResource {
    private http;
    constructor(http: RequestClient);
    /** Send a TestFlight invitation email for an existing tester + app. */
    send(params: {
        appId: string;
        betaTesterId: string;
    }): Promise<BetaTesterInvitation>;
}

interface BetaLicenseAgreementAttributes {
    agreementText?: string | null;
}
type BetaLicenseAgreement = JsonApiResource<"betaLicenseAgreements", BetaLicenseAgreementAttributes>;
declare class BetaLicensesResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        limit?: number;
    }): Promise<BetaLicenseAgreement[]>;
    get(id: string): Promise<BetaLicenseAgreement>;
    getForApp(appId: string): Promise<BetaLicenseAgreement>;
    update(id: string, attributes: Partial<BetaLicenseAgreementAttributes>): Promise<BetaLicenseAgreement>;
}

interface AppPreviewAttributes {
    fileSize?: number | null;
    fileName?: string | null;
    sourceFileChecksum?: string | null;
    previewFrameTimeCode?: string | null;
    mimeType?: string | null;
    videoUrl?: string | null;
    previewImage?: {
        templateUrl?: string;
        width?: number;
        height?: number;
    } | null;
    uploadOperations?: unknown[] | null;
    assetDeliveryState?: {
        state?: string;
    } | null;
    uploaded?: boolean | null;
}
type AppPreview = JsonApiResource<"appPreviews", AppPreviewAttributes>;
declare class AppPreviewsResource {
    private http;
    constructor(http: RequestClient);
    get(id: string): Promise<AppPreview>;
    create(params: {
        appPreviewSetId: string;
        fileSize: number;
        fileName: string;
        previewFrameTimeCode?: string;
        mimeType?: string;
    }): Promise<AppPreview>;
    update(id: string, attributes: {
        uploaded?: boolean;
        sourceFileChecksum?: string;
        previewFrameTimeCode?: string;
    }): Promise<AppPreview>;
    delete(id: string): Promise<void>;
}

interface AppPreviewSetAttributes {
    previewType?: string | null;
}
type AppPreviewSet = JsonApiResource<"appPreviewSets", AppPreviewSetAttributes>;
declare class AppPreviewSetsResource {
    private http;
    constructor(http: RequestClient);
    listForLocalization(localizationId: string, params?: {
        limit?: number;
        include?: string;
    }): Promise<AppPreviewSet[]>;
    get(id: string, params?: {
        include?: string;
    }): Promise<AppPreviewSet>;
    create(params: {
        appStoreVersionLocalizationId: string;
        previewType: string;
    }): Promise<AppPreviewSet>;
    delete(id: string): Promise<void>;
}

interface AppPriceAttributes {
    startDate?: string | null;
}
type AppPrice = JsonApiResource<"appPrices", AppPriceAttributes>;
declare class AppPricesResource {
    private http;
    constructor(http: RequestClient);
    listForApp(appId: string, params?: {
        include?: string;
        limit?: number;
    }): Promise<AppPrice[]>;
    get(id: string, params?: {
        include?: string;
    }): Promise<AppPrice>;
}

interface TerritoryAttributes {
    currency?: string | null;
}
type Territory = JsonApiResource<"territories", TerritoryAttributes>;
declare class TerritoriesResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        limit?: number;
    }): Promise<Territory[]>;
    get(id: string): Promise<Territory>;
}

interface AgeRatingDeclarationAttributes {
    alcoholTobaccoOrDrugUseOrReferences?: string | null;
    contests?: string | null;
    gamblingSimulated?: string | null;
    medicalOrTreatmentInformation?: string | null;
    profanityOrCrudeHumor?: string | null;
    sexualContentGraphicAndNudity?: string | null;
    sexualContentOrNudity?: string | null;
    horrorOrFearThemes?: string | null;
    matureOrSuggestiveThemes?: string | null;
    unrestrictedWebAccess?: boolean | null;
    gamblingAndContests?: boolean | null;
    gambling?: string | null;
    violenceCartoonOrFantasy?: string | null;
    violenceRealistic?: string | null;
    violenceRealisticProlongedGraphicOrSadistic?: string | null;
    kidsAgeBand?: string | null;
    seventeenPlus?: boolean | null;
}
type AgeRatingDeclaration = JsonApiResource<"ageRatingDeclarations", AgeRatingDeclarationAttributes>;
declare class AgeRatingDeclarationsResource {
    private http;
    constructor(http: RequestClient);
    get(id: string): Promise<AgeRatingDeclaration>;
    update(id: string, attributes: Partial<AgeRatingDeclarationAttributes>): Promise<AgeRatingDeclaration>;
}

interface AppCategoryAttributes {
    platforms?: string[] | null;
}
type AppCategory = JsonApiResource<"appCategories", AppCategoryAttributes>;
declare class AppCategoriesResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            platforms?: string;
        };
        include?: string;
        limit?: number;
    }): Promise<AppCategory[]>;
    get(id: string, params?: {
        include?: string;
    }): Promise<AppCategory>;
}

interface AppEncryptionDeclarationAttributes {
    appEncryptionDeclarationState?: string | null;
    createdDate?: string | null;
    codeValue?: string | null;
    usesEncryption?: boolean | null;
    exempt?: boolean | null;
    containsProprietaryCryptography?: boolean | null;
    containsThirdPartyCryptography?: boolean | null;
    availableOnFrenchStore?: boolean | null;
    platform?: string | null;
    uploadedDate?: string | null;
    documentUrl?: string | null;
    documentName?: string | null;
    documentType?: string | null;
}
type AppEncryptionDeclaration = JsonApiResource<"appEncryptionDeclarations", AppEncryptionDeclarationAttributes>;
declare class AppEncryptionDeclarationsResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            app?: string;
            platform?: string;
        };
        limit?: number;
    }): Promise<AppEncryptionDeclaration[]>;
    get(id: string): Promise<AppEncryptionDeclaration>;
    assignToBuild(params: {
        declarationId: string;
        buildIds: string[];
    }): Promise<void>;
}

interface IdfaDeclarationAttributes {
    honorsLimitedAdTracking?: boolean | null;
    servesAds?: boolean | null;
    attributesActionWithPreviousAd?: boolean | null;
    attributesAppInstallationToPreviousAd?: boolean | null;
}
type IdfaDeclaration = JsonApiResource<"idfaDeclarations", IdfaDeclarationAttributes>;
declare class IdfaDeclarationsResource {
    private http;
    constructor(http: RequestClient);
    getForAppStoreVersion(appStoreVersionId: string): Promise<IdfaDeclaration>;
    get(id: string): Promise<IdfaDeclaration>;
    create(params: {
        appStoreVersionId: string;
        attributes: IdfaDeclarationAttributes;
    }): Promise<IdfaDeclaration>;
    update(id: string, attributes: Partial<IdfaDeclarationAttributes>): Promise<IdfaDeclaration>;
    delete(id: string): Promise<void>;
}

interface PreReleaseVersionAttributes {
    version?: string | null;
    platform?: string | null;
}
type PreReleaseVersion = JsonApiResource<"preReleaseVersions", PreReleaseVersionAttributes>;
declare class PreReleaseVersionsResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            app?: string;
            version?: string;
            platform?: string;
            "builds.expired"?: string;
            "builds.processingState"?: string;
            "builds.version"?: string;
        };
        include?: string;
        limit?: number;
        sort?: string;
    }): Promise<PreReleaseVersion[]>;
    get(id: string, params?: {
        include?: string;
    }): Promise<PreReleaseVersion>;
    findByVersion(params: {
        appId: string;
        version: string;
        platform?: string;
    }): Promise<PreReleaseVersion | null>;
}

interface ReviewSubmissionItemAttributes {
    state?: string | null;
    removed?: boolean | null;
    ready?: boolean | null;
}
type ReviewSubmissionItem = JsonApiResource<"reviewSubmissionItems", ReviewSubmissionItemAttributes>;
declare class ReviewSubmissionItemsResource {
    private http;
    constructor(http: RequestClient);
    listForSubmission(reviewSubmissionId: string, params?: {
        include?: string;
        limit?: number;
    }): Promise<ReviewSubmissionItem[]>;
    get(id: string): Promise<ReviewSubmissionItem>;
    create(params: {
        reviewSubmissionId: string;
        appStoreVersionId?: string;
        appCustomProductPageVersionId?: string;
        appStoreVersionExperimentId?: string;
    }): Promise<ReviewSubmissionItem>;
    update(id: string, attributes: {
        removed?: boolean;
    }): Promise<ReviewSubmissionItem>;
    delete(id: string): Promise<void>;
}

interface UserAttributes {
    username?: string | null;
    firstName?: string | null;
    lastName?: string | null;
    roles?: string[] | null;
    allAppsVisible?: boolean | null;
    provisioningAllowed?: boolean | null;
}
type User = JsonApiResource<"users", UserAttributes>;
declare class UsersResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            username?: string;
            roles?: string | string[];
        };
        include?: string;
        limit?: number;
        sort?: string;
    }): Promise<User[]>;
    get(id: string): Promise<User>;
    update(id: string, attributes: Partial<UserAttributes>, visibleAppIds?: string[]): Promise<User>;
    delete(id: string): Promise<void>;
}

interface UserInvitationAttributes {
    email: string;
    firstName?: string | null;
    lastName?: string | null;
    expirationDate?: string | null;
    roles?: string[] | null;
    allAppsVisible?: boolean | null;
    provisioningAllowed?: boolean | null;
}
type UserInvitation = JsonApiResource<"userInvitations", UserInvitationAttributes>;
declare class UserInvitationsResource {
    private http;
    constructor(http: RequestClient);
    list(params?: {
        filter?: {
            email?: string;
            roles?: string | string[];
        };
        include?: string;
        limit?: number;
        sort?: string;
    }): Promise<UserInvitation[]>;
    get(id: string): Promise<UserInvitation>;
    create(params: {
        attributes: UserInvitationAttributes;
        visibleAppIds?: string[];
    }): Promise<UserInvitation>;
    delete(id: string): Promise<void>;
    findByEmail(email: string): Promise<UserInvitation | null>;
}

interface InAppPurchaseAttributes {
    name?: string | null;
    productId?: string | null;
    inAppPurchaseType?: string | null;
    state?: string | null;
    reviewNote?: string | null;
    familySharable?: boolean | null;
}
type InAppPurchase = JsonApiResource<"inAppPurchases" | "inAppPurchasesV2", InAppPurchaseAttributes>;
declare class InAppPurchasesResource {
    private http;
    constructor(http: RequestClient);
    listForApp(appId: string, params?: {
        filter?: {
            state?: string;
            inAppPurchaseType?: string;
        };
        include?: string;
        limit?: number;
        sort?: string;
    }): Promise<InAppPurchase[]>;
    get(id: string, params?: {
        include?: string;
    }): Promise<InAppPurchase>;
}

interface GameCenterDetailAttributes {
    arcadeEnabled?: boolean | null;
    challengeEnabled?: boolean | null;
}
type GameCenterDetail = JsonApiResource<"gameCenterDetails", GameCenterDetailAttributes>;
declare class GameCenterDetailResource {
    private http;
    constructor(http: RequestClient);
    getForApp(appId: string): Promise<GameCenterDetail>;
    get(id: string): Promise<GameCenterDetail>;
    update(id: string, attributes: Partial<GameCenterDetailAttributes>): Promise<GameCenterDetail>;
}

/**
 * TestFlight / Xcode build metrics. Exposes perf & crash stats per build.
 * Wraps `/v1/builds/{id}/perfPowerMetrics` and
 * `/v1/builds/{id}/diagnosticSignatures`.
 */
interface PerfPowerMetricAttributes {
    metricCategory?: string | null;
    platform?: string | null;
    datasets?: unknown[] | null;
}
type PerfPowerMetric = JsonApiResource<"perfPowerMetrics", PerfPowerMetricAttributes>;
interface DiagnosticSignatureAttributes {
    signature?: string | null;
    weight?: number | null;
    diagnosticType?: string | null;
}
type DiagnosticSignature = JsonApiResource<"diagnosticSignatures", DiagnosticSignatureAttributes>;
declare class XcodeMetricsResource {
    private http;
    constructor(http: RequestClient);
    getPerfPowerMetrics(buildId: string): Promise<PerfPowerMetric[]>;
    getDiagnosticSignatures(buildId: string): Promise<DiagnosticSignature[]>;
    getPerfPowerMetric(id: string): Promise<PerfPowerMetric>;
    getDiagnosticSignature(id: string): Promise<DiagnosticSignature>;
}

/**
 * Apple ID Session Authentication
 * 1:1 port of Fastlane Spaceship client.rb + two_step_or_factor_client.rb
 *
 * Two flows:
 *
 *   loginWithAppleId({ email, password, onPrompt })
 *     - blocking, CLI-style. onPrompt is awaited to collect 2FA codes.
 *
 *   beginLogin({ email, password }) → { kind: "logged_in" | "needs_2fa", ... }
 *     submitTwoFactorCode({ pending, code, source, ... }) → AppleSession
 *     requestSmsCode({ pending, phoneId, mode })
 *     - HTTP-resumable. Used by the App Release wizard, where the 2FA
 *       challenge is rendered in a browser modal and the code arrives in
 *       a separate request.
 */
interface AppleSessionConfig {
    email: string;
    password: string;
    onLog?: (msg: string) => void;
    onPrompt?: (msg: string) => Promise<string>;
}
interface ContractMessage {
    id: string;
    group: string;
    subject: string;
    message: string;
}
interface AppleSession {
    cookies: Record<string, string>;
    sessionId: string;
    scnt: string;
    serviceKey: string;
    userEmail: string;
    teamId?: string;
    pendingAgreements: ContractMessage[];
}
/**
 * State held between beginLogin() and submitTwoFactorCode() — captures
 * everything needed to resume an in-progress 2FA flow across HTTP requests.
 * Stored server-side keyed by an opaque session id; never sent to the
 * browser (the browser only sees the opaque id).
 */
interface PendingLogin {
    cookies: Record<string, string>;
    sessionId: string;
    scnt: string;
    serviceKey: string;
    userEmail: string;
}
/**
 * Description of the 2FA challenge presented to the user.
 *
 * Modern 2FA accounts (the default for everyone) have `kind: "device"` —
 * Apple pushes the 6-digit code to all the user's trusted Apple devices
 * (iPhone, Mac, etc.) and the user types it into our wizard. The legacy
 * `trustedDevices` field is empty in this case; that field only ever
 * populates for old "two-step verification" accounts which are
 * essentially extinct.
 *
 * `kind: "phone_only"` is reserved for accounts that have no real Apple
 * devices (Apple's `noTrustedDevices === true` flag) — those accounts
 * must use SMS to a trusted phone number.
 *
 * Either way, the user can opt to receive the code via SMS instead by
 * picking from `trustedPhoneNumbers` and calling requestSmsCode().
 */
interface TwoFactorChallenge {
    kind: "device" | "phone_only";
    codeLength: number;
    trustedPhoneNumbers: {
        id: number;
        numberWithDialCode: string;
        pushMode?: string;
    }[];
}
type BeginLoginResult = {
    kind: "logged_in";
    session: AppleSession;
} | {
    kind: "needs_2fa";
    pending: PendingLogin;
    challenge: TwoFactorChallenge;
};
/** Thrown when an Apple Developer Program agreement needs to be accepted */
declare class ProgramLicenseAgreementError extends Error {
    agreements: ContractMessage[];
    constructor(message: string, agreements: ContractMessage[]);
}
/**
 * Check a portal API response for agreement/license errors.
 * Throws ProgramLicenseAgreementError if detected.
 * Call this after any portal API call. Mirrors Spaceship::Client#handle_itc_response.
 */
declare function checkPortalResponse(body: any, session?: AppleSession): void;
/**
 * Step 1 of HTTP-resumable login: do the SIRP exchange and detect whether
 * 2FA is required. Returns either a fully-established session (no 2FA) or
 * a pending state + a description of the 2FA challenge.
 */
declare function beginLogin(config: {
    email: string;
    password: string;
    onLog?: (msg: string) => void;
}): Promise<BeginLoginResult>;
/**
 * Ask Apple to send an SMS / voice code to the chosen trusted phone.
 * Used by the wizard's "Send code via text instead" affordance.
 */
declare function requestSmsCode(input: {
    pending: PendingLogin;
    phoneId: number;
    mode?: "sms" | "voice";
}): Promise<void>;
/**
 * Step 2 of HTTP-resumable login: submit the 2FA code the user typed.
 * Returns a fully-established AppleSession on success.
 *
 *   source = "device" → 4-digit code from a trusted Apple device
 *   source = "phone"  → 6-digit code from SMS / push to trusted phone
 */
declare function submitTwoFactorCode(input: {
    pending: PendingLogin;
    code: string;
    source: "device" | "phone";
    phoneId?: number;
    mode?: "sms" | "voice";
    onLog?: (msg: string) => void;
}): Promise<AppleSession>;
/**
 * Backward-compatible CLI-style login. Internally uses beginLogin +
 * submitTwoFactorCode but routes 2FA through the synchronous onPrompt
 * callback so existing scripts (test-login.ts, test-full-workflow.ts)
 * keep working.
 */
declare function loginWithAppleId(config: AppleSessionConfig): Promise<AppleSession>;

/**
 * Apple Developer Portal Client
 * 1:1 port of Fastlane Spaceship PortalClient
 *
 * Uses session cookies (from loginWithAppleId) to talk to
 * developer.apple.com/services-account/QH65B2/
 *
 * This is the web portal API — separate from the ASC REST API (JWT).
 * Fastlane uses this for: certs, profiles, devices, bundle IDs, app groups, etc.
 */

declare class PortalClient {
    private session;
    private teamId;
    private csrf;
    private csrfTs;
    private cookieStr;
    constructor(session: AppleSession, teamId: string);
    /** Initialize CSRF tokens — must be called before mutations */
    init(): Promise<void>;
    /**
     * JSON POST — different content type than the standard form-encoded
     * `post()`. Used by the App Store Connect API key endpoints
     * (`account/auth/key/v2/create`), which Spaceship discovered take a
     * JSON body even though every other portal mutation is form-encoded.
     *
     * Like the form-encoded `post()`, this also runs the response through
     * `checkPortalResponse` — Apple returns HTTP 200 even for errors and
     * encodes the error in `resultCode`/`userString` fields, so a raw
     * status check would silently miss real failures.
     */
    private postJson;
    /**
     * GET helper for the portal endpoints that take query parameters
     * (currently just `account/auth/key/download`). Returns the raw text
     * since download endpoints can return PEMs or JSON depending on Apple's
     * mood — caller decides how to parse.
     */
    private getRaw;
    /**
     * Create an App Store Connect API key via the developer portal's
     * `account/auth/key/v2/create` endpoint. Reverse-engineered from the
     * _current_ @expo/apple-utils npm package (v2.1.21), which is what
     * EAS CLI uses to manage Apple credentials in production.
     *
     * This differs from older published reverse-engineering guides:
     *   • URL uses the `/v2/create` suffix (Apple kept it)
     *   • Field is `serviceConfigurations`, shape is an object keyed by
     *     service id (NOT `serviceConfigurationsRequests: [...]` array)
     *   • Body REQUIRES `scope: "team"`
     *   • Needs a scope-specific CSRF warmup via the `keys` endpoint
     *     before the create call (EAS's `ensureCSRFAsync("keys", …)`)
     *
     * For an App Store Connect API key (PUBLIC_API, used by altool for
     * TestFlight uploads), `serviceConfigurations` is an empty object `{}`.
     * For an APNs auth key, it's `{ "U27F4V844T": [] }`. For MusicKit:
     * `{ "6A7HVUVQ3M": [musicId] }`, etc.
     *
     * Apple's name validator rejects parentheses, brackets, and most
     * punctuation — sanitize to alphanumeric + space + dash + underscore
     * + period and collapse whitespace.
     */
    createApiKey(rawName: string, serviceConfigurations?: Record<string, unknown[]>): Promise<{
        keyId: string;
        raw: any;
    }>;
    /**
     * Fetch a single API key by id via `account/auth/key/get`. Reverse-
     * engineered from Spaceship's `get_key`. Returns the raw key record so
     * the caller can extract whatever fields it needs (e.g. issuerId).
     *
     * Form-encoded POST — same shape as every other PortalClient mutation
     * except the JSON `create` endpoint.
     */
    getApiKey(keyId: string): Promise<any>;
    /**
     * Revoke an existing key. Form-encoded POST per Spaceship's
     * `revoke_key!`. Used for cleaning up orphan keys created during
     * failed wizard runs.
     */
    revokeApiKey(keyId: string): Promise<void>;
    /** Apple's hardcoded service id for APNs auth keys (from Spaceship). */
    static readonly APNS_SERVICE_ID = "U27F4V844T";
    /**
     * Create an APNs Authentication Key (.p8) via the developer portal.
     *
     * Apple requires BOTH `serviceConfigurations` (the map) AND
     * `serviceConfigurationsRequests` (the array of full config objects)
     * in the v2/create body. Just sending the map alone results in
     * "No value was provided for the parameter 'serviceConfigurations'".
     *
     * The exact body comes from @expo/apple-utils v2.1.21 — both fields
     * are produced by separate functions (`d` for the map, `h` for the
     * array) and merged into the create payload.
     *
     * Apple also rejects duplicate key names ("Another key with same
     * name exists") — we dedupe by listing existing keys first and
     * appending " (N)" until we find a free slot, mirroring the
     * provisioning profile dedup.
     */
    createApnsAuthKey(rawName: string): Promise<{
        keyId: string;
        pem: string;
        raw: any;
    }>;
    /**
     * Find existing APNs auth keys in the team. Used by the wizard to
     * detect "you already have one" cases and offer to reuse rather than
     * proliferate keys.
     */
    listApnsAuthKeys(): Promise<{
        keyId: string;
        keyName: string;
        canDownload: boolean;
    }[]>;
    /**
     * Download an existing App Store Connect API key as PEM. Spaceship's
     * `download_key` endpoint — GET with teamId + keyId in query string.
     * Returns the raw .p8 PEM text. Apple shows the .p8 exactly once
     * (after creation), so call this immediately after createApiKey.
     */
    downloadApiKey(keyId: string): Promise<string>;
    /**
     * List existing API keys via the portal. Used to discover the team's
     * issuer id — every key in the team shares the same issuer id, and
     * altool needs it alongside the key id and .p8 file.
     *
     * Form-encoded POST (NOT JSON), with pagination params, per Spaceship's
     * `list_keys` method. JSON returned 415 from this endpoint.
     */
    listApiKeys(): Promise<{
        keys: any[];
        issuerId?: string;
    }>;
    private post;
    listTeams(): Promise<any[]>;
    listAppIds(): Promise<any[]>;
    createAppId(params: {
        identifier: string;
        name: string;
        enablePush?: boolean;
        enableIAP?: boolean;
    }): Promise<any>;
    deleteAppId(appIdId: string): Promise<void>;
    /**
     * Toggle a capability (a.k.a. "service") on a bundle ID. Mirrors
     * Spaceship::Portal's `update_service` — the legacy portal endpoint
     * still works and is the only session-cookie-authenticated way to flip
     * capabilities like Push Notifications and Sign in with Apple from
     * outside the Apple Developer web UI.
     *
     * Common service codes (from Spaceship portal/portal_client.rb):
     *   push          → push notifications
     *   APG3427HIY    → Sign in with Apple
     *   IAD53UNK2F    → in-app purchase
     *   homeKit       → HomeKit
     *   healthKit     → HealthKit
     *
     * @param featureType  Apple's internal capability key (string code or short name)
     * @param enabled      true → turn on, false → turn off
     */
    setBundleCapability(params: {
        appIdId: string;
        featureType: string;
        enabled: boolean;
    }): Promise<void>;
    listCertificates(types?: string[]): Promise<any[]>;
    listPushCertificates(): Promise<any[]>;
    createCertificate(params: {
        type: string;
        csrContent: string;
        appIdId?: string;
    }): Promise<any>;
    downloadCertificate(certId: string, type: string): Promise<Buffer>;
    revokeCertificate(certId: string, type: string): Promise<void>;
    listDevices(): Promise<any[]>;
    registerDevice(params: {
        name: string;
        udid: string;
        deviceClass?: string;
    }): Promise<any>;
    listProfiles(): Promise<any[]>;
    createProfile(params: {
        appIdId: string;
        name: string;
        distributionType: string;
        certificateIds: string[];
        deviceIds?: string[];
    }): Promise<any>;
    deleteProfile(profileId: string): Promise<void>;
    downloadProfile(profileId: string): Promise<Buffer>;
    /**
     * Apple certificate type codes — copied 1:1 from Fastlane's
     * spaceship/portal/certificate.rb IOS_CERTIFICATE_TYPE_IDS / MAC_CERTIFICATE_TYPE_IDS
     */
    static CERT_TYPES: {
        readonly IOS_DEVELOPMENT: "5QPB9NHCEI";
        readonly IOS_DISTRIBUTION: "R58UK2EWSO";
        readonly IOS_IN_HOUSE: "9RQEK7MSXA";
        readonly IOS_DEVELOPMENT_PUSH: "JKG5JZ54H7";
        readonly IOS_PRODUCTION_PUSH: "UPV3DW712I";
        readonly APPLE_PUSH_PRODUCTION: "UPV3DW712I";
        readonly APPLE_PUSH_SANDBOX: "JKG5JZ54H7";
        readonly PASSBOOK: "Y3B2F3TYSI";
        readonly WEBSITE_PUSH: "3T2ZP62QW8";
        readonly VOIP_PUSH: "E5D663CMZW";
        readonly APPLE_PAY: "4APLUP237T";
        readonly APPLE_PAY_MERCHANT_IDENTITY: "MD8Q2VRT6A";
        readonly APPLE_DEVELOPMENT: "83Q87W3TGH";
        readonly APPLE_DISTRIBUTION: "WXV89964HE";
        readonly MAC_DEVELOPMENT: "749Y1QAGU7";
        readonly MAC_APP_DISTRIBUTION: "HXZEUKP0FP";
        readonly MAC_INSTALLER_DISTRIBUTION: "2PQI8IDXNH";
        readonly MAC_PRODUCTION_PUSH: "CDZ7EMXIZ1";
        readonly MAC_DEVELOPMENT_PUSH: "HQ4KP3I34R";
        readonly DEVELOPER_ID_APPLICATION: "DIVN2GW3XT";
        readonly DEVELOPER_ID_INSTALLER: "OYVN2GW35E";
    };
    /**
     * Legacy iOS certificate type codes that can still appear in the portal
     * responses. Port of Fastlane's Spaceship::Portal::Certificate
     * OLDER_IOS_CERTIFICATE_TYPES list (certificate.rb lines 180-189).
     */
    static OLDER_IOS_CERTIFICATE_TYPES: readonly string[];
}

/**
 * App Store Connect "iris" admin API client.
 *
 * The iris API lives at `https://appstoreconnect.apple.com/iris/v1/*` and
 * is what App Store Connect's own web UI uses for everything that doesn't
 * fit the public REST API (which requires JWT). Authentication is via the
 * Olympus session cookies we already obtain after SIRP + 2FA login.
 *
 * Notable iris endpoints (reverse-engineered from the App Store Connect
 * web app — Apple does not publish this API, so the shapes below are best
 * effort and may need iteration):
 *
 *   POST /iris/v1/apiKeys
 *     Body: { data: { type: "apiKeys", attributes: {
 *       nickname, allAppsVisible, roles: ["DEVELOPER" | "APP_MANAGER" | ...]
 *     }}}
 *     Response: { data: { id, attributes: { nickname, kid, privateKey?, ... }}}
 *
 *     `kid` is the key ID used in JWT auth (e.g. "2X9R4HXF34"). The
 *     `privateKey` field, when present, contains the PEM-encoded .p8
 *     content. Apple shows this exactly ONCE at creation time — if we
 *     don't capture it, the key is bricked and must be revoked.
 *
 *   GET  /iris/v1/apiKeys
 *     List existing keys. Used to find the issuer id.
 *
 * Roles the wizard uses: "APP_MANAGER" is the minimum needed for
 * TestFlight uploads via altool. Higher roles work too.
 *
 * Failure modes:
 *   • 403 → user lacks Account Holder / Admin role → fall back to manual
 *   • 4xx with `error.detail` → surface the message to the user
 *   • 200 but no `privateKey` in response → endpoint shape changed,
 *     surface so we can iterate
 */

type ApiKeyRole = "ADMIN" | "FINANCE" | "ACCESS_TO_REPORTS" | "APP_MANAGER" | "DEVELOPER" | "MARKETING" | "SALES" | "CUSTOMER_SUPPORT";
interface IrisApiKey {
    id: string;
    /** Key ID used for JWT auth (the short alphanumeric string) */
    kid: string;
    nickname: string;
    /** PEM-encoded .p8 private key — only present in create response, ONCE */
    privateKey?: string;
    /** Issuer id (UUID) — needed by altool/iTMSTransporter alongside the key id */
    issuerId?: string;
    roles: ApiKeyRole[];
    allAppsVisible: boolean;
}
declare class IrisClient {
    private session;
    private cookieStr;
    constructor(session: AppleSession);
    private buildHeaders;
    /**
     * Issue a request and absorb any new cookies (Apple rotates session
     * cookies on a lot of iris calls).
     */
    private request;
    /**
     * List existing API keys. Used both as a sanity check (the user has
     * permission) and to discover the team's issuer id (which is the same
     * for every key in the team and is needed by altool).
     *
     * Important: Apple's iris endpoint rejects most query parameters with
     * `PARAMETER_ERROR.INVALID`. Call with no params and let the API return
     * its default page.
     */
    listApiKeys(): Promise<{
        keys: IrisApiKey[];
        issuerId?: string;
    }>;
    /**
     * Create a new API key. Apple returns the .p8 PEM exactly once in the
     * create response — capture it immediately or the key is dead weight.
     *
     * `keyType` is required by Apple's iris API:
     *   • PUBLIC_API     — the standard team-wide API key (what TestFlight uploads need)
     *   • MARKETING_API  — for App Analytics access only
     */
    createApiKey(input: {
        nickname: string;
        roles?: ApiKeyRole[];
        allAppsVisible?: boolean;
        keyType?: "PUBLIC_API" | "MARKETING_API";
    }): Promise<IrisApiKey>;
    /**
     * Fetch the .p8 PEM AND the team's issuer id for a previously-created
     * ASC API key. Both come back in a single request via:
     *
     *   GET /iris/v1/apiKeys/{id}?fields[apiKeys]=privateKey&include=provider
     *
     * Sparse fieldset requesting ONLY `privateKey` is the magic that makes
     * Apple actually include the (base64-encoded) PEM in the response —
     * the default view returns `privateKey: null`. The `include=provider`
     * pulls the team's contentProvider record into `included[]`, and its
     * `id` field IS the issuer id altool needs (a UUID like
     * `cfadaf94-44ca-4c2c-8fa6-ecc28d3c7d0d`).
     *
     * Reverse-engineered from @expo/apple-utils v2.1.21 (the package that
     * powers EAS CLI), specifically the `ApiKey.downloadAsync` method
     * combined with `ApiKey.infoAsync` reading `provider?.id`.
     *
     * Returns `{ pem, issuerId }`, or `null` if Apple won't return the
     * private key (typically because the key was already downloaded once).
     */
    fetchApiKeyPrivateKey(keyId: string): Promise<{
        pem: string;
        issuerId?: string;
    } | null>;
    /**
     * @deprecated Kept as a fallback probe for debugging. The real path
     * is the sparse fieldset above — everything in this brute-force list
     * returned 404 during testing. Left here so we can re-verify if Apple
     * changes anything.
     */
    fetchApiKeyPrivateKeyBruteForce(keyId: string): Promise<string | null>;
    /** Internal: like request() but lets us override headers. */
    private requestWithHeaders;
    /** Internal: fetch an absolute URL with the session cookies. */
    private requestAbsolute;
    deleteApiKey(keyId: string): Promise<void>;
}
/** Thrown when the user doesn't have permission to use the iris admin API. */
declare class IrisAuthError extends Error {
    constructor(message: string);
}

declare class AppStoreConnectClient {
    readonly http: RequestClient;
    readonly certificates: CertificatesResource;
    readonly profiles: ProfilesResource;
    readonly bundleIds: BundleIdsResource;
    readonly devices: DevicesResource;
    readonly apps: AppsResource;
    readonly builds: BuildsResource;
    readonly betaGroups: BetaGroupsResource;
    readonly capabilities: CapabilitiesResource;
    readonly appStoreVersions: AppStoreVersionsResource;
    readonly appScreenshots: AppScreenshotsResource;
    readonly reviewSubmissions: ReviewSubmissionsResource;
    readonly appInfos: AppInfosResource;
    readonly appInfoLocalizations: AppInfoLocalizationsResource;
    readonly appStoreReviewDetails: AppStoreReviewDetailsResource;
    readonly betaTesters: BetaTestersResource;
    readonly betaAppReviewSubmissions: BetaAppReviewSubmissionsResource;
    readonly betaAppReviewDetails: BetaAppReviewDetailsResource;
    readonly betaInvitations: BetaInvitationsResource;
    readonly betaLicenses: BetaLicensesResource;
    readonly appPreviews: AppPreviewsResource;
    readonly appPreviewSets: AppPreviewSetsResource;
    readonly appPrices: AppPricesResource;
    readonly territories: TerritoriesResource;
    readonly ageRatingDeclarations: AgeRatingDeclarationsResource;
    readonly appCategories: AppCategoriesResource;
    readonly appEncryptionDeclarations: AppEncryptionDeclarationsResource;
    readonly idfaDeclarations: IdfaDeclarationsResource;
    readonly preReleaseVersions: PreReleaseVersionsResource;
    readonly reviewSubmissionItems: ReviewSubmissionItemsResource;
    readonly users: UsersResource;
    readonly userInvitations: UserInvitationsResource;
    readonly inAppPurchases: InAppPurchasesResource;
    readonly gameCenterDetail: GameCenterDetailResource;
    readonly xcodeMetrics: XcodeMetricsResource;
    constructor(config: AppStoreConnectConfig);
    request<T>(path: string, options?: RequestOptions): Promise<T>;
}

export { type ContractMessage as $, type AppleSession as A, type BundleId as B, type Certificate as C, type Device as D, CapabilitiesResource as E, AppStoreVersionsResource as F, type AppStoreVersion as G, type AppStoreVersionLocalization as H, AppScreenshotsResource as I, type JsonApiResource as J, type AppScreenshot as K, type ListParams as L, type AppScreenshotSet as M, ReviewSubmissionsResource as N, type ReviewSubmission as O, type Profile as P, type AppStoreVersionSubmission as Q, RequestClient as R, loginWithAppleId as S, TokenManager as T, type UploadOperation as U, beginLogin as V, submitTwoFactorCode as W, requestSmsCode as X, checkPortalResponse as Y, ProgramLicenseAgreementError as Z, type AppleSessionConfig as _, AppStoreConnectClient as a, type PendingLogin as a0, type TwoFactorChallenge as a1, type BeginLoginResult as a2, PortalClient as a3, IrisClient as a4, IrisAuthError as a5, type IrisApiKey as a6, type ApiKeyRole as a7, type JsonApiRelationship as a8, type JsonApiErrorResponse as a9, AppStoreConnectError as b, RateLimitError as c, type AppStoreConnectConfig as d, type TokenConfig as e, type RequestOptions as f, type JsonApiResponse as g, type JsonApiListResponse as h, type JsonApiError as i, type App as j, type Build as k, type BetaGroup as l, type BetaBuildLocalization as m, type BuildBetaDetail as n, type PreReleaseVersion$1 as o, type BundleIdCapability as p, type CapabilitySettingInput as q, type CapabilitySetting as r, type CapabilityOption as s, CertificatesResource as t, ProfilesResource as u, BundleIdsResource as v, DevicesResource as w, AppsResource as x, BuildsResource as y, BetaGroupsResource as z };