@onmyway133/asc-cli 1.0.1 → 1.0.3

package/src/commands/pricing.ts

@@ -1,22 +1,25 @@
-import { ascFetch, ascFetchAll } from "../api/client.ts"
+import {
+  appsAppPriceScheduleGetToOneRelated,
+  appPriceSchedulesCreateInstance,
+  appsAppPricePointsGetToManyRelated,
+  territoriesGetCollection,
+} from "../api/generated/sdk.gen.ts"
+import { throwOnError } from "../api/client.ts"
 import { detectFormat, formatDate, printJSON, printSuccess, printTable } from "../utils/output.ts"
 
 export async function pricingScheduleGet(appId: string, opts: { output?: string } = {}): Promise<void> {
-  // Fetch price schedule with related resources included
-  const result = await ascFetch<{
-    data: { id: string; type: string }
-    included?: Array<{ type: string; id: string; attributes?: Record<string, unknown> }>
-  }>(`/v1/apps/${appId}/appPriceSchedule`, {
-    params: {
-      include: "manualPrices,automaticPrices,baseTerritory",
-      "fields[territories]": "currency,name",
+  const result = await appsAppPriceScheduleGetToOneRelated({
+    path: { id: appId },
+    query: {
+      include: ["manualPrices", "automaticPrices", "baseTerritory"],
+      "fields[territories]": ["currency"],
     },
   })
-  const body = result.data
+  const body = throwOnError(result)
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(body); return }
   console.log(`Schedule ID:    ${body.data.id}`)
-  const included = body.included ?? []
+  const included = (body as { data: unknown; included?: Array<{ type: string; id: string; attributes?: Record<string, unknown> }> }).included ?? []
   const base = included.find(r => r.type === "territories")
   if (base) {
     const attrs = base.attributes as { currency?: string; name?: string } | undefined
@@ -40,8 +43,7 @@ export async function pricingScheduleSet(opts: {
   baseTerritory: string
   pricePointId: string
 }): Promise<void> {
-  await ascFetch("/v1/appPriceSchedules", {
-    method: "POST",
+  await appPriceSchedulesCreateInstance({
     body: {
       data: {
         type: "appPriceSchedules",
@@ -60,7 +62,7 @@ export async function pricingScheduleSet(opts: {
             appPricePoint: { data: { type: "appPricePoints", id: opts.pricePointId } },
             territory: { data: { type: "territories", id: opts.baseTerritory } },
           },
-        },
+        } as never,
       ],
     },
   })
@@ -72,39 +74,41 @@ export async function pricingPointsList(opts: {
   territory?: string
   output?: string
 }): Promise<void> {
-  const params: Record<string, string> = {
-    "fields[appPricePoints]": "customerPrice,proceeds,territory",
-    limit: "200",
+  const query: Record<string, unknown> = {
+    "fields[appPricePoints]": ["customerPrice", "proceeds", "territory"],
+    limit: 200,
   }
-  if (opts.territory) params["filter[territory]"] = opts.territory
-  const items = await ascFetchAll<{
-    id: string
-    attributes: { customerPrice?: string; proceeds?: string; territory?: unknown }
-  }>(`/v1/apps/${opts.appId}/appPricePoints`, { params })
+  if (opts.territory) query["filter[territory]"] = [opts.territory]
+
+  const result = await appsAppPricePointsGetToManyRelated({
+    path: { id: opts.appId },
+    query: query as never,
+  })
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["ID", "Customer Price", "Proceeds", "Territory"],
     items.map(p => [
       p.id,
-      p.attributes.customerPrice ?? "-",
-      p.attributes.proceeds ?? "-",
-      String(p.attributes.territory ?? "-"),
+      (p.attributes as Record<string, unknown>)?.customerPrice as string ?? "-",
+      (p.attributes as Record<string, unknown>)?.proceeds as string ?? "-",
+      String((p.attributes as Record<string, unknown>)?.territory ?? "-"),
     ]),
     `Price Points (${items.length})`,
   )
 }
 
 export async function territoriesList(opts: { output?: string } = {}): Promise<void> {
-  const items = await ascFetchAll<{
-    id: string
-    attributes: { currency?: string; name?: string }
-  }>("/v1/territories")
+  const result = await territoriesGetCollection()
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["Territory Code", "Name", "Currency"],
-    items.map(t => [t.id, t.attributes.name ?? "-", t.attributes.currency ?? "-"]),
+    items.map(t => [t.id, (t.attributes as { currency?: string })?.currency ?? "-", ""]),
     `Territories (${items.length})`,
   )
 }

package/src/commands/reports.ts

@@ -1,4 +1,8 @@
-import { ascFetch, ascFetchAll } from "../api/client.ts"
+import {
+  appsAnalyticsReportRequestsGetToManyRelated,
+  analyticsReportRequestsCreateInstance,
+} from "../api/generated/sdk.gen.ts"
+import { throwOnError } from "../api/client.ts"
 import { detectFormat, formatDate, printJSON, printTable } from "../utils/output.ts"
 
 // ---- Sales and Finance Reports ----
@@ -84,15 +88,14 @@ export async function analyticsReportsList(opts: {
   appId: string
   output?: string
 }): Promise<void> {
-  const items = await ascFetchAll<{
-    id: string
-    attributes: { name?: string; category?: string }
-  }>(`/v1/apps/${opts.appId}/analyticsReportRequests`)
+  const result = await appsAnalyticsReportRequestsGetToManyRelated({ path: { id: opts.appId } })
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["Request ID", "State"],
-    items.map(r => [r.id, String(r.attributes.name ?? r.id)]),
+    items.map(r => [r.id, String(r.attributes?.accessType ?? r.id)]),
     `Analytics Report Requests (${items.length})`,
   )
 }
@@ -101,16 +104,16 @@ export async function analyticsReportRequest(opts: {
   appId: string
   category: string
 }): Promise<void> {
-  const result = await ascFetch<{ data: { id: string } }>("/v1/analyticsReportRequests", {
-    method: "POST",
+  const result = await analyticsReportRequestsCreateInstance({
     body: {
       data: {
         type: "analyticsReportRequests",
-        attributes: { accessType: opts.category },
+        attributes: { accessType: opts.category as never },
         relationships: { app: { data: { type: "apps", id: opts.appId } } },
       },
     },
   })
-  console.log(`Analytics report request created: ${result.data.data.id}`)
+  const data = throwOnError(result)
+  console.log(`Analytics report request created: ${data.data.id}`)
   console.log("Check back later with: asc reports analytics-list --app-id <id>")
 }

package/src/commands/review-details.ts

@@ -0,0 +1,79 @@
+import {
+  appStoreVersionsAppStoreReviewDetailGetToOneRelated,
+  appStoreReviewDetailsCreateInstance,
+  appStoreReviewDetailsUpdateInstance,
+} from "../api/generated/sdk.gen.ts"
+import { throwOnError, ASCError } from "../api/client.ts"
+import { detectFormat, printJSON, printSuccess } from "../utils/output.ts"
+
+export async function reviewDetailsGet(versionId: string, output?: string): Promise<void> {
+  const result = await appStoreVersionsAppStoreReviewDetailGetToOneRelated({ path: { id: versionId } })
+  const data = throwOnError(result)
+  const d = data.data
+
+  const fmt = detectFormat(output)
+  if (fmt === "json") { printJSON({ id: d.id, ...d.attributes }); return }
+  console.log(`ID:                   ${d.id}`)
+  console.log(`Contact:              ${[d.attributes?.contactFirstName, d.attributes?.contactLastName].filter(Boolean).join(" ") || "-"}`)
+  console.log(`Contact Email:        ${d.attributes?.contactEmail ?? "-"}`)
+  console.log(`Contact Phone:        ${d.attributes?.contactPhone ?? "-"}`)
+  console.log(`Demo Account:         ${d.attributes?.demoAccountName ?? "-"}`)
+  console.log(`Demo Account Required:${d.attributes?.demoAccountRequired ? " yes" : " no"}`)
+  console.log(`Notes:                ${d.attributes?.notes ?? "-"}`)
+}
+
+export async function reviewDetailsUpdate(opts: {
+  versionId: string
+  contactFirstName?: string
+  contactLastName?: string
+  contactEmail?: string
+  contactPhone?: string
+  demoAccountName?: string
+  demoAccountPassword?: string
+  demoAccountRequired?: boolean
+  notes?: string
+}): Promise<void> {
+  // Try to get existing review detail ID
+  let existingId: string | undefined
+  try {
+    const existing = await appStoreVersionsAppStoreReviewDetailGetToOneRelated({ path: { id: opts.versionId } })
+    const data = throwOnError(existing)
+    existingId = data.data.id
+  } catch (err) {
+    if (!(err instanceof ASCError) || err.status !== 404) throw err
+  }
+
+  const attributes = {
+    contactFirstName: opts.contactFirstName,
+    contactLastName: opts.contactLastName,
+    contactEmail: opts.contactEmail,
+    contactPhone: opts.contactPhone,
+    demoAccountName: opts.demoAccountName,
+    demoAccountPassword: opts.demoAccountPassword,
+    demoAccountRequired: opts.demoAccountRequired,
+    notes: opts.notes,
+  }
+
+  if (existingId) {
+    const result = await appStoreReviewDetailsUpdateInstance({
+      path: { id: existingId },
+      body: { data: { type: "appStoreReviewDetails", id: existingId, attributes } },
+    })
+    throwOnError(result)
+    printSuccess("Review details updated")
+  } else {
+    const result = await appStoreReviewDetailsCreateInstance({
+      body: {
+        data: {
+          type: "appStoreReviewDetails",
+          attributes,
+          relationships: {
+            appStoreVersion: { data: { type: "appStoreVersions", id: opts.versionId } },
+          },
+        },
+      },
+    })
+    throwOnError(result)
+    printSuccess("Review details created")
+  }
+}

package/src/commands/review-submission.ts

@@ -0,0 +1,143 @@
+import {
+  reviewSubmissionsGetCollection,
+  reviewSubmissionsCreateInstance,
+  reviewSubmissionsGetInstance,
+  reviewSubmissionsUpdateInstance,
+  reviewSubmissionsItemsGetToManyRelated,
+  reviewSubmissionItemsCreateInstance,
+  reviewSubmissionItemsDeleteInstance,
+} from "../api/generated/sdk.gen.ts"
+import { throwOnError } from "../api/client.ts"
+import { detectFormat, formatDate, printJSON, printSuccess, printTable } from "../utils/output.ts"
+
+export async function reviewSubmissionList(opts: {
+  appId: string
+  output?: string
+}): Promise<void> {
+  const result = await reviewSubmissionsGetCollection({
+    query: { "filter[app]": [opts.appId] },
+  })
+  const data = throwOnError(result)
+  const items = data.data
+
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items.map(s => ({ id: s.id, ...s.attributes }))); return }
+  printTable(
+    ["ID", "Platform", "State", "Date"],
+    items.map(s => [
+      s.id,
+      s.attributes?.platform ?? "-",
+      s.attributes?.state ?? "-",
+      formatDate(s.attributes?.submittedDate),
+    ]),
+    `Review Submissions (${items.length})`,
+  )
+}
+
+export async function reviewSubmissionCreate(opts: {
+  appId: string
+  platform?: string
+}): Promise<void> {
+  const platform = (opts.platform ?? "IOS").toUpperCase() as "IOS" | "MAC_OS" | "TV_OS" | "VISION_OS"
+  const result = await reviewSubmissionsCreateInstance({
+    body: {
+      data: {
+        type: "reviewSubmissions",
+        attributes: { platform },
+        relationships: {
+          app: { data: { type: "apps", id: opts.appId } },
+        },
+      },
+    },
+  })
+  const data = throwOnError(result)
+  const s = data.data
+  printSuccess(`Review submission created — ID: ${s.id}`)
+  console.log(`  State:    ${s.attributes?.state ?? "-"}`)
+  console.log(`  Platform: ${platform}`)
+}
+
+export async function reviewSubmissionGet(submissionId: string, output?: string): Promise<void> {
+  const result = await reviewSubmissionsGetInstance({ path: { id: submissionId } })
+  const data = throwOnError(result)
+  const s = data.data
+
+  const fmt = detectFormat(output)
+  if (fmt === "json") { printJSON({ id: s.id, ...s.attributes }); return }
+  console.log(`ID:        ${s.id}`)
+  console.log(`Platform:  ${s.attributes?.platform ?? "-"}`)
+  console.log(`State:     ${s.attributes?.state ?? "-"}`)
+  console.log(`Date:      ${formatDate(s.attributes?.submittedDate)}`)
+}
+
+export async function reviewSubmissionSubmit(submissionId: string): Promise<void> {
+  const result = await reviewSubmissionsUpdateInstance({
+    path: { id: submissionId },
+    body: {
+      data: {
+        type: "reviewSubmissions",
+        id: submissionId,
+        attributes: { submitted: true },
+      },
+    },
+  })
+  throwOnError(result)
+  printSuccess(`Submission ${submissionId} submitted for review`)
+}
+
+export async function reviewSubmissionCancel(submissionId: string): Promise<void> {
+  const result = await reviewSubmissionsUpdateInstance({
+    path: { id: submissionId },
+    body: {
+      data: {
+        type: "reviewSubmissions",
+        id: submissionId,
+        attributes: { canceled: true },
+      },
+    },
+  })
+  throwOnError(result)
+  printSuccess(`Submission ${submissionId} cancelled`)
+}
+
+export async function reviewSubmissionItemsList(opts: {
+  submissionId: string
+  output?: string
+}): Promise<void> {
+  const result = await reviewSubmissionsItemsGetToManyRelated({ path: { id: opts.submissionId } })
+  const data = throwOnError(result)
+  const items = data.data
+
+  const fmt = detectFormat(opts.output)
+  if (fmt === "json") { printJSON(items.map(i => ({ id: i.id, ...i.attributes }))); return }
+  printTable(
+    ["Item ID", "State"],
+    items.map(i => [i.id, i.attributes?.state ?? "-"]),
+    `Submission Items (${items.length})`,
+  )
+}
+
+export async function reviewSubmissionItemAdd(opts: {
+  submissionId: string
+  appStoreVersionId: string
+}): Promise<void> {
+  const result = await reviewSubmissionItemsCreateInstance({
+    body: {
+      data: {
+        type: "reviewSubmissionItems",
+        relationships: {
+          reviewSubmission: { data: { type: "reviewSubmissions", id: opts.submissionId } },
+          appStoreVersion: { data: { type: "appStoreVersions", id: opts.appStoreVersionId } },
+        },
+      },
+    },
+  })
+  const data = throwOnError(result)
+  printSuccess(`Item added — ID: ${data.data.id}`)
+}
+
+export async function reviewSubmissionItemDelete(itemId: string): Promise<void> {
+  const result = await reviewSubmissionItemsDeleteInstance({ path: { id: itemId } })
+  throwOnError(result)
+  printSuccess(`Submission item ${itemId} removed`)
+}

package/src/commands/reviews.ts

@@ -1,20 +1,26 @@
-import { ascFetch, ascFetchAll } from "../api/client.ts"
-import type { CustomerReview, CustomerReviewResponse } from "../api/types.ts"
+import {
+  appsCustomerReviewsGetToManyRelated,
+  customerReviewsGetInstance,
+  customerReviewsResponseGetToOneRelated,
+  customerReviewResponsesCreateInstance,
+  customerReviewResponsesDeleteInstance,
+} from "../api/generated/sdk.gen.ts"
+import { throwOnError, ascFetch } from "../api/client.ts"
 import { detectFormat, formatDate, printJSON, printSuccess, printTable, truncate } from "../utils/output.ts"
 
 export async function reviewsList(opts: {
   appId: string
   output?: string
 }): Promise<void> {
-  const reviews = await ascFetchAll<CustomerReview>(
-    `/v1/apps/${opts.appId}/customerReviews`,
-    {
-      params: {
-        "fields[customerReviews]": "rating,title,body,reviewerNickname,createdDate,territory",
-        "sort": "-createdDate",
-      },
+  const result = await appsCustomerReviewsGetToManyRelated({
+    path: { id: opts.appId },
+    query: {
+      "fields[customerReviews]": ["rating", "title", "body", "reviewerNickname", "createdDate", "territory"],
+      sort: ["-createdDate"],
     },
-  )
+  })
+  const data = throwOnError(result)
+  const reviews = data.data
 
   const fmt = detectFormat(opts.output)
   if (fmt === "json") {
@@ -26,18 +32,19 @@ export async function reviewsList(opts: {
     ["ID", "Rating", "Title", "Body", "Date"],
     reviews.map((r) => [
       r.id,
-      "★".repeat(r.attributes.rating) + "☆".repeat(5 - r.attributes.rating),
-      truncate(r.attributes.title ?? "-", 30),
-      truncate(r.attributes.body ?? "-", 50),
-      formatDate(r.attributes.createdDate),
+      "★".repeat(r.attributes?.rating ?? 0) + "☆".repeat(5 - (r.attributes?.rating ?? 0)),
+      truncate(r.attributes?.title ?? "-", 30),
+      truncate(r.attributes?.body ?? "-", 50),
+      formatDate(r.attributes?.createdDate ?? ""),
     ]),
     `Reviews (${reviews.length})`,
   )
 }
 
 export async function reviewsGet(reviewId: string, opts: { output?: string } = {}): Promise<void> {
-  const res = await ascFetch<CustomerReview>(`/v1/customerReviews/${reviewId}`)
-  const r = res.data
+  const result = await customerReviewsGetInstance({ path: { id: reviewId } })
+  const data = throwOnError(result)
+  const r = data.data
 
   const fmt = detectFormat(opts.output)
   if (fmt === "json") {
@@ -46,12 +53,12 @@ export async function reviewsGet(reviewId: string, opts: { output?: string } = {
   }
 
   console.log(`ID:       ${r.id}`)
-  console.log(`Rating:   ${"★".repeat(r.attributes.rating)}${"☆".repeat(5 - r.attributes.rating)}`)
-  console.log(`Title:    ${r.attributes.title ?? "-"}`)
-  console.log(`Body:     ${r.attributes.body ?? "-"}`)
-  console.log(`Author:   ${r.attributes.reviewerNickname ?? "-"}`)
-  console.log(`Date:     ${formatDate(r.attributes.createdDate)}`)
-  console.log(`Territory:${r.attributes.territory ?? "-"}`)
+  console.log(`Rating:   ${"★".repeat(r.attributes?.rating ?? 0)}${"☆".repeat(5 - (r.attributes?.rating ?? 0))}`)
+  console.log(`Title:    ${r.attributes?.title ?? "-"}`)
+  console.log(`Body:     ${r.attributes?.body ?? "-"}`)
+  console.log(`Author:   ${r.attributes?.reviewerNickname ?? "-"}`)
+  console.log(`Date:     ${formatDate(r.attributes?.createdDate ?? "")}`)
+  console.log(`Territory:${r.attributes?.territory ?? "-"}`)
 }
 
 export async function reviewsRespond(opts: {
@@ -59,25 +66,24 @@ export async function reviewsRespond(opts: {
   message: string
 }): Promise<void> {
   // Check if a response already exists
-  const existingRes = await ascFetch<CustomerReviewResponse | null>(
-    `/v1/customerReviews/${opts.reviewId}/response`,
-  ).catch(() => null)
+  const existingRes = await customerReviewsResponseGetToOneRelated({ path: { id: opts.reviewId } }).catch(() => null)
+  const existingData = existingRes ? throwOnError(existingRes) : null
 
-  if (existingRes?.data) {
-    await ascFetch(`/v1/customerReviewResponses/${existingRes.data.id}`, {
+  if (existingData?.data) {
+    // No SDK update function for customerReviewResponses — use ascFetch for PATCH
+    await ascFetch(`/v1/customerReviewResponses/${existingData.data.id}`, {
       method: "PATCH",
       body: {
         data: {
           type: "customerReviewResponses",
-          id: existingRes.data.id,
+          id: existingData.data.id,
           attributes: { responseBody: opts.message },
         },
       },
     })
     printSuccess("Review response updated")
   } else {
-    await ascFetch("/v1/customerReviewResponses", {
-      method: "POST",
+    await customerReviewResponsesCreateInstance({
       body: {
         data: {
           type: "customerReviewResponses",

package/src/commands/screenshots.ts

@@ -1,4 +1,12 @@
-import { ascFetch, ascFetchAll } from "../api/client.ts"
+import {
+  appStoreVersionLocalizationsAppScreenshotSetsGetToManyRelated,
+  appScreenshotSetsAppScreenshotsGetToManyRelated,
+  appScreenshotsCreateInstance,
+  appScreenshotsUpdateInstance,
+  appScreenshotsDeleteInstance,
+  appStoreVersionLocalizationsAppPreviewSetsGetToManyRelated,
+} from "../api/generated/sdk.gen.ts"
+import { throwOnError } from "../api/client.ts"
 import { readFileSync } from "fs"
 import { detectFormat, printJSON, printSuccess, printTable } from "../utils/output.ts"
 
@@ -8,20 +16,17 @@ export async function screenshotSetsList(opts: {
   versionLocalizationId: string
   output?: string
 }): Promise<void> {
-  const items = await ascFetchAll<{
-    id: string
-    attributes: {
-      screenshotDisplayType?: string
-      appScreenshots?: { meta?: { total?: number } }
-    }
-  }>(`/v1/appStoreVersionLocalizations/${opts.versionLocalizationId}/appScreenshotSets`, {
-    params: { "fields[appScreenshotSets]": "screenshotDisplayType,appScreenshots" },
+  const result = await appStoreVersionLocalizationsAppScreenshotSetsGetToManyRelated({
+    path: { id: opts.versionLocalizationId },
+    query: { "fields[appScreenshotSets]": ["screenshotDisplayType", "appScreenshots"] },
   })
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["Set ID", "Display Type"],
-    items.map(s => [s.id, s.attributes.screenshotDisplayType ?? "-"]),
+    items.map(s => [s.id, s.attributes?.screenshotDisplayType ?? "-"]),
     `Screenshot Sets (${items.length})`,
   )
 }
@@ -30,24 +35,19 @@ export async function screenshotsList(opts: {
   setId: string
   output?: string
 }): Promise<void> {
-  const items = await ascFetchAll<{
-    id: string
-    attributes: {
-      fileName?: string
-      fileSize?: number
-      sourceFileChecksum?: string
-      assetDeliveryState?: { state?: string }
-      imageAsset?: { templateUrl?: string; width?: number; height?: number }
-    }
-  }>(`/v1/appScreenshotSets/${opts.setId}/appScreenshots`)
+  const result = await appScreenshotSetsAppScreenshotsGetToManyRelated({
+    path: { id: opts.setId },
+  })
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["ID", "File Name", "State"],
     items.map(s => [
       s.id,
-      s.attributes.fileName ?? "-",
-      s.attributes.assetDeliveryState?.state ?? "-",
+      s.attributes?.fileName ?? "-",
+      s.attributes?.assetDeliveryState?.state ?? "-",
     ]),
     `Screenshots (${items.length})`,
   )
@@ -62,21 +62,7 @@ export async function screenshotCreate(opts: {
   const fileSize = fileData.length
 
   // Step 1: Reserve asset
-  const reserve = await ascFetch<{
-    data: {
-      id: string
-      attributes: {
-        uploadOperations?: Array<{
-          url: string
-          method: string
-          offset: number
-          length: number
-          requestHeaders?: Array<{ name: string; value: string }>
-        }>
-      }
-    }
-  }>("/v1/appScreenshots", {
-    method: "POST",
+  const reserve = await appScreenshotsCreateInstance({
     body: {
       data: {
         type: "appScreenshots",
@@ -87,21 +73,23 @@ export async function screenshotCreate(opts: {
       },
     },
   })
-
-  const screenshotId = reserve.data.data.id
-  const uploads = reserve.data.data.attributes.uploadOperations ?? []
+  const reserveData = throwOnError(reserve)
+  const screenshotId = reserveData.data.id
+  const uploads = reserveData.data.attributes?.uploadOperations ?? []
 
   // Step 2: Upload parts
   for (const op of uploads) {
-    const chunk = fileData.subarray(op.offset, op.offset + op.length)
+    const chunk = fileData.subarray(op.offset ?? 0, (op.offset ?? 0) + (op.length ?? 0))
     const headers: Record<string, string> = { "Content-Type": "image/png" }
-    for (const h of op.requestHeaders ?? []) headers[h.name] = h.value
-    await fetch(op.url, { method: op.method, headers, body: chunk })
+    for (const h of op.requestHeaders ?? []) {
+      if (h.name && h.value) headers[h.name] = h.value
+    }
+    await fetch(op.url ?? "", { method: op.method ?? "PUT", headers, body: chunk })
   }
 
   // Step 3: Commit
-  await ascFetch(`/v1/appScreenshots/${screenshotId}`, {
-    method: "PATCH",
+  await appScreenshotsUpdateInstance({
+    path: { id: screenshotId },
     body: {
       data: {
         type: "appScreenshots",
@@ -115,7 +103,7 @@ export async function screenshotCreate(opts: {
 }
 
 export async function screenshotDelete(screenshotId: string): Promise<void> {
-  await ascFetch(`/v1/appScreenshots/${screenshotId}`, { method: "DELETE" })
+  await appScreenshotsDeleteInstance({ path: { id: screenshotId } })
   printSuccess(`Screenshot ${screenshotId} deleted`)
 }
 
@@ -125,15 +113,16 @@ export async function previewSetsList(opts: {
   versionLocalizationId: string
   output?: string
 }): Promise<void> {
-  const items = await ascFetchAll<{
-    id: string
-    attributes: { previewType?: string }
-  }>(`/v1/appStoreVersionLocalizations/${opts.versionLocalizationId}/appPreviewSets`)
+  const result = await appStoreVersionLocalizationsAppPreviewSetsGetToManyRelated({
+    path: { id: opts.versionLocalizationId },
+  })
+  const data = throwOnError(result)
+  const items = data.data
   const fmt = detectFormat(opts.output)
   if (fmt === "json") { printJSON(items); return }
   printTable(
     ["Set ID", "Preview Type"],
-    items.map(s => [s.id, s.attributes.previewType ?? "-"]),
+    items.map(s => [s.id, s.attributes?.previewType ?? "-"]),
     `Preview Sets (${items.length})`,
   )
 }