@billkit-eu/sdk 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -10,6 +10,37 @@ so the numbers will diverge after this first release.
 
 ## [Unreleased]
 
+### Added
+- `client.prices.update(id, { active: false })` archives a price
+  (`POST /v1/prices/{id}`). The price keeps its id and stays readable through
+  `retrieve()` and `list()`, because subscriptions renew against it by id.
+  Subscriptions already on it keep renewing; what stops is new business.
+  Re-archiving is a no-op that returns the price unchanged, so a retry is safe.
+  `active` is the only field a price accepts and `active: true` is refused,
+  because prices are immutable.
+- `client.subscriptions.list()` and `.iter()` now take `customer_id`, `status`
+  and `renewal_state` through the new `SubscriptionsListParams`, and `iter()`
+  carries the filter onto every page request instead of narrowing client-side.
+  Both filters take a comma-separated list.
+
+### Removed
+- `delete()` on `products`, `prices`, `coupons`, `taxRates` and
+  `webhookEndpoints`. None of them deleted anything: every one of those rows
+  stays readable afterwards, which is why they have to. Retire them through the
+  update route instead — `active: false` for products, prices, tax rates and
+  coupons, `status: "disabled"` for webhook endpoints. The server no longer
+  answers `DELETE` on those paths at all.
+
+### Changed
+- `client.customers.delete(id)` resolves to `{ id, object: "customer", deleted:
+  true }` instead of the customer. The customer leaves the API, so returning a
+  body that reads like a live resource said the opposite of what happened.
+- `renewal_state: "paused"` is the way to find paused subscriptions.
+  `status: "paused"` is no longer accepted by the API and now raises
+  `InvalidRequestError`: pausing sets `renewal_state` and leaves `status` at
+  `active`, because the customer has paid for the period they are in. The README
+  documents the split between the two filters.
+
 ## [0.1.0]
 
 First public release.

package/README.md

@@ -93,25 +93,83 @@ The client exposes one accessor per resource family. Each mirrors the verbs from
 | Accessor | Verbs |
 | --- | --- |
 | `client.customers` | `create`, `retrieve`, `update`, `delete`, `list`, `iter` |
-| `client.products` | `create`, `retrieve`, `update`, `delete`, `list`, `iter` |
-| `client.prices` | `create`, `retrieve`, `list`, `iter` |
+| `client.products` | `create`, `retrieve`, `update` (archive with `active: false`), `list`, `iter` |
+| `client.prices` | `create`, `retrieve`, `update` (archive with `active: false`, restore with `active: true`), `list`, `iter` |
 | `client.checkoutSessions` | `create`, `retrieve` |
 | `client.oneShotPayments` | `create`, `retrieve` |
-| `client.subscriptions` | `retrieve`, `list`, `iter`, `cancel`, `pause`, `resume`, `previewUpdate`, `update`, `reauthorizePaymentMethod` |
+| `client.subscriptions` | `retrieve`, `list`, `iter` (filter by `customer_id`, `status`, `renewal_state`), `cancel`, `pause`, `resume`, `previewUpdate`, `update`, `reauthorizePaymentMethod` |
 | `client.refunds` | `create`, `retrieve`, `list`, `iter` |
-| `client.webhookEndpoints` | `create`, `retrieve`, `update`, `delete`, `rotateSecret`, `list`, `iter`, `listDeliveries`, `iterDeliveries`, `getDelivery`, `redeliver` |
+| `client.webhookEndpoints` | `create`, `retrieve`, `update` (stop delivery with `status: "disabled"`), `delete`, `rotateSecret`, `list`, `iter`, `listDeliveries`, `iterDeliveries`, `getDelivery`, `redeliver` |
 | `client.events` | `retrieve`, `list`, `iter` (filter by `type`) |
 | `client.tenant` | `capabilities`, `portalBranding`, `setPortalBranding`, `rotateProviderCredential` |
-| `client.coupons` | `create`, `retrieve`, `update`, `delete`, `validate`, `list`, `iter` |
-| `client.taxRates` | `create`, `retrieve`, `update`, `delete`, `list`, `iter` |
-| `client.invoices` | `retrieve`, `list`, `iter` |
+| `client.coupons` | `create`, `retrieve`, `update` (withdraw with `active: false`), `validate`, `list`, `iter` |
+| `client.taxRates` | `create`, `retrieve`, `update` (retire with `active: false`), `list`, `iter` |
+| `client.invoices` | `retrieve`, `retrievePdf`, `list`, `iter` |
 | `client.auditLogs` | `retrieve`, `list`, `iter` (filter by `action`, `resource_type`, `actor_id`) |
 | `client.payments` | `retrieve`, `list`, `iter` |
 | `client.billingPortalSessions` | `create`, `revoke` |
 
