@sitepong/fastnode 0.2.1 → 0.3.0

package/dist/{index-CdfgEZwh.d.cts → index-DrmS802s.d.cts}

@@ -1,4 +1,5 @@
-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';
+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, k as AppAssetLibraryMediaType, l as AppAssetLibraryPlacementType, n as AppAssetLibraryPlacementState, j as AppAssetLibraryAssetCategory, m as AppAssetLibraryAssetState, o as AppAssetLibraryFeature, p as AppAssetLibraryPlacementPlatform } from './enums-yXNVh3UI.cjs';
+import { A as AppleSession } from './apple-session-jUzBrql5.cjs';
 
 interface TokenConfig {
     keyId: string;
@@ -434,6 +435,31 @@ declare class AppsResource {
         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 {
@@ -1206,11 +1232,24 @@ declare class ReviewSubmissionItemsResource {
         limit?: number;
     }): Promise<ReviewSubmissionItem[]>;
     get(id: string): Promise<ReviewSubmissionItem>;
+    /**
+     * Add one item to a review submission. Besides versions, asset library
+     * images and videos can be submitted on their own (ASC API 4.5.1) so
+     * creative assets are approved ahead of a campaign.
+     */
     create(params: {
         reviewSubmissionId: string;
         appStoreVersionId?: string;
         appCustomProductPageVersionId?: string;
         appStoreVersionExperimentId?: string;
+        appStoreVersionExperimentV2Id?: string;
+        appEventId?: string;
+        appAssetLibraryImageId?: string;
+        appAssetLibraryVideoId?: string;
+        backgroundAssetVersionId?: string;
+        inAppPurchaseVersionId?: string;
+        subscriptionVersionId?: string;
+        subscriptionGroupVersionId?: string;
     }): Promise<ReviewSubmissionItem>;
     update(id: string, attributes: {
         removed?: boolean;
@@ -1340,142 +1379,226 @@ declare class XcodeMetricsResource {
     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 {
+interface AppAssetLibraryPlacementAttributes {
+    mediaType?: AppAssetLibraryMediaType;
+    placementType?: AppAssetLibraryPlacementType;
+    placementGroup?: string;
+    state?: AppAssetLibraryPlacementState;
+    stateDetails?: Array<{
+        code?: string;
+        message?: string;
+    }> | null;
+    createdDate?: string;
+    lastModifiedDate?: string;
+}
+type AppAssetLibraryPlacement = JsonApiResource<"appAssetLibraryPlacements", AppAssetLibraryPlacementAttributes>;
+/** The localization a placement puts an asset on. */
+type PlacementTargetKind = "appStoreVersionLocalization" | "appCustomProductPageLocalization" | "appEventLocalization" | "appStoreVersionExperimentTreatmentLocalization";
+interface PlacementTarget {
+    kind: PlacementTargetKind;
     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;
+declare class AppAssetLibraryPlacementsResource {
+    private http;
+    constructor(http: RequestClient);
+    /**
+     * Place an image or video on one localization. Placements cannot be edited —
+     * delete and recreate. The parent version/page must be editable.
+     */
+    create(params: {
+        placementType: AppAssetLibraryPlacementType;
+        placementGroup: string;
+        imageId?: string;
+        videoId?: string;
+        target: PlacementTarget;
+    }): Promise<AppAssetLibraryPlacement>;
+    get(id: string, params?: {
+        include?: string;
+    }): Promise<AppAssetLibraryPlacement>;
+    delete(id: string): Promise<void>;
+    /** Placements on one localization, in display order by default. */
+    listForTarget(target: PlacementTarget, params?: {
+        placementType?: AppAssetLibraryPlacementType;
+        placementGroup?: string;
+        include?: string;
+    }): Promise<AppAssetLibraryPlacement[]>;
+    /** Set the display order of a placement group. In-app event localizations cannot be ordered. */
+    order(params: {
+        placementGroup: string;
+        placementIds: string[];
+        target: PlacementTarget;
+    }): Promise<void>;
 }
-/**
- * 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[]);
+
+interface AssetAttributes {
+    category?: AppAssetLibraryAssetCategory;
+    fileName?: string;
+    fileSize?: number;
+    referenceName?: string | null;
+    specId?: string | null;
+    state?: AppAssetLibraryAssetState;
+    stateDetails?: Array<{
+        code?: string;
+        message?: string;
+    }> | null;
+    uploadOperations?: UploadOperation[] | null;
+    createdDate?: string;
+    lastModifiedDate?: string;
+}
+interface AppAssetLibraryImageAttributes extends AssetAttributes {
+    imageAsset?: {
+        templateUrl: string;
+        width: number;
+        height: number;
+    } | null;
+}
+interface AppAssetLibraryVideoAttributes extends AssetAttributes {
+    previewFrameTimeCode?: string | null;
+    videoAsset?: {
+        url?: string;
+        width?: number;
+        height?: number;
+        duration?: string;
+    } | null;
+    previewFrameImage?: {
+        templateUrl: string;
+        width: number;
+        height: number;
+    } | null;
+}
+type AppAssetLibraryImage = JsonApiResource<"appAssetLibraryImages", AppAssetLibraryImageAttributes>;
+type AppAssetLibraryVideo = JsonApiResource<"appAssetLibraryVideos", AppAssetLibraryVideoAttributes>;
+interface CreateAssetParams {
+    libraryId: string;
+    fileName: string;
+    fileSize: number;
+    /** Fixed at upload. Headers, search results and event assets need CREATIVE_ASSETS. */
+    category: AppAssetLibraryAssetCategory;
+    referenceName?: string;
+}
+interface UpdateAssetAttributes {
+    /** Commit after every upload operation has succeeded. No checksum is sent. */
+    uploaded?: boolean;
+    referenceName?: string;
+    /** Only an APPROVED asset can be archived (409 STATE_ERROR.INVALID_ASSET_STATE otherwise). */
+    archived?: boolean;
 }
 /**
- * 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
+ * Images and videos in an app's asset library share one lifecycle:
+ * reserve (POST) → run uploadOperations → PATCH uploaded:true → poll state.
  */
-declare function submitTwoFactorCode(input: {
-    pending: PendingLogin;
-    code: string;
-    source: "device" | "phone";
-    phoneId?: number;
-    mode?: "sms" | "voice";
-    onLog?: (msg: string) => void;
-}): Promise<AppleSession>;
+declare abstract class AssetLibraryMediaResource<T extends "appAssetLibraryImages" | "appAssetLibraryVideos", R extends JsonApiResource<T, AssetAttributes>> {
+    protected http: RequestClient;
+    protected abstract readonly type: T;
+    constructor(http: RequestClient);
+    get(id: string): Promise<R>;
+    protected reserve(params: CreateAssetParams, extra?: Record<string, unknown>): Promise<R>;
+    protected patch(id: string, attributes: Record<string, unknown>): Promise<R>;
+    /** Fails with 409 STATE_ERROR.ASSET_HAS_PLACEMENTS while the asset is still placed. */
+    delete(id: string): Promise<void>;
+    listPlacements(id: string, params?: ListParams): Promise<AppAssetLibraryPlacement[]>;
+}
+declare class AppAssetLibraryImagesResource extends AssetLibraryMediaResource<"appAssetLibraryImages", AppAssetLibraryImage> {
+    protected readonly type: "appAssetLibraryImages";
+    create(params: CreateAssetParams): Promise<AppAssetLibraryImage>;
+    update(id: string, attributes: UpdateAssetAttributes): Promise<AppAssetLibraryImage>;
+}
+declare class AppAssetLibraryVideosResource extends AssetLibraryMediaResource<"appAssetLibraryVideos", AppAssetLibraryVideo> {
+    protected readonly type: "appAssetLibraryVideos";
+    create(params: CreateAssetParams & {
+        previewFrameTimeCode?: string;
+    }): Promise<AppAssetLibraryVideo>;
+    update(id: string, attributes: UpdateAssetAttributes & {
+        previewFrameTimeCode?: string;
+    }): Promise<AppAssetLibraryVideo>;
+}
+
 /**
- * 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.
+ * The App Asset Library (ASC API 4.5.1) — one per app. Images and videos are
+ * uploaded into it once, then placed on any number of App Store surfaces
+ * (version, custom product page, in-app event, product page test
+ * localizations). Replaces the deprecated screenshot/preview sets.
  */
-declare function loginWithAppleId(config: AppleSessionConfig): Promise<AppleSession>;
+type AppAssetLibrary = JsonApiResource<"appAssetLibraries", Record<string, never>>;
+interface AppAssetLibraryDimensions {
+    minWidth: number;
+    maxWidth: number;
+    minHeight: number;
+    maxHeight: number;
+}
+interface AppAssetLibraryImageSpec {
+    specId: string;
+    shortName?: string;
+    aspectRatio?: string;
+    dimensions: AppAssetLibraryDimensions;
+    compatiblePlacementTypes: AppAssetLibraryPlacementType[];
+    alphaAllowed?: boolean;
+    fileExtensions?: string[];
+    mimeTypes?: string[];
+    maxFileSize?: number;
+    universalAsset?: boolean;
+}
+interface AppAssetLibraryVideoSpec extends AppAssetLibraryImageSpec {
+    audioRequired?: boolean;
+    duration?: {
+        min?: string;
+        max?: string;
+    };
+    frameRates?: Array<{
+        minFps?: number;
+        maxFps?: number;
+    }>;
+}
+interface AppAssetLibraryRefDatumAttributes {
+    features?: Array<{
+        featureId: AppAssetLibraryFeature;
+        placementPolicies?: Array<{
+            placementType: AppAssetLibraryPlacementType;
+            groupLimits?: Array<{
+                groupIds: string[];
+                maxCount: number;
+            }>;
+        }>;
+    }>;
+    placementProfileGroups?: Array<{
+        placementProfileGroupId: string;
+        platform?: AppAssetLibraryPlacementPlatform;
+        displayClassId?: string;
+    }>;
+    imageSpecs?: AppAssetLibraryImageSpec[];
+    videoSpecs?: AppAssetLibraryVideoSpec[];
+    placementTypes?: Array<{
+        placementTypeId: AppAssetLibraryPlacementType;
+        acceptsAssetCategories?: AppAssetLibraryAssetCategory[];
+        specMappings?: Array<{
+            placementGroupId: string;
+            specs: string[];
+        }>;
+    }>;
+    displayClasses?: Array<{
+        displayClassId: string;
+        deviceFamily?: string;
+        screenDimensions?: string[];
+    }>;
+}
+type AppAssetLibraryRefDatum = JsonApiResource<"appAssetLibraryRefData", AppAssetLibraryRefDatumAttributes>;
+declare class AppAssetLibrariesResource {
+    private http;
+    constructor(http: RequestClient);
+    getForApp(appId: string): Promise<AppAssetLibrary>;
+    listImages(libraryId: string, params?: ListParams): Promise<AppAssetLibraryImage[]>;
+    listVideos(libraryId: string, params?: ListParams): Promise<AppAssetLibraryVideo[]>;
+    /**
+     * Specs, placement groups and limits. Apple adds placement groups (new
+     * devices) without an API version bump, so read them from here rather than
+     * hard-coding display types.
+     */
+    refData(params?: {
+        features?: AppAssetLibraryFeature[];
+        placementTypes?: AppAssetLibraryPlacementType[];
+        placementProfileGroups?: string[];
+    }): Promise<AppAssetLibraryRefDatumAttributes>;
+}
 
 /**
  * Apple Developer Portal Client
@@ -1643,6 +1766,105 @@ declare class PortalClient {
         featureType: string;
         enabled: boolean;
     }): Promise<void>;
+    /** Apple's internal feature code for the App Groups capability. */
+    static readonly APP_GROUPS_FEATURE = "APG3427HIY";
+    /** List all app groups in the team. */
+    listAppGroups(): Promise<any[]>;
+    /**
+     * Create an app group, returning the raw group record. Idempotent —
+     * Apple rejects a duplicate group identifier ("Multiple App Groups may
+     * not have the same identifier"), so we list first and reuse an existing
+     * group when the identifier already exists in the team.
+     *
+     * Note the two ids on the returned record: `identifier` is the
+     * `group.com.…` string you type, while `applicationGroup` is Apple's
+     * opaque internal handle that association actually requires — do NOT pass
+     * the human identifier to assignAppGroups.
+     */
+    createAppGroup(params: {
+        identifier: string;
+        name: string;
+    }): Promise<any>;
+    /**
+     * Enable the App Groups capability on an App ID. Required before an
+     * App ID can have a group associated with it — mirrors Spaceship
+     * enabling `AppService::AppGroup` before `associate_groups`.
+     */
+    enableAppGroups(appIdId: string): Promise<void>;
+    /**
+     * Associate one or more app groups with an App ID. `appGroupIds` are the
+     * internal ids (Spaceship's `app_group_id`), NOT the `group.com.…`
+     * identifiers. Apple wants both `appIdId` and `displayId` set to the
+     * App ID's internal id, per Spaceship's associate_groups_with_app.
+     */
+    assignAppGroups(params: {
+        appIdId: string;
+        appGroupIds: string[];
+    }): Promise<void>;
+    /** Apple's internal feature code for the Apple Pay capability. */
+    static readonly APPLE_PAY_FEATURE = "OM633U5T5G";
+    /**
+     * List all Apple Pay merchant IDs in the team. Each record maps
+     * (per Spaceship's merchant.rb attr_mapping): `omcId` = internal id,
+     * `identifier` = the human `merchant.com.…` string, `name` = display name.
+     */
+    listMerchants(): Promise<any[]>;
+    /**
+     * Register (or reuse) a merchant ID, returning its INTERNAL id (`omcId`) —
+     * Apple's opaque handle that association requires, NOT the human
+     * `merchant.com.…` identifier. Idempotent: lists first and reuses an
+     * existing merchant with the same identifier. Endpoint + params ported 1:1
+     * from Spaceship's create_merchant! (addOMC.action).
+     */
+    createMerchant(params: {
+        identifier: string;
+        name: string;
+    }): Promise<string>;
+    /**
+     * Enable the Apple Pay capability on an App ID. Apple Pay is a standard
+     * AppService (service_id OM633U5T5G) whose service_uri is the default
+     * `updateService.action` — confirmed in Spaceship's app_service.rb.
+     */
+    enableApplePay(appIdId: string): Promise<void>;
+    /**
+     * Associate merchant IDs with an App ID's Apple Pay capability. `omcIds`
+     * are the internal ids (each merchant record's `omcId`), NOT the
+     * `merchant.com.…` identifiers. Endpoint + params ported 1:1 from
+     * Spaceship's associate_merchants_with_app (assignOMCToAppId.action — note
+     * the singular "OMC", and NO displayId param).
+     */
+    assignMerchants(params: {
+        appIdId: string;
+        omcIds: string[];
+    }): Promise<void>;
+    /**
+     * Create an Apple Pay **Payment Processing Certificate** on a merchant ID
+     * from a CSR — the certificate a PSP (e.g. Stripe) hands you as a CSR, which
+     * must be uploaded to the Merchant ID in Apple Developer, then the resulting
+     * `.cer` downloaded and given back to the PSP so it can decrypt payment
+     * tokens. This is the one manual Apple-portal step in wiring up Apple Pay.
+     *
+     * Ported 1:1 from Spaceship's create_certificate! (submitCertificateRequest
+     * .action): the merchant's INTERNAL id (`omcId`) is passed as BOTH `appIdId`
+     * and `specialIdentifierDisplayId` — the latter is how the portal scopes a
+     * cert to a merchant/special identifier rather than an App ID. The cert type
+     * is APPLE_PAY (`4APLUP237T`). Returns the created certRequest (its
+     * `certificateId` feeds `downloadApplePayCertificate`).
+     *
+     * @param omcId       the merchant's internal id (from createMerchant/listMerchants)
+     * @param csrContent  the PEM CSR string (Stripe's "Apple Pay CSR")
+     */
+    createApplePayCertificate(params: {
+        omcId: string;
+        csrContent: string;
+    }): Promise<any>;
+    /**
+     * Download an Apple Pay Payment Processing Certificate's raw bytes by its
+     * certificate id (from `createApplePayCertificate`). Thin wrapper over
+     * `downloadCertificate` pinned to the APPLE_PAY type — the DER `.cer` you
+     * upload back into Stripe.
+     */
+    downloadApplePayCertificate(certificateId: string): Promise<Buffer>;
     listCertificates(types?: string[]): Promise<any[]>;
     listPushCertificates(): Promise<any[]>;
     createCertificate(params: {
@@ -1867,8 +2089,12 @@ declare class AppStoreConnectClient {
     readonly inAppPurchases: InAppPurchasesResource;
     readonly gameCenterDetail: GameCenterDetailResource;
     readonly xcodeMetrics: XcodeMetricsResource;
+    readonly appAssetLibraries: AppAssetLibrariesResource;
+    readonly appAssetLibraryImages: AppAssetLibraryImagesResource;
+    readonly appAssetLibraryVideos: AppAssetLibraryVideosResource;
+    readonly appAssetLibraryPlacements: AppAssetLibraryPlacementsResource;
     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 };
+export { AppAssetLibraryVideosResource as $, AppStoreConnectClient as A, type BundleId as B, type Certificate as C, type Device as D, AppStoreVersionsResource as E, type AppStoreVersion as F, type AppStoreVersionLocalization as G, AppScreenshotsResource as H, type AppScreenshot as I, type JsonApiResource as J, type AppScreenshotSet as K, type ListParams as L, ReviewSubmissionsResource as M, type ReviewSubmission as N, type AppStoreVersionSubmission as O, type Profile as P, AppAssetLibrariesResource as Q, RequestClient as R, type AppAssetLibrary as S, TokenManager as T, type UploadOperation as U, type AppAssetLibraryRefDatum as V, type AppAssetLibraryRefDatumAttributes as W, type AppAssetLibraryImageSpec as X, type AppAssetLibraryVideoSpec as Y, type AppAssetLibraryDimensions as Z, AppAssetLibraryImagesResource as _, AppStoreConnectError as a, type AppAssetLibraryImage as a0, type AppAssetLibraryVideo as a1, type CreateAssetParams as a2, type UpdateAssetAttributes as a3, AppAssetLibraryPlacementsResource as a4, type AppAssetLibraryPlacement as a5, type PlacementTarget as a6, type PlacementTargetKind as a7, PortalClient as a8, IrisClient as a9, IrisAuthError as aa, type IrisApiKey as ab, type ApiKeyRole as ac, type JsonApiRelationship as ad, type JsonApiErrorResponse as ae, RateLimitError as b, type AppStoreConnectConfig as c, type TokenConfig as d, type RequestOptions as e, type JsonApiResponse as f, type JsonApiListResponse as g, type JsonApiError as h, type App as i, type Build as j, type BetaGroup as k, type BetaBuildLocalization as l, type BuildBetaDetail as m, type PreReleaseVersion$1 as n, type BundleIdCapability as o, type CapabilitySettingInput as p, type CapabilitySetting as q, type CapabilityOption as r, CertificatesResource as s, ProfilesResource as t, BundleIdsResource as u, DevicesResource as v, AppsResource as w, BuildsResource as x, BetaGroupsResource as y, CapabilitiesResource as z };

package/dist/index-Dv-Mek07.d.cts

@@ -0,0 +1,84 @@
+type AndroidOutputType = "aab" | "apk" | "both";
+interface GradleBuildOptions {
+    /** The android/ dir or app root containing `gradlew`. */
+    projectDir: string;
+    /** Which artifact(s) to produce. */
+    outputType: AndroidOutputType;
+    /** Product flavor (e.g. "prod") — capitalized into the Gradle task name. */
+    flavor?: string;
+    /** Build type, defaults to "Release". */
+    buildType?: string;
+    /**
+     * JVM args for the Gradle daemon. Defaults to a raised heap/metaspace
+     * (`-Xmx3072m -XX:MaxMetaspaceSize=1024m`) because Expo's generated
+     * `gradle.properties` caps metaspace at 512m, which OOMs on large RN
+     * module graphs (Kotlin/AGP class metadata). Set to `null` to leave the
+     * project's `gradle.properties` untouched.
+     */
+    jvmArgs?: string | null;
+    /** Absolute (or resolvable) path to the keystore file. */
+    keystorePath: string;
+    keystorePassword: string;
+    keyAlias: string;
+    keyPassword: string;
+    onOutput?: (chunk: string) => void;
+    /** When aborted, the gradlew process group is killed to stop the build. */
+    signal?: AbortSignal;
+}
+interface GradleBuildResult {
+    success: boolean;
+    exitCode: number;
+    aabPath?: string;
+    apkPath?: string;
+    logContent: string;
+}
+/**
+ * Rewrite `versionCode` (and `versionName`, when given) in an app module's
+ * Gradle file, Groovy (`versionCode 1`) or Kotlin DSL (`versionCode = 1`).
+ * Returns the new source and whether each value was found.
+ */
+declare function stampAndroidVersion(source: string, versionCode: number, versionName?: string | null): {
+    source: string;
+    versionCode: boolean;
+    versionName: boolean;
+};
+/**
+ * Stamp the build's version into `android/app/build.gradle(.kts)`. Play refuses
+ * a versionCode it has seen, so each build must carry its own.
+ */
+declare function setAndroidVersion(projectDir: string, versionCode: number, versionName?: string | null): Promise<{
+    file: string;
+    versionCode: boolean;
+    versionName: boolean;
+}>;
+/**
+ * Resolve the directory that contains `gradlew`. Accepts either the app root
+ * (which contains an `android/` subdirectory) or the `android/` dir itself.
+ */
+declare function detectAndroidDir(rootDir: string): Promise<string>;
+/**
+ * Build an Android app using Gradle (`./gradlew`).
+ * This is the Android-side equivalent of `gym` (iOS).
+ *
+ * Steps:
+ *  1. Resolve the gradlew directory.
+ *  2. chmod +x gradlew so it's executable on fresh checkouts.
+ *  3. Run the appropriate task(s) (bundle/assemble), injecting the signing
+ *     config via standard AGP `-Pandroid.injected.signing.*` properties.
+ *  4. Locate produced AAB/APK artifacts by globbing standard output paths.
+ *  5. Return a GradleBuildResult.
+ */
+declare function buildAndroid(options: GradleBuildOptions): Promise<GradleBuildResult>;
+
+type index_AndroidOutputType = AndroidOutputType;
+type index_GradleBuildOptions = GradleBuildOptions;
+type index_GradleBuildResult = GradleBuildResult;
+declare const index_buildAndroid: typeof buildAndroid;
+declare const index_detectAndroidDir: typeof detectAndroidDir;
+declare const index_setAndroidVersion: typeof setAndroidVersion;
+declare const index_stampAndroidVersion: typeof stampAndroidVersion;
+declare namespace index {
+  export { type index_AndroidOutputType as AndroidOutputType, type index_GradleBuildOptions as GradleBuildOptions, type index_GradleBuildResult as GradleBuildResult, index_buildAndroid as buildAndroid, index_detectAndroidDir as detectAndroidDir, index_setAndroidVersion as setAndroidVersion, index_stampAndroidVersion as stampAndroidVersion };
+}
+
+export { type AndroidOutputType as A, type GradleBuildOptions as G, type GradleBuildResult as a, setAndroidVersion as b, buildAndroid as c, detectAndroidDir as d, index as i, stampAndroidVersion as s };