@expo/apple-utils 2.1.19 → 2.1.20

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@expo/apple-utils",
-  "version": "2.1.19",
+  "version": "2.1.20",
   "main": "build",
   "license": "MIT",
   "scripts": {
-    "prepare": "yarn run clean && yarn workspace @expo/app-store run prepare && yarn run typegen && yarn run build:prod && yarn run append-types",
+    "prepare": "bun run clean && bun run --filter '@expo/app-store' prepare && bun run typegen && bun run build:prod && bun run append-types",
     "lint": "eslint . --ext .ts",
-    "watch": "yarn run build -w",
+    "watch": "bun run build -w",
     "test": "jest",
     "build": "ncc build ./src/index.ts -o build/",
     "build:prod": "ncc build ./src/index.ts -o build/ --minify --no-cache --no-source-map-register",

package/ts-declarations/expo__app-store/app-store.d.ts

@@ -1466,6 +1466,8 @@ declare module "connect/AssetAPI" {
     export enum AppMediaAssetStateState {
         AWAITING_UPLOAD = "AWAITING_UPLOAD",
         UPLOAD_COMPLETE = "UPLOAD_COMPLETE",
+        /** Used by videoDeliveryState while Apple transcodes the video. */
+        PROCESSING = "PROCESSING",
         COMPLETE = "COMPLETE",
         FAILED = "FAILED"
     }
@@ -2991,8 +2993,11 @@ declare module "connect/models/AppPreview" {
         sourceFileChecksum: string;
         /**
          * Time code for the preview frame (poster image).
-         * Format: "MM:SS:FF" where FF is frames (e.g., "00:05:00" for 5 seconds)
-         * @example "00:05:00"
+         * Must be exactly 4-segment "HH:MM:SS:FF" format where FF is frames.
+         * 3-segment ("MM:SS:FF") and 5+ segment formats are rejected with "Invalid format!".
+         * Values beyond the video duration are silently accepted (clamped to last frame).
+         * Empty string and null are rejected with "previewFrameTimeCode attribute is missing!".
+         * @example "00:00:05:01"
          */
         previewFrameTimeCode: string | null;
         mimeType: string;
@@ -3001,6 +3006,15 @@ declare module "connect/models/AppPreview" {
          * Only available after processing is complete.
          */
         videoUrl: string | null;
+        /**
+         * Preview frame/poster image with processing state.
+         * Contains the image asset and its processing state (e.g., COMPLETE, PROCESSING).
+         * This is the detailed version returned by the API after setting a preview frame time code.
+         */
+        previewFrameImage: {
+            image: ImageAsset;
+            state: AppMediaAssetState;
+        } | null;
         /**
          * Preview frame/poster image asset.
          * Contains templateUrl with {w}, {h}, {f} placeholders.
@@ -3008,6 +3022,12 @@ declare module "connect/models/AppPreview" {
         previewImage: ImageAsset | null;
         uploadOperations: UploadOperation[];
         assetDeliveryState: AppMediaAssetState;
+        /**
+         * Video-specific delivery state. Tracks video transcoding/processing progress
+         * separately from the asset upload state.
+         * Only present for video previews (not screenshots).
+         */
+        videoDeliveryState: AppMediaAssetState | null;
     }
     /**
      * App Preview (video) for App Store listings.
@@ -3032,7 +3052,7 @@ declare module "connect/models/AppPreview" {
          * @param id AppPreviewSet ID
          * @param filePath Path to the video file (MP4, MOV)
          * @param waitForProcessing Wait for Apple to process the video (default: true)
-         * @param previewFrameTimeCode Optional time code for preview frame (e.g., "00:05:00" for 5 seconds)
+         * @param previewFrameTimeCode Optional time code for preview frame in "HH:MM:SS:FF" format (e.g., "00:00:05:00" for 5 seconds)
          */
         static uploadAsync(context: RequestContext, { id, filePath, waitForProcessing, previewFrameTimeCode, }: {
             id: string;
@@ -3047,6 +3067,11 @@ declare module "connect/models/AppPreview" {
         updateAsync(options: Partial<AppPreviewProps> & {
             uploaded?: boolean;
         }): Promise<AppPreview>;
+        /**
+         * Set the poster frame (preview image) for this app preview.
+         * @param previewFrameTimeCode Time code in "HH:MM:SS:FF" format (e.g., "00:00:05:01" for ~5 seconds)
+         */
+        setPreviewFrameAsync(previewFrameTimeCode: string): Promise<AppPreview>;
         isAwaitingUpload(): boolean;
         isProcessing(): boolean;
         isComplete(): boolean;
@@ -3816,6 +3841,10 @@ declare module "connect/models/ResolutionCenterMessage" {
         fromActor: unknown;
     }
     export type ResolutionCenterMessageQueryFilter = ConnectQueryFilter<ResolutionCenterMessageProps, 'rejections'>;
+    /**
+     * Resolution center messages require session auth (Iris API).
+     * These endpoints are NOT available with API key (JWT) authentication.
+     */
     export class ResolutionCenterMessage extends ConnectModel<ResolutionCenterMessageProps> {
         static type: string;
         static getAsync: (context: import("AppStoreConnect").RequestContext, props?: {
@@ -3827,20 +3856,82 @@ declare module "connect/models/ResolutionCenterMessage" {
         } | undefined) => Promise<ResolutionCenterMessage[]>;
     }
 }
+declare module "connect/models/ResolutionCenterDraftMessage" {
+    import { RequestContext } from "network/Request";
+    import { ConnectModel } from "connect/models/ConnectModel";
+    import { ResolutionCenterMessage } from "connect/models/ResolutionCenterMessage";
+    interface ResolutionCenterDraftMessageProps {
+        messageBody: string;
+        /** @example '2026-04-13T20:26:31.914Z' */
+        createdDate: string;
+        /** @example '2026-04-13T20:26:31.883Z' */
+        lastUpdatedDate: string;
+    }
+    /**
+     * Draft messages in the resolution center. Used as an intermediate step
+     * before sending a reply to App Review.
+     *
+     * Requires session auth (Iris API). NOT available with API key (JWT) authentication.
+     *
+     * Flow: createAsync (draft) → sendAsync (publish draft as message)
+     */
+    export class ResolutionCenterDraftMessage extends ConnectModel<ResolutionCenterDraftMessageProps> {
+        static type: string;
+        /**
+         * Create a draft message on a resolution center thread.
+         *
+         * POST /iris/v1/resolutionCenterDraftMessages
+         */
+        static createAsync(context: RequestContext, { threadId, messageBody, }: {
+            threadId: string;
+            messageBody: string;
+        }): Promise<ResolutionCenterDraftMessage>;
+        static deleteAsync: (context: RequestContext, props: {
+            id: string;
+        }) => Promise<void>;
+        /**
+         * Update the draft message body.
+         *
+         * PATCH /iris/v1/resolutionCenterDraftMessages/{id}
+         */
+        updateAsync({ messageBody, }: {
+            messageBody: string;
+        }): Promise<ResolutionCenterDraftMessage>;
+        /**
+         * Delete this draft message.
+         *
+         * DELETE /iris/v1/resolutionCenterDraftMessages/{id}
+         */
+        deleteAsync(): Promise<void>;
+        /**
+         * Send this draft message, publishing it as a resolution center message.
+         *
+         * POST /iris/v1/resolutionCenterMessages
+         */
+        sendAsync(): Promise<ResolutionCenterMessage>;
+    }
+}
 declare module "connect/models/ReviewRejection" {
     import { ConnectQueryFilter } from "connect/ConnectAPI";
     import { ConnectModel } from "connect/models/ConnectModel";
-    interface ReviewRejectionProps {
-        /** '2.1' */
+    export interface ReviewRejectionReason {
+        /** @example '2.5' */
         reasonSection: string;
-        /** 'Performance: App Completeness' */
+        /** @example 'Performance: Software Requirements' */
         reasonDescription: string;
-        /** '2.1.0' */
+        /** @example '2.5.4' */
         reasonCode: string;
     }
+    interface ReviewRejectionProps {
+        reasons: ReviewRejectionReason[];
+    }
     export type ReviewRejectionQueryFilter = ConnectQueryFilter<ReviewRejectionProps & {
         'resolutionCenterMessage.resolutionCenterThread': string;
     }, 'resolutionCenterMessage.resolutionCenterThread'>;
+    /**
+     * Review rejections require session auth (Iris API).
+     * These endpoints are NOT available with API key (JWT) authentication.
+     */
     export class ReviewRejection extends ConnectModel<ReviewRejectionProps> {
         static type: string;
         static getAsync: (context: import("AppStoreConnect").RequestContext, props?: {
@@ -3857,6 +3948,7 @@ declare module "connect/models/ResolutionCenterThread" {
     import type { AppStoreVersion } from "connect/models/AppStoreVersion";
     import type { Build } from "connect/models/Build";
     import { ConnectModel } from "connect/models/ConnectModel";
+    import { ResolutionCenterDraftMessage } from "connect/models/ResolutionCenterDraftMessage";
     import { ResolutionCenterMessage } from "connect/models/ResolutionCenterMessage";
     import { ReviewRejection } from "connect/models/ReviewRejection";
     export interface ResolutionCenterThreadProps {
@@ -3877,6 +3969,10 @@ declare module "connect/models/ResolutionCenterThread" {
         build: string;
         reviewSubmission: string;
     }, 'build' | 'appStoreVersion' | 'threadType' | 'reviewSubmission'>;
+    /**
+     * Resolution center threads require session auth (Iris API).
+     * These endpoints are NOT available with API key (JWT) authentication.
+     */
     export class ResolutionCenterThread extends ConnectModel<ResolutionCenterThreadProps> {
         static type: string;
         static DEFAULT_INCLUDES: string[];
@@ -3893,7 +3989,28 @@ declare module "connect/models/ResolutionCenterThread" {
         getResolutionCenterMessagesAsync({ query, }?: {
             query?: ConnectQueryParams;
         }): Promise<ResolutionCenterMessage[]>;
+        /**
+         * Get the current draft message for this thread, if any.
+         *
+         * GET /iris/v1/resolutionCenterThreads/{id}/resolutionCenterDraftMessage
+         * Note: singular endpoint (not plural), returns a single object not an array.
+         */
+        getDraftMessageAsync(): Promise<ResolutionCenterDraftMessage | null>;
         fetchRejectionReasonsAsync(): Promise<ReviewRejection[]>;
+        /**
+         * Create a draft message on this thread.
+         * Use `draft.sendAsync()` to publish it.
+         */
+        createDraftMessageAsync({ messageBody, }: {
+            messageBody: string;
+        }): Promise<ResolutionCenterDraftMessage>;
+        /**
+         * Send a reply to this resolution center thread.
+         * Creates a draft and immediately publishes it.
+         */
+        sendReplyAsync({ messageBody }: {
+            messageBody: string;
+        }): Promise<ResolutionCenterMessage>;
     }
 }
 declare module "connect/models/Build" {
@@ -4513,12 +4630,119 @@ declare module "connect/models/AppPriceTier" {
         static type: string;
     }
 }
+declare module "connect/models/Territory" {
+    import { ConnectModel } from "connect/models/ConnectModel";
+    export interface TerritoryProps {
+        /**
+         * @example 'USD'
+         */
+        currency: string;
+    }
+    export class Territory extends ConnectModel<TerritoryProps> {
+        static type: string;
+        static getAsync: (context: import("AppStoreConnect").RequestContext, props?: {
+            query?: import("connect/ConnectAPI").ConnectQueryParams<Record<string, any>> | undefined;
+        } | undefined) => Promise<Territory[]>;
+    }
+}
+declare module "connect/models/AppPricePoint" {
+    import { RequestContext } from "network/Request";
+    import { ConnectQueryFilter, ConnectQueryParams } from "connect/ConnectAPI";
+    import { AppPriceTier } from "connect/models/AppPriceTier";
+    import { ConnectModel } from "connect/models/ConnectModel";
+    import { Territory } from "connect/models/Territory";
+    export interface AppPricePointProps {
+        customerPrice: string;
+        proceeds: string;
+        /** @deprecated Only populated via the legacy iris endpoint. */
+        priceTier?: AppPriceTier;
+        territory?: Territory;
+    }
+    export type AppPricePointQueryFilter = ConnectQueryFilter<{
+        territory: string;
+        priceTier: string;
+        app: string;
+    }, 'territory' | 'priceTier' | 'app'>;
+    export class AppPricePoint extends ConnectModel<AppPricePointProps> {
+        static type: string;
+        /**
+         * Legacy list endpoint (iris). Kept for backwards compatibility; new callers
+         * should use the app-scoped {@link AppPricePoint.getForAppAsync} helper which
+         * uses the public App Store Connect API.
+         */
+        static getAsync: (context: RequestContext, props?: {
+            query?: ConnectQueryParams<Partial<{
+                app: string | string[];
+                territory: string | string[];
+                priceTier: string | string[];
+            } & {
+                id?: string;
+            }>> | undefined;
+        } | undefined) => Promise<AppPricePoint[]>;
+        /**
+         * Look up a single price point by id (ex: `UNHB5PT4MA`).
+         *
+         * Uses the legacy iris endpoint for compatibility with existing callers.
+         * The modern equivalent is `GET /v3/appPricePoints/{id}`.
+         */
+        static infoAsync: (context: RequestContext, props: {
+            id: string;
+            query?: ConnectQueryParams;
+        }) => Promise<AppPricePoint>;
+        /**
+         * Fetch the valid price points for a given app, optionally filtered by
+         * territory. This is the replacement for the deprecated global
+         * `appPriceTiers` lookup and is used when constructing an
+         * {@link AppPriceSchedule}. Price point ids are app-specific.
+         *
+         * @see https://developer.apple.com/documentation/appstoreconnectapi/get-v1-apps-_id_-apppricepoints
+         */
+        static getForAppAsync(context: RequestContext, { id, query, }: {
+            /** App id (e.g. `1234567890`). */
+            id: string;
+            query?: ConnectQueryParams<AppPricePointQueryFilter>;
+        }): Promise<AppPricePoint[]>;
+    }
+}
 declare module "connect/models/AppPrice" {
+    import { AppPricePoint } from "connect/models/AppPricePoint";
     import { AppPriceTier } from "connect/models/AppPriceTier";
     import { ConnectModel } from "connect/models/ConnectModel";
+    import { Territory } from "connect/models/Territory";
     export interface AppPriceProps {
-        startDate: string;
-        priceTier: AppPriceTier;
+        /**
+         * ISO-8601 start date for this price (e.g. `2024-01-31`).
+         *
+         * When used as a "manual" price inside an {@link AppPriceSchedule} create
+         * request, passing `null` (or omitting the attribute) means "effective
+         * immediately".
+         */
+        startDate: string | null;
+        /**
+         * ISO-8601 end date. Optional — typically not set by callers and returned by
+         * Apple only for historical automatic prices.
+         */
+        endDate?: string | null;
+        /**
+         * Whether this price was set manually as part of an
+         * {@link AppPriceSchedule}, or automatically computed by Apple from the
+         * schedule's `baseTerritory` price. Only populated on reads.
+         */
+        manual?: boolean;
+        /**
+         * The price point this price refers to. Populated on reads, and required
+         * when constructing an `AppPrice` to pass to
+         * {@link AppPriceSchedule.createAsync}.
+         */
+        appPricePoint?: AppPricePoint;
+        /** Territory this price applies to (read-only). */
+        territory?: Territory;
+        /**
+         * Legacy price tier (e.g. `1`, `2`, ...). Only populated by the deprecated
+         * iris endpoint. New callers should use {@link AppPriceProps.appPricePoint}.
+         * @deprecated Apple removed the global tier system in late 2023.
+         */
+        priceTier?: AppPriceTier;
     }
     export class AppPrice extends ConnectModel<AppPriceProps> {
         static type: string;
@@ -4531,6 +4755,123 @@ declare module "connect/models/AppPrice" {
         }) => Promise<AppPrice>;
     }
 }
+declare module "connect/models/AppPriceSchedule" {
+    /**
+     * App price schedule — the "base territory" pricing model Apple introduced in
+     * late 2023, replacing the legacy `appPriceTier`-driven
+     * `App.updateAsync({ appPriceTier, territories })` flow.
+     *
+     * A schedule describes the full set of manual prices for an app. Creating a
+     * new schedule REPLACES any prior schedule entirely, so callers must include
+     * every manual price they want to keep.
+     *
+     * @see https://developer.apple.com/documentation/appstoreconnectapi/appPriceSchedules
+     * @see https://developer.apple.com/documentation/appstoreconnectapi/post-v1-apppriceschedules
+     * @see https://developer.apple.com/documentation/appstoreconnectapi/get-v1-apps-_id_-apppriceschedule
+     */
+    import { RequestContext } from "network/Request";
+    import { ConnectQueryParams } from "connect/ConnectAPI";
+    import { AppPrice } from "connect/models/AppPrice";
+    import { ConnectModel } from "connect/models/ConnectModel";
+    import { Territory } from "connect/models/Territory";
+    export interface AppPriceScheduleProps {
+        /** Territory used as the reference for automatically-computed prices. */
+        baseTerritory?: Territory;
+        /**
+         * Manual prices explicitly set by the developer. Each entry ties an
+         * {@link AppPricePoint} to an (optional) `startDate`.
+         */
+        manualPrices?: AppPrice[];
+        /**
+         * Prices automatically computed by Apple for territories not covered by
+         * `manualPrices`, using the `baseTerritory` price point as a reference.
+         * Read-only.
+         */
+        automaticPrices?: AppPrice[];
+    }
+    /**
+     * Shape of a manual price when creating an {@link AppPriceSchedule}. Each
+     * entry becomes an inline `appPrices` resource in the POST body, referencing
+     * an existing `appPricePoint` id (look these up via
+     * {@link AppPricePoint.getForAppAsync}).
+     */
+    export interface AppPriceScheduleManualPriceInput {
+        /** Id of the target `appPricePoint`. */
+        appPricePointId: string;
+        /**
+         * ISO-8601 date (YYYY-MM-DD) for when this price should take effect.
+         * Pass `null` (or omit) for "effective immediately".
+         */
+        startDate?: string | null;
+        /**
+         * Optional end date. Typically unused on creates — callers express "end"
+         * by scheduling a follow-up price with a later `startDate`.
+         */
+        endDate?: string | null;
+    }
+    export class AppPriceSchedule extends ConnectModel<AppPriceScheduleProps> {
+        static type: string;
+        static DEFAULT_INCLUDES: string[];
+        /**
+         * Fetch a single schedule by id.
+         *
+         * @see https://developer.apple.com/documentation/appstoreconnectapi/get-v1-apppriceschedules-_id_
+         */
+        static infoAsync: (context: RequestContext, props: {
+            id: string;
+            query?: ConnectQueryParams;
+        }) => Promise<AppPriceSchedule>;
+        /**
+         * Fetch the current schedule for an app.
+         *
+         * @see https://developer.apple.com/documentation/appstoreconnectapi/get-v1-apps-_id_-apppriceschedule
+         */
+        static getForAppAsync(context: RequestContext, { id, query, }: {
+            /** App id. */
+            id: string;
+            query?: ConnectQueryParams;
+        }): Promise<AppPriceSchedule | null>;
+        /**
+         * Create a new price schedule for an app. This REPLACES any prior
+         * schedule — callers must include every manual price they want to keep.
+         *
+         * Manual prices are passed as inline `appPrices` resources referencing
+         * existing `appPricePoint` ids. Look up valid price point ids for the target
+         * app (and optionally a specific territory) via
+         * {@link AppPricePoint.getForAppAsync}.
+         *
+         * @example
+         * ```ts
+         * const pricePoints = await AppPricePoint.getForAppAsync(context, {
+         *   id: app.id,
+         *   query: { filter: { territory: 'USA' } },
+         * });
+         * await AppPriceSchedule.createAsync(context, {
+         *   appId: app.id,
+         *   baseTerritoryId: 'USA',
+         *   manualPrices: [{ appPricePointId: pricePoints[0].id }],
+         * });
+         * ```
+         *
+         * @see https://developer.apple.com/documentation/appstoreconnectapi/post-v1-apppriceschedules
+         */
+        static createAsync(context: RequestContext, { appId, baseTerritoryId, manualPrices, }: {
+            /** Id of the app the schedule is being set on. */
+            appId: string;
+            /**
+             * Id of the territory (e.g. `USA`) whose manual price Apple should use
+             * as the reference for automatic prices in other territories.
+             */
+            baseTerritoryId: string;
+            /**
+             * Manual prices to apply. An empty array makes the app free in the
+             * base territory (Apple requires at least one entry matching the base
+             * territory's price point in practice).
+             */
+            manualPrices: AppPriceScheduleManualPriceInput[];
+        }): Promise<AppPriceSchedule>;
+    }
+}
 declare module "connect/models/BetaAppLocalization" {
     import { RequestContext } from "network/Request";
     import { ConnectQueryFilter } from "connect/ConnectAPI";
@@ -4961,21 +5302,6 @@ declare module "connect/models/ReviewSubmission" {
         getResolutionCenterThreadsAsync(): Promise<ResolutionCenterThread[]>;
     }
 }
-declare module "connect/models/Territory" {
-    import { ConnectModel } from "connect/models/ConnectModel";
-    export interface TerritoryProps {
-        /**
-         * @example 'USD'
-         */
-        currency: string;
-    }
-    export class Territory extends ConnectModel<TerritoryProps> {
-        static type: string;
-        static getAsync: (context: import("AppStoreConnect").RequestContext, props?: {
-            query?: import("connect/ConnectAPI").ConnectQueryParams<Record<string, any>> | undefined;
-        } | undefined) => Promise<Territory[]>;
-    }
-}
 declare module "connect/models/App" {
     import { RequestContext } from "network/Request";
     import { ConnectQueryFilter, ConnectQueryParams } from "connect/ConnectAPI";
@@ -4987,6 +5313,8 @@ declare module "connect/models/App" {
     import { AppDataUsagesPublishState } from "connect/models/AppDataUsagesPublishState";
     import { AppInfo, AppStoreState } from "connect/models/AppInfo";
     import { AppPrice } from "connect/models/AppPrice";
+    import { AppPricePoint, AppPricePointQueryFilter } from "connect/models/AppPricePoint";
+    import { AppPriceSchedule, AppPriceScheduleManualPriceInput } from "connect/models/AppPriceSchedule";
     import { AppStoreVersion, AppStoreVersionProps } from "connect/models/AppStoreVersion";
     import { BetaAppLocalization, BetaAppLocalizationProps } from "connect/models/BetaAppLocalization";
     import { BetaAppReviewDetail, BetaAppReviewDetailProps } from "connect/models/BetaAppReviewDetail";
@@ -5148,6 +5476,36 @@ declare module "connect/models/App" {
         getAvailableTerritoriesAsync({ query, }?: {
             query?: ConnectQueryParams;
         }): Promise<Territory[]>;
+        /**
+         * Get the current base-territory price schedule for this app, or `null` if
+         * none has been set. This is the read half of the modern pricing API
+         * (replaces the legacy `prices` relationship populated by
+         * `App.updateAsync({ appPriceTier, territories })`).
+         *
+         * @see https://developer.apple.com/documentation/appstoreconnectapi/get-v1-apps-_id_-apppriceschedule
+         */
+        getPriceScheduleAsync({ query, }?: {
+            query?: ConnectQueryParams;
+        }): Promise<AppPriceSchedule | null>;
+        /**
+         * Create (replace) the price schedule for this app. See
+         * {@link AppPriceSchedule.createAsync} for important details — this
+         * REPLACES any prior schedule entirely.
+         */
+        createPriceScheduleAsync({ baseTerritoryId, manualPrices, }: {
+            baseTerritoryId: string;
+            manualPrices: AppPriceScheduleManualPriceInput[];
+        }): Promise<AppPriceSchedule>;
+        /**
+         * List the valid price points for this app, optionally filtered by
+         * territory. Use this to look up a concrete `appPricePoint` id to pass to
+         * {@link App.createPriceScheduleAsync}.
+         *
+         * @see https://developer.apple.com/documentation/appstoreconnectapi/get-v1-apps-_id_-apppricepoints
+         */
+        getAppPricePointsAsync({ query, }?: {
+            query?: ConnectQueryParams<AppPricePointQueryFilter>;
+        }): Promise<AppPricePoint[]>;
         getInAppPurchasesAsync({ query, }?: {
             query?: ConnectQueryParams<InAppPurchaseQueryFilter>;
         }): Promise<InAppPurchase[]>;
@@ -5160,6 +5518,10 @@ declare module "connect/models/App" {
             platform?: Platform;
             includes?: string[];
         }): Promise<ReviewSubmission | null>;
+        getUnresolvedReviewSubmissionAsync({ platform, includes, }?: {
+            platform?: Platform;
+            includes?: string[];
+        }): Promise<ReviewSubmission | null>;
         getReviewSubmissionsAsync({ query, }?: {
             query?: ConnectQueryParams;
         }): Promise<ReviewSubmission[]>;
@@ -5349,41 +5711,6 @@ declare module "connect/models/ApiKey" {
         revokeAsync(): Promise<ApiKey>;
     }
 }
-declare module "connect/models/AppPricePoint" {
-    import { ConnectQueryFilter } from "connect/ConnectAPI";
-    import { AppPriceTier } from "connect/models/AppPriceTier";
-    import { ConnectModel } from "connect/models/ConnectModel";
-    import { Territory } from "connect/models/Territory";
-    export interface AppPricePointProps {
-        customerPrice: string;
-        proceeds: string;
-        priceTier?: AppPriceTier;
-        territory?: Territory;
-    }
-    export type AppPricePointQueryFilter = ConnectQueryFilter<{
-        territory: string;
-        priceTier: string;
-    }, 'territory' | 'priceTier'>;
-    export class AppPricePoint extends ConnectModel<AppPricePointProps> {
-        static type: string;
-        static getAsync: (context: import("AppStoreConnect").RequestContext, props?: {
-            query?: import("connect/ConnectAPI").ConnectQueryParams<Partial<{
-                territory: string | string[];
-                priceTier: string | string[];
-            } & {
-                id?: string;
-            }>> | undefined;
-        } | undefined) => Promise<AppPricePoint[]>;
-        /**
-         *
-         * @param id `AppPricePoint` id (ex: UNHB5PT4MA)
-         */
-        static infoAsync: (context: import("AppStoreConnect").RequestContext, props: {
-            id: string;
-            query?: import("connect/ConnectAPI").ConnectQueryParams;
-        }) => Promise<AppPricePoint>;
-    }
-}
 declare module "connect/models/BetaCrashLog" {
     /**
      * The crash log text associated with a beta feedback crash submission.
@@ -5692,6 +6019,7 @@ declare module "connect/index" {
     export * from "connect/models/AppInfoLocalization";
     export * from "connect/models/AppPrice";
     export * from "connect/models/AppPricePoint";
+    export * from "connect/models/AppPriceSchedule";
     export * from "connect/models/AppPriceTier";
     export * from "connect/models/AppPreview";
     export * from "connect/models/AppPreviewSet";
@@ -5725,6 +6053,7 @@ declare module "connect/index" {
     export * from "connect/models/BundleId";
     export * from "connect/models/BundleIdCapability";
     export * from "connect/models/ContentProvider";
+    export * from "connect/models/ResolutionCenterDraftMessage";
     export * from "connect/models/ResolutionCenterMessage";
     export * from "connect/models/ResolutionCenterThread";
     export * from "connect/models/ReviewRejection";