+### Retiring something, and deleting something
+
+`delete()` exists on `customers` and `webhookEndpoints`, and it resolves to `{ id, object, deleted: true }` rather than the object: it has left the API, so there is nothing to hand back. A deleted endpoint takes its delivery rows with it, because those are readable only through the endpoint that owns them; the events stay in `client.events`, which is the record of what you were sent.
+
+The catalogue is retired through its update route instead, because it stays readable afterwards. A price, a product, a tax rate and a coupon each take `active: false`. Each of them has to survive: subscriptions renew against a price by id, an invoice records the VAT percentage a tax rate produced, and a redeemed coupon is part of what a customer was charged.
+
+`status: "disabled"` on a webhook endpoint is the other half of the pair, not a substitute for deleting. It stops delivery and keeps the endpoint, its secret and its history, and it can be turned back on.
+
+```ts
+// Stop selling a price. It stays readable; customers on it keep renewing.
+await client.prices.update(price.id, { active: false });
+// ...and put it back. The amount never moved.
+await client.prices.update(price.id, { active: true });
+
+// Stop sending to an endpoint, without losing its signing secret.
+await client.webhookEndpoints.update(endpoint.id, { status: "disabled" });
+// Remove one entirely, along with its delivery rows.
+await client.webhookEndpoints.delete(endpoint.id); // → { deleted: true, ... }
+
+// Remove a customer. Refused while they hold a subscription that can
+// still charge them.
+await client.customers.delete(customer.id); // → { deleted: true, ... }
+```
+
+### Finding paused subscriptions
+
+`status` and `renewal_state` answer different questions, and only one of them knows about pausing. `status` is where the subscription stands with its payments (`incomplete`, `trialing`, `active`, `past_due`, `canceled`). `renewal_state` is what happens when the current period ends (`auto_renew`, `paused`, `canceling`, `stopped`). Pausing sets `renewal_state` and leaves `status` at `active`, because the customer has paid for the period they are in:
+
+```ts
+const paused = await client.subscriptions.list({ renewal_state: "paused" });
+```
+
+`status: "paused"` is not an accepted value and comes back as `InvalidRequestError`. Both filters take a comma-separated list (`status: "active,past_due"`), and an unrecognised value is rejected rather than silently ignored.
+
+### Embedded checkout
+
+Pass `ui_mode: "embedded"` and the session comes back with a `client_secret` instead of a `url`. Hand that to [`@billkit-eu/js`](https://www.npmjs.com/package/@billkit-eu/js) or [`@billkit-eu/react`](https://www.npmjs.com/package/@billkit-eu/react) and the card fields render on your own page, inside a cross-origin iframe. `cancel_url` is still required.
+
+```ts
+const session = await client.checkoutSessions.create<{ client_secret: string }>({
+  customer_id: customer.id,
+  price_id: price.id,
+  ui_mode: "embedded",
+  success_url: "https://app.example.com/success",
+  cancel_url: "https://app.example.com/cancel",
+  metadata: { order_id: "ord_42" },
+});
+```
+
+### Invoice PDFs
+
+```ts
+const pdf = await client.invoices.retrievePdf("inv_123");
+await writeFile("invoice.pdf", Buffer.from(pdf));
+```
+
+Returns the raw bytes. S3-backed deployments answer with a redirect to a presigned URL, which is followed transparently under the SDK's own timeout and retry policy, so both storage adapters look the same from here. A deployment with PDF rendering disabled throws a `ServerError` with `code: "rendering_pending"`; `retrieve()` still gives you the structured invoice to render yourself.
+
 ## Auto-pagination
 
-Every list-returning resource ships an `iter()` async iterator that walks the Stripe-shape `has_more` + `starting_after` cursor protocol for you. No more manual cursor loops:
+Every list-returning resource ships an `iter()` async iterator that walks the Stripe-shape `has_more` + `starting_after` cursor protocol for you. Pagination is forward-only — BillKit has no `ending_before` — so page backwards by holding onto the cursors you have already walked.
 
 ```ts
 for await (const customer of client.customers.iter()) {
@@ -153,6 +211,8 @@ const client = new BillKit({
 
 The SDK auto-generates an `Idempotency-Key` for every mutating call, so 5xx and short `Retry-After` 429 retries are safe: the server replays the original response when an earlier attempt completed. Pass `idempotencyKey` to coalesce retries across process restarts.
 
+`409 idempotency_in_progress` is retried too. It means an earlier request carrying the same key is still in flight, which is the one 4xx where giving up is the dangerous answer: that request may already have charged the customer, and the obvious workaround — retry with a *fresh* key — is exactly what turns one charge into two. The retry reuses the original key, so it either loses the race again or replays the first call's result. Every other 409 (`idempotency_key_in_use`, a conflicting subscription state) fails immediately, because retrying can only repeat it.
+
 ## Errors
 
 ```ts
@@ -180,6 +240,20 @@ try {
 
 All errors inherit from `BillKitError`. Subclasses: `APIConnectionError`, `APIError`, `ServerError`, `AuthenticationError`, `PermissionError`, `ResourceMissingError`, `InvalidRequestError`, `ConflictError`, `RateLimitError`.
 
+The class is chosen by **HTTP status**, not by the envelope's `type`:
+
+| Status | Class |
+|---|---|
+| 401 | `AuthenticationError` |
+| 403 | `PermissionError` |
+| 404 | `ResourceMissingError` |
+| 409 | `ConflictError` |
+| 429 | `RateLimitError` |
+| other 4xx (400, 405, 422, …) | `InvalidRequestError` |
+| 5xx | `ServerError` |
+
+The status is the field the API cannot get wrong. Requests that never reach a route handler — an unmatched path, a method the route does not allow — are serialised by the framework as `{"type": "api_error", "code": "unhandled"}` *with a 4xx status*, so mapping on `type` would turn a plain 404 into a `ServerError` and tell you BillKit had broken when the request was at fault. The envelope's `type`, `code` and `param` are all still on the thrown object if you want them.
+
 ## Logging
 
 The SDK is **silent by default**. It ships no logger, no transport and no destination, so it can't take over your application's output because it never picks one. Hand it a logger to opt in:

package/dist/index.cjs

@@ -87,6 +87,16 @@ var Customers = class extends BaseResource {
   update(id, params = {}) {
     return this.post(`/v1/customers/${id}`, params);
   }
+  /**
+   * Delete a customer. Resolves to `{ id, object: "customer", deleted:
+   * true }`, not the customer.
+   *
+   * The customer leaves the API: `retrieve()` 404s and they drop out of
+   * `list()`. Their payments, invoices and refunds are untouched, and so
+   * is their personal data — use {@link Customers.purge} for a GDPR
+   * erasure. Refused while they hold a subscription that can still
+   * charge them.
+   */
   delete(id, params = {}) {
     return this.del(`/v1/customers/${id}`, params);
   }
@@ -126,14 +136,18 @@ var Products = class extends BaseResource {
   retrieve(id) {
     return this.get(`/v1/products/${id}`);
   }
-  /** Patch mutable Product fields. */
+  /**
+   * Patch mutable Product fields, or archive it with `active: false`.
+   *
+   * Archiving is how you stop offering something. The product keeps its
+   * id and still comes back from `retrieve()` and `list()`, because what
+   * was sold under it has to stay readable, so there is no `delete()`.
+   * A checkout against any of its prices is refused from then on, and
+   * `active: true` un-archives.
+   */
   update(id, params) {
     return this.post(`/v1/products/${id}`, params);
   }
-  /** Archive a Product. */
-  delete(id, params = {}) {
-    return this.del(`/v1/products/${id}`, params);
-  }
   list(params = {}) {
     return this.get("/v1/products", params);
   }
@@ -149,6 +163,29 @@ var Prices = class extends BaseResource {
   retrieve(id) {
     return this.get(`/v1/prices/${id}`);
   }
+  /**
+   * Archive a Price so it stops selling, or put it back on sale.
+   *
+   * `update(id, { active: false })` archives. The price keeps its id and
+   * is still returned by `retrieve()` and by `list()`, because
+   * subscriptions renew against it by id and what they are charged has to
+   * stay readable. Subscriptions already on it keep renewing at it. What
+   * stops is new business: a checkout session against the price is
+   * refused and it is no longer offered as a plan change.
+   *
+   * `{ active: true }` undoes that. `active` is the only field because
+   * `amount_cents`, `currency` and `interval` are fixed at creation, and
+   * since none of them move here neither direction can change what a past
+   * charge was made under. To charge something different, create a new
+   * price.
+   *
+   * Sending the value a price already has returns it unchanged and emits
+   * no second event, so a retry is safe. Archiving emits
+   * `price.archived`; putting one back emits `price.updated`.
+   */
+  update(id, params) {
+    return this.post(`/v1/prices/${id}`, params);
+  }
   list(params = {}) {
     return this.get("/v1/prices", params);
   }
@@ -180,11 +217,23 @@ var Subscriptions = class extends BaseResource {
   retrieve(id) {
     return this.get(`/v1/subscriptions/${id}`);
   }
+  /**
+   * List subscriptions, newest first, optionally filtered.
+   *
+   * Reach for `renewal_state: "paused"` rather than `status: "paused"`
+   * to find paused subscriptions; see `SubscriptionsListParams`.
+   */
   list(params = {}) {
     return this.get("/v1/subscriptions", params);
   }
+  /**
+   * Walk every page of `list()`. Filters are carried onto each page
+   * request, so a filtered walk narrows server-side instead of paging
+   * the whole history and discarding rows client-side.
+   */
   iter(options = {}) {
-    return paginate((p) => this.get("/v1/subscriptions", p), { pageSize: options.pageSize });
+    const { pageSize, ...filter } = options;
+    return paginate((p) => this.get("/v1/subscriptions", { ...filter, ...p }), { pageSize });
   }
   cancel(id, params = {}) {
     return this.postEmpty(`/v1/subscriptions/${id}/cancel`, params);
@@ -225,6 +274,39 @@ var Subscriptions = class extends BaseResource {
       { idempotencyKey: params.idempotencyKey }
     );
   }
+  /**
+   * Report consumption against a metered subscription.
+   *
+   * Only valid when the subscription's price is `usage_type:
+   * "metered"`; a licensed subscription is rejected with `400
+   * parameter_invalid`. Records accumulate until the renewal invoice
+   * rolls them up (`amount_cents × sum(quantity)`); the record's
+   * `invoice_id` stays `null` until then.
+   *
+   * Supports `Idempotency-Key` replay: retrying with the same key
+   * returns the same record instead of double-counting the usage,
+   * which is what makes at-least-once reporting pipelines safe.
+   */
+  createUsageRecord(id, params) {
+    return this.post(`/v1/subscriptions/${id}/usage_records`, params);
+  }
+  /**
+   * List usage records for one subscription.
+   *
+   * Pass `invoice_id: "pending"` to reconcile what has been reported
+   * but not yet billed, or a concrete invoice id to see what that
+   * invoice charged for.
+   */
+  listUsageRecords(id, params = {}) {
+    return this.get(`/v1/subscriptions/${id}/usage_records`, params);
+  }
+  /** Walk every page of `listUsageRecords()` for one subscription. */
+  iterUsageRecords(id, options = {}) {
+    return paginate((p) => this.get(`/v1/subscriptions/${id}/usage_records`, p), {
+      pageSize: options.pageSize,
+      filters: { invoice_id: options.invoice_id }
+    });
+  }
 };
 var Refunds = class extends BaseResource {
   create(params) {
@@ -258,9 +340,28 @@ var WebhookEndpoints = class extends BaseResource {
   retrieve(id) {
     return this.get(`/v1/webhook_endpoints/${id}`);
   }
+  /**
+   * Update an endpoint, or stop delivery with `status: "disabled"`.
+   *
+   * Disabling keeps the endpoint, its signing secret and its delivery
+   * history, and `status: "enabled"` resumes. Use {@link
+   * WebhookEndpoints.delete} when the endpoint should not exist at all:
+   * disabling is reversible and deleting is not.
+   */
   update(id, params) {
     return this.post(`/v1/webhook_endpoints/${id}`, params);
   }
+  /**
+   * Delete an endpoint. Resolves to `{ id, object: "webhook_endpoint",
+   * deleted: true }`, not the endpoint.
+   *
+   * A URL registered by mistake should not be a permanent fixture of the
+   * account, so this removes it: `retrieve()` 404s afterwards and it is
+   * gone from `list()`. Its delivery attempts go with it, because they
+   * are readable only through the endpoint that owns them. The events
+   * themselves are untouched and still in `client.events`, so what you
+   * were sent stays on record.
+   */
   delete(id, params = {}) {
     return this.del(`/v1/webhook_endpoints/${id}`, params);
   }
@@ -369,12 +470,17 @@ var Coupons = class extends BaseResource {
   retrieve(id) {
     return this.get(`/v1/coupons/${id}`);
   }
+  /**
+   * Update a coupon's limits, or withdraw it with `active: false`.
+   *
+   * A withdrawn code is refused at checkout while the coupon stays
+   * readable and discounts already applied keep working out, so there is
+   * no `delete()`: a coupon that has been redeemed is part of what a
+   * customer was charged. `active: true` brings the campaign back.
+   */
   update(id, params) {
     return this.post(`/v1/coupons/${id}`, params);
   }
-  delete(id, params = {}) {
-    return this.del(`/v1/coupons/${id}`, params);
-  }
   /**
    * Server-side dry-run of a coupon redemption.
    *
@@ -401,12 +507,17 @@ var TaxRates = class extends BaseResource {
   retrieve(id) {
     return this.get(`/v1/tax_rates/${id}`);
   }
+  /**
+   * Correct a rate, retire it with `active: false`, or bring one back.
+   *
+   * Retiring is how you stop charging VAT in a country. The rate stays
+   * readable, because an invoice records the percentage it charged and
+   * you have to be able to point at the rate that produced it, so there
+   * is no `delete()`.
+   */
   update(id, params) {
     return this.post(`/v1/tax_rates/${id}`, params);
   }
-  delete(id, params = {}) {
-    return this.del(`/v1/tax_rates/${id}`, params);
-  }
   list(params = {}) {
     return this.get("/v1/tax_rates", params);
   }
@@ -418,6 +529,27 @@ var Invoices = class extends BaseResource {
   retrieve(id) {
     return this.get(`/v1/invoices/${id}`);
   }
+  /**
+   * Download the rendered invoice PDF as raw bytes.
+   *
+   * ```ts
+   * const pdf = await client.invoices.retrievePdf("inv_123");
+   * await writeFile("invoice.pdf", Buffer.from(pdf));
+   * ```
+   *
+   * Blob-backed deployments stream the bytes inline; S3-backed ones
+   * answer `302` to a presigned URL, which `fetch` follows for us under
+   * the SDK's own timeout and retry policy — so both storage adapters
+   * look identical from here.
+   *
+   * Deployments with `INVOICE_PDF_ENABLED=false` never render one and
+   * answer `501 rendering_pending`, which surfaces as a `ServerError`
+   * whose `code` is `"rendering_pending"`; `retrieve()` still returns the
+   * structured invoice for tenants who render their own.
+   */
+  retrievePdf(id) {
+    return this.t.requestBinary({ method: "GET", path: `/v1/invoices/${id}/pdf` });
+  }
   list(params = {}) {
     return this.get("/v1/invoices", params);
   }
@@ -523,19 +655,6 @@ var RateLimitError = class extends BillKitError {
     this.retryAfter = options.retryAfter;
   }
 };
-var TYPE_TO_CLASS = {
-  api_connection_error: APIConnectionError,
-  // ``api_error`` is the Stripe-convention type for 5xx, so surface it as
-  // ServerError (a subclass of APIError) so `catch (e instanceof
-  // ServerError)` works without false negatives.
-  api_error: ServerError,
-  authentication_error: AuthenticationError,
-  permission_error: PermissionError,
-  invalid_request_error: InvalidRequestError,
-  idempotency_error: ConflictError,
-  conflict: ConflictError,
-  rate_limit_error: RateLimitError
-};
 function fallbackType(status) {
   if (status === 401) return "authentication_error";
   if (status === 403) return "permission_error";
@@ -545,13 +664,13 @@ function fallbackType(status) {
   if (status >= 500) return "api_error";
   return "invalid_request_error";
 }
-function fallbackClass(status) {
+function classForStatus(status) {
+  if (status >= 500) return ServerError;
   if (status === 401) return AuthenticationError;
   if (status === 403) return PermissionError;
   if (status === 404) return ResourceMissingError;
   if (status === 409) return ConflictError;
   if (status === 429) return RateLimitError;
-  if (status >= 500) return ServerError;
   return InvalidRequestError;
 }
 function errorFromResponse(args) {
@@ -559,9 +678,7 @@ function errorFromResponse(args) {
   const envelope = typeof body === "object" && body !== null && "error" in body ? body.error ?? {} : {};
   const type = envelope.type ?? fallbackType(status);
   const message = envelope.message ?? `BillKit API returned HTTP ${status} with no error body.`;
-  let cls = TYPE_TO_CLASS[type] ?? fallbackClass(status);
-  if (status === 404 && cls === InvalidRequestError) cls = ResourceMissingError;
-  if (status === 409 && cls === InvalidRequestError) cls = ConflictError;
+  const cls = classForStatus(status);
   const options = {
     type,
     code: envelope.code,
@@ -600,9 +717,11 @@ function backoffForMs(attempt, policy) {
   const jittered = capped + (Math.random() * 2 - 1) * jitterRange;
   return Math.max(0, jittered);
 }
-function shouldRetry(status, attempt, policy, retryAfterMs) {
+var IN_PROGRESS_CODE = "idempotency_in_progress";
+function shouldRetry(status, attempt, policy, retryAfterMs, errorCode) {
   if (attempt >= policy.maxAttempts) return false;
   if (status === null) return true;
+  if (status === 409) return errorCode === IN_PROGRESS_CODE;
   if (status === 429) {
     if (retryAfterMs === void 0 || retryAfterMs < 0) return false;
     return policy.maxRetryAfterMs === void 0 || retryAfterMs <= policy.maxRetryAfterMs;
@@ -614,7 +733,7 @@ function sleep(ms) {
 }
 
 // src/version.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 
 // src/transport.ts
 var DEFAULT_BASE_URL = "https://api.billkit.eu";
@@ -664,8 +783,7 @@ function buildHeaders(apiKey, hasBody, idempotencyKey, extra) {
   }
   return headers;
 }
-async function parseJson(response) {
-  const text = await response.text();
+function parseJsonText(text) {
   if (!text) return null;
   try {
     return JSON.parse(text);
@@ -673,6 +791,17 @@ async function parseJson(response) {
     return null;
   }
 }
+async function parseJson(response) {
+  return parseJsonText(await response.text());
+}
+async function readBody(response, responseType) {
+  if (responseType !== "binary") {
+    return { parsed: await parseJson(response), binary: void 0 };
+  }
+  const buffer = await response.arrayBuffer();
+  if (response.ok) return { parsed: null, binary: buffer };
+  return { parsed: parseJsonText(new TextDecoder().decode(buffer)), binary: void 0 };
+}
 function parseRetryAfterMs(header) {
   if (!header) return void 0;
   const n = Number.parseFloat(header);
@@ -716,7 +845,21 @@ var Transport = class {
     }
     this.fetchFn = fetchFn.bind(globalThis);
   }
+  /**
+   * Fetch a binary document (currently only the invoice PDF).
+   *
+   * Same retry policy, same timeout, same typed errors as
+   * {@link Transport.request}; only the success-path decoding differs.
+   * `fetch` follows the storage adapter's `302` to the signed URL by
+   * itself, and the WHATWG spec drops the `Authorization` header on that
+   * cross-origin hop — which is correct, since a presigned URL carries
+   * its own credential and must not be handed BillKit's API key.
+   */
+  requestBinary(options) {
+    return this.request({ ...options, responseType: "binary" });
+  }
   async request(options) {
+    const responseType = options.responseType ?? "json";
     const idempotencyKey = autoIdempotencyKey(options.method, options.idempotencyKey);
     const url = buildUrl(this.baseUrl, options.path, options.query);
     const headers = buildHeaders(
@@ -738,6 +881,7 @@ var Transport = class {
       const startedAt = Date.now();
       let response;
       let parsedBody;
+      let binaryBody;
       try {
         const init = {
           method: options.method,
@@ -746,7 +890,7 @@ var Transport = class {
         };
         if (body !== void 0) init.body = body;
         response = await this.fetchFn(url, init);
-        parsedBody = await parseJson(response);
+        ({ parsed: parsedBody, binary: binaryBody } = await readBody(response, responseType));
       } catch (err) {
         lastError = connectionError(err, this.timeoutMs);
         if (!shouldRetry(null, attempt, this.retryPolicy)) throw lastError;
@@ -770,6 +914,7 @@ var Transport = class {
         requestId: requestId ?? null
       });
       if (response.ok) {
+        if (responseType === "binary") return binaryBody;
         return parsedBody ?? void 0;
       }
       const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"));
@@ -779,7 +924,7 @@ var Transport = class {
         requestId,
         retryAfter: retryAfterMs === void 0 ? void 0 : retryAfterMs / 1e3
       });
-      if (!shouldRetry(response.status, attempt, this.retryPolicy, retryAfterMs)) {
+      if (!shouldRetry(response.status, attempt, this.retryPolicy, retryAfterMs, error.code)) {
         throw error;
       }
       lastError = error;