@rewloy/node 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -5,6 +5,63 @@ https://rewloy.com/gelistiriciler/degisiklikler
 
 This library's releases. The API's own changes are listed at the link above.
 
+## 0.2.2 (2026-10-05)
+
+Rewloy 1.1.0'a (API sürümü) göre yeniden üretildi: 256 işlem (0.2.1'de 255). Kasa
+için `reverseAction`, `recordSale`'de `occurredAt`, `passAction`'da `reference`;
+yanıtlarda `RateLimit-*` başlıkları.
+
+Regenerated from Rewloy 1.1.0 (the product version in `info.version`): 256
+operations (255 in 0.2.1).
+
+- **New operation: `reverseAction`** (`POST /v1/passes/{serial}/actions/reverse`).
+  Voids a till action made with `passAction` (`spend`, `spend-points`,
+  `redeem-stamps`, `redeem-reward`, `use`), found by its `actionKey` (the
+  `Idempotency-Key` it was sent with) or its `reference`. It needs no
+  `Idempotency-Key`: an action is voided once and a repeat answers
+  `duplicate: true`. New error codes `ACTION_NOT_FOUND`, `ACTION_AMBIGUOUS`,
+  `ACTION_NOT_REVERSIBLE`.
+- **`recordSale` takes an optional `occurredAt`**: when the sale really happened
+  (ISO 8601 with offset), for a till that queues sales while offline.
+- **`passAction` takes an optional `reference`**, and its answer is now a union
+  type: the balance-card answer (`balance`, `detail`, `promotion`) or the coupon /
+  discount-card answer (`status`, `uses`, `usesLeft`). Narrow with `'uses' in r`.
+- **Rate limit headers.** `ApiResponse.rateLimit` (`{ limit, remaining, reset }`,
+  from `RateLimit-Limit`, `RateLimit-Remaining`, `RateLimit-Reset`; `null` when the
+  answer has none) and `RewloyError.rateLimit` (including `RateLimitError`).
+  `parseRateLimit(headers)` is exported. Additive.
+- Webhook-creation responses may carry `warnings` (a non-live installation whose
+  URL production would refuse); the `Idempotency-Key` parameter documents its
+  8–64 printable ASCII rule; the API's descriptions no longer contain internal
+  `ADR n` references. README: the till example has a void step and a note on
+  `occurredAt` for offline queues.
+
+## 0.2.1 (2026-10-05)
+
+Dışarıdan geliştiricilerin bulduğu üç sorun düzeltildi.
+
+Three problems found by outside developers, fixed.
+
+- **`Idempotency-Key` is checked before sending.** A key with non-ASCII
+  characters (`fiş-0042`) made `fetch` throw a bare `TypeError` about the header
+  value. Now the client refuses any key that is not printable ASCII
+  (0x21–0x7E), 8–64 characters, with a clear `TypeError` ("Idempotency-Key
+  yalnız ASCII karakterler içerebilir …") and sends nothing. The API will also
+  answer `400 VALIDATION` for such a key in its next release.
+- **`baseUrl` takes the address with or without `/v1`.** The documentation and
+  the OpenAPI document show `https://app.rewloy.com/v1`; the client wanted the
+  origin only. Now both work; a trailing `/v1` or `/v1/` and trailing slashes
+  are stripped (`rewloy.baseUrl` is the origin).
+- **`idempotencyKey` is required where the API requires it.** For `recordSale`,
+  `passAction`, `sendCampaign` and `refundShopRedemption` the OpenAPI document
+  marks the header required, but the client made up a random UUID when it was
+  missing, which does not survive a restart of your app. `idempotencyKey` is now
+  a required argument of those methods (a type error in TypeScript, a
+  `TypeError` before sending in JavaScript). Where the header is optional
+  (`issuePass`, …) a UUID is still generated and reused on every retry.
+  **Breaking for callers that relied on the generated key** (a small break,
+  taken in a patch release because the old behaviour could write a sale twice).
+
 ## 0.2.0 (2026-10-05)
 
 Rewloy API 1.0.5'e göre yeniden üretildi: 255 işlem (0.1.0'da 237). Kasa için

package/README.md

@@ -52,7 +52,7 @@ işlemin gerektirdikleriyle:
 - `query`: sorgu parametreleri;
 - `body`: JSON gövde;
 - `merchant`: `Rewloy-Merchant` başlığı;
-- `idempotencyKey`: `Idempotency-Key` başlığı (satış, kasa işlemi ve kampanya);
+- `idempotencyKey`: `Idempotency-Key` başlığı (satış, kasa işlemi, kampanya ve mağaza iadesinde zorunlu);
 - `signal`, `timeoutMs`, `maxRetries`.
 
 Metot yanıttaki `data`yı döndürür. Sayfalı listelerde `{ data, meta }`,
@@ -86,7 +86,7 @@ Bir işlem istemcinin kimlik türünü kabul etmiyor ama kimliksiz de çalışı
 bir kimliği reddeder (`CREDENTIAL_NOT_ALLOWED`).
 
 Diğer seçenekler:
-- `baseUrl` (varsayılan `https://app.rewloy.com`; `/v1` olmadan, kütüphane ekler);
+- `baseUrl` (varsayılan `https://app.rewloy.com`; sonuna `/v1` eklemeniz ya da eklememeniz fark etmez: `https://app.rewloy.com/v1` de olur, kütüphane `/v1`i kendisi ekler);
 - `timeoutMs` (60000);
 - `maxRetries` (2);
 - `fetch`: kendi `fetch`iniz;
@@ -100,7 +100,7 @@ API'nin başka bir kopyasına (kendi staging ortamınız ya da bir vekil sunucu)
 ```ts
 const rewloy = new Rewloy({
   apiKey: process.env.REWLOY_API_KEY!,
-  baseUrl: 'https://rewloy-staging.ornek.com',   // /v1 olmadan
+  baseUrl: 'https://rewloy-staging.ornek.com',   // sonuna /v1 yazsanız da olur
 });
 ```
 
@@ -120,6 +120,15 @@ const sonuc = await rewloy.passAction({
   idempotencyKey: `kasa3-z0187-fis${fisNo}`,   // aşağıya bakın
 });
 if (sonuc.duplicate) console.log('Bu işlem zaten yazılmış');
+
+// Yanlışlıkla bir harcama mı yapıldı? Yaparken gönderdiğiniz anahtarla geri alın:
+await rewloy.passAction({
+  params: { serial },
+  body: { action: 'spend', locationId, amountMinor: 2500 },
+  idempotencyKey: `kasa3-z0187-iptal${fisNo}`,
+});
+const iptal = await rewloy.reverseAction({ params: { serial }, body: { actionKey: `kasa3-z0187-iptal${fisNo}` } });
+console.log(iptal.undone, iptal.restored, iptal.balance);   // 'spend', 2500, kartın bakiyesi
 ```
 
 ### Satış: `recordSale`
@@ -173,13 +182,62 @@ Bir satış bir kez geri alınır (tekrar `duplicate: true` döner). Kazanılan
 kullanılmışsa (ödüle ya da harcamaya gitmişse) `409 SALE_ALREADY_SPENT` gelir ve
 hiçbir şey yazılmaz.
 
+**Çevrimdışı kasa kuyruğu: `occurredAt`.** Bağlantı koptuğunda satışı sonra
+yazıyorsanız `occurredAt` ile satışın gerçekten olduğu anı (ISO 8601, saat
+dilimiyle) gönderin; geçmişte, kartın geçmişinde o anla görünür. Gelecekte
+olamaz (2 dakikalık saat farkı kabul edilir). `idempotencyKey` kuyruktaki
+kayıtla birlikte saklanır, tekrar gönderilince satış ikinci kez yazılmaz.
+
+```ts
+await rewloy.recordSale({
+  params: { serial },
+  body: { locationId, amountMinor: 4550, reference: `fis-${fisNo}`, occurredAt: '2026-10-05T14:32:10+03:00' },
+  idempotencyKey: anahtar,
+});
+```
+
+**Kasa işlemini iptal etmek: `reverseAction`.** `passAction` ile yapılan bir
+harcama, ödül ya da kullanım yanlışlıkla yapıldıysa (`spend`, `spend-points`,
+`redeem-stamps`, `redeem-reward`, `use`) `reverseAction` tamamını geri verir.
+İşlemi, yaparken gönderdiğiniz `Idempotency-Key` (`actionKey`) ya da işlemin
+`reference` değeriyle bulur (`passAction` artık isteğe bağlı bir `reference`
+alır). `reverseAction` bir `Idempotency-Key` **istemez**: bir işlem bir kez geri
+alınır, tekrar `duplicate: true` döner.
+
+```ts
+const geri = await rewloy.reverseAction({
+  params: { serial },
+  body: { actionKey: `kasa3-z0187-fis${fisNo}`, locationId },   // ya da { reference: `fis-${fisNo}` }
+});
+console.log(geri.undone, geri.restored, geri.balance, geri.reopened, geri.duplicate);
+```
+
+`passAction`ın yanıtı kart türüne göre iki biçimdedir ve TypeScript'te bir
+birleşim türüdür: bakiyeli kartlarda `balance` (damga, puan, VIP, cashback,
+hediye kartı), kupon ve indirim kartında `status`, `uses` ve `usesLeft`
+(`'uses' in sonuc` ile ayırın). Kazanımlar (`earn-stamps`, `earn-points`,
+`visit`) `reverseAction`la değil `reverseSale`la geri alınır.
+
+**İstek sınırı.** Kimlikli her yanıt `RateLimit-Limit`, `RateLimit-Remaining` ve
+`RateLimit-Reset` başlıklarını taşır: `rewloy.request(...)` bunları
+`res.rateLimit` (`{ limit, remaining, reset }`) olarak verir, `429` hatası da
+(`RateLimitError`) `err.rateLimit` ve `err.retryAfter` taşır.
+
 ### `Idempotency-Key`
 
-`recordSale`, `passAction` ve `sendCampaign` bir `Idempotency-Key` ister.
-Verilmezse kütüphane bir UUID üretir ve aynı çağrının her denemesinde aynısını
-gönderir; ama uygulama çöküp yeniden başlarsa yeni bir anahtar üretilir ve
-satış ikinci kez yazılabilir. Kasada anahtarı kendiniz üretip satışla birlikte
-saklayın:
+`recordSale`, `passAction`, `sendCampaign` ve `refundShopRedemption` bir
+`Idempotency-Key` **ister**: API'nin tanımında (OpenAPI) bu başlık bu işlemlerde
+zorunludur, bu yüzden `idempotencyKey` bu metotlarda zorunlu bir argümandır.
+Verilmezse kütüphane istek göndermeden `TypeError` fırlatır; **sizin yerinize
+anahtar üretmez**. Üretilmiş rastgele bir anahtar yalnızca tek çağrının yeniden
+denemelerini korurdu: uygulama çöküp yeniden başlarsa yeni bir anahtar çıkar ve
+satış ikinci kez yazılabilirdi. Anahtarı kendiniz üretip satışla birlikte
+saklayın. Anahtar 8–64 karakterlik görünür ASCII olmalıdır (0x21–0x7E: harf,
+rakam ve noktalama; boşluk, Türkçe harf ya da `fiş` gibi ASCII dışı karakter
+olmaz); aksi halde kütüphane yine istek göndermeden `TypeError` fırlatır.
+Başlığın isteğe bağlı olduğu işlemlerde (örneğin `issuePass`) anahtar verilmezse
+kütüphane bir UUID üretir ve aynı çağrının her denemesinde aynısını gönderir.
+
 - **Anahtar bir kimlik için kalıcı olarak tekildir** (8–64 karakter; defterden
   hiç silinmez). Aynı anahtarla aynı isteğin tekrarı ikinci kez yazmaz ve
   ilk sonucu `duplicate: true` ile döndürür. Aynı anahtar başka bir gövdeyle
@@ -515,6 +573,15 @@ const sale = await rewloy.recordSale({
   body: { locationId, amountMinor: 4550, reference: `receipt-${receiptNo}` },  // amount in the card's currency, minor units
   idempotencyKey: `till3-z0187-r${receiptNo}`,
 });
+
+// A gift-card spend rung up by mistake? Void it by the key it was sent with:
+await rewloy.passAction({
+  params: { serial },
+  body: { action: 'spend', locationId, amountMinor: 2500 },
+  idempotencyKey: `till3-z0187-s${receiptNo}`,
+});
+const voided = await rewloy.reverseAction({ params: { serial }, body: { actionKey: `till3-z0187-s${receiptNo}` } });
+console.log(voided.undone, voided.restored, voided.balance);   // 'spend', 2500, the balance again
 ```
 
 - **Till.** `recordSale` writes a completed sale to a card (the card type and
@@ -522,14 +589,34 @@ const sale = await rewloy.recordSale({
   card's structured fields (`programName`, `currency`, `stamps`, `points`,
   `money`, `customer`); `reverseSale` takes a refunded sale back:
   `rewloy.reverseSale({ params: { serial }, body: { saleKey: key } })`.
-- **Idempotency keys.** `recordSale`, `passAction` and `sendCampaign` need an
-  `Idempotency-Key`. A key is unique **for good per credential**: do not use the
+  A void is `reverseAction`: it takes back a `passAction` that was a mistake
+  (`spend`, `spend-points`, `redeem-stamps`, `redeem-reward`, `use`), found by
+  the `Idempotency-Key` you sent with it (`actionKey`) or its `reference`; it
+  needs no `Idempotency-Key` of its own, and a repeat answers `duplicate: true`:
+  `rewloy.reverseAction({ params: { serial }, body: { actionKey: key } })`.
+  A till that queues sales while offline sends `occurredAt` (ISO 8601 with the
+  UTC offset, not in the future) with `recordSale`, so the card's history shows
+  when the sale really happened; the queued `idempotencyKey` makes the resend
+  safe. `passAction` takes an optional `reference` too, and its answer is a union:
+  the balance-card answer (`balance`) or the coupon / discount-card answer
+  (`status`, `uses`, `usesLeft`).
+- **Idempotency keys.** `recordSale`, `passAction`, `sendCampaign` and
+  `refundShopRedemption` need an `Idempotency-Key`: the API's OpenAPI document
+  marks the header required for them, so `idempotencyKey` is a required
+  argument and the client throws a `TypeError` before sending if it is missing.
+  It never makes one up for you (a generated key would not survive a restart of
+  your app). The key must be 8–64 printable ASCII characters (0x21–0x7E); a
+  non-ASCII key such as `fiş-0042` is refused client-side, with a `TypeError`,
+  before anything is sent. Where the header is optional (for example
+  `issuePass`) the client still generates a UUID and reuses it on every retry
+  of the call. A key is unique **for good per credential**: do not use the
   receipt number alone (fiscal receipt numbers restart after the Z report) but
   register + Z number + receipt number, or a UUID stored with the sale. The
-  receipt number goes in `reference`. A generated key only covers the retries
-  of one call, not a restart of your app.
+  receipt number goes in `reference`.
 - **Base URL.** `new Rewloy({ apiKey, baseUrl: 'https://staging.example.com' })`
-  (the origin, without `/v1`). Default `https://app.rewloy.com`.
+  or `baseUrl: 'https://staging.example.com/v1'`: with or without a trailing
+  `/v1` (and trailing slashes), the client appends `/v1/...` itself. Default
+  `https://app.rewloy.com`.
 - **Test mode.** Open the test environment (panel → Developer, or
   `POST /v1/test/environment`) and use its `rwk_test_` key at the same address:
   a separate test business that sends nothing and never reaches real
@@ -540,7 +627,9 @@ const sale = await rewloy.recordSale({
 - **Results.** It resolves to the answer's `data`: `{ data, meta }` for paged
   lists, `undefined` for 204, a `Blob` for files.
 - **The whole answer.** `rewloy.request(id, args)` returns `status`,
-  `headers`, `requestId`, `mode` (the `Rewloy-Mode` header: `live` or `test`) and `replayed` (`Idempotent-Replayed`).
+  `headers`, `requestId`, `rateLimit` (`{ limit, remaining, reset }` from the
+  `RateLimit-*` headers, `null` when absent), `mode` (the `Rewloy-Mode` header: `live` or `test`) and `replayed` (`Idempotent-Replayed`).
+  A `RewloyError` carries `rateLimit` too; a `RateLimitError` also has `retryAfter`.
 - **Pagination.** `rewloy.paginate('listCustomers', args)` iterates the items
   of every page.
 - **Streams.** `rewloy.liveFeed({ signal })` (or `rewloy.stream('liveFeed',

package/dist/client.d.ts

@@ -6,7 +6,7 @@
 import { RewloyMethods } from './generated/methods.js';
 import type { OperationId, Operations, PagedOperationId, StreamOperationId } from './generated/types.js';
 import { EventStream } from './sse.js';
-import type { ApiResponse, AuthKind } from './types.js';
+import type { ApiResponse, AuthKind, RateLimitInfo } from './types.js';
 export declare const DEFAULT_BASE_URL = "https://app.rewloy.com";
 type Credential = Exclude<AuthKind, 'public'>;
 type Sleep = (ms: number, signal?: AbortSignal) => Promise<void>;
@@ -58,8 +58,21 @@ type ArgsParam<A> = object extends A ? [args?: A] : [args: A];
 type ItemOf<K extends PagedOperationId> = Operations[K]['data'] extends (infer T)[] ? T : never;
 /** `Retry-After` in milliseconds: delta-seconds or an HTTP date. */
 export declare function parseRetryAfter(value: string | null, now?: number): number | null;
+/** The `RateLimit-Limit`, `RateLimit-Remaining` and `RateLimit-Reset` headers; `null` unless all three are numbers. */
+export declare function parseRateLimit(headers: Headers | null | undefined): RateLimitInfo | null;
 /** Exponential backoff with jitter for the retry after attempt `attempt` (0-based). */
 export declare function backoff(attempt: number, random?: () => number): number;
+/**
+ * The base URL without trailing slashes and without a trailing `/v1`: the
+ * paths of the operations carry `/v1` themselves, and the documentation shows
+ * the address both ways (`https://app.rewloy.com` and `https://app.rewloy.com/v1`).
+ */
+export declare function normalizeBaseUrl(url: string): string;
+/**
+ * An `Idempotency-Key` is 8–64 printable ASCII characters (0x21–0x7E): an HTTP
+ * header value cannot carry anything else, and `fetch` would throw a bare TypeError.
+ */
+export declare function checkIdempotencyKey(key: unknown): string;
 /**
  * A client of the Rewloy API (`https://app.rewloy.com/v1`).
  *

package/dist/client.js

@@ -51,11 +51,42 @@ export function parseRetryAfter(value, now = Date.now()) {
     const at = Date.parse(v);
     return Number.isNaN(at) ? null : Math.max(0, at - now);
 }
+/** The `RateLimit-Limit`, `RateLimit-Remaining` and `RateLimit-Reset` headers; `null` unless all three are numbers. */
+export function parseRateLimit(headers) {
+    if (!headers)
+        return null;
+    const read = (name) => {
+        const v = headers.get(name)?.trim();
+        return v && /^\d+$/.test(v) ? Number(v) : null;
+    };
+    const limit = read('ratelimit-limit');
+    const remaining = read('ratelimit-remaining');
+    const reset = read('ratelimit-reset');
+    return limit === null || remaining === null || reset === null ? null : { limit, remaining, reset };
+}
 /** Exponential backoff with jitter for the retry after attempt `attempt` (0-based). */
 export function backoff(attempt, random = Math.random) {
     const cap = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** attempt);
     return Math.round(cap / 2 + random() * (cap / 2));
 }
+/**
+ * The base URL without trailing slashes and without a trailing `/v1`: the
+ * paths of the operations carry `/v1` themselves, and the documentation shows
+ * the address both ways (`https://app.rewloy.com` and `https://app.rewloy.com/v1`).
+ */
+export function normalizeBaseUrl(url) {
+    return url.replace(/\/+$/, '').replace(/\/v1$/, '').replace(/\/+$/, '');
+}
+/**
+ * An `Idempotency-Key` is 8–64 printable ASCII characters (0x21–0x7E): an HTTP
+ * header value cannot carry anything else, and `fetch` would throw a bare TypeError.
+ */
+export function checkIdempotencyKey(key) {
+    if (typeof key !== 'string' || !/^[\x21-\x7e]{8,64}$/.test(key)) {
+        throw new TypeError('Rewloy: Idempotency-Key yalnız ASCII karakterler içerebilir (görünür karakterler, 8–64) / the Idempotency-Key must be printable ASCII (0x21–0x7E), 8–64 characters');
+    }
+    return key;
+}
 /** The URL a `Link` header gives for `rel="deprecation"` (else its first). */
 function deprecationLink(link) {
     if (!link)
@@ -135,7 +166,7 @@ export class Rewloy extends RewloyMethods {
         if (options.merchant !== undefined && which !== 'staffSession')
             throw new TypeError('Rewloy: `merchant` goes with a staffSession');
         this.merchant = options.merchant ?? null;
-        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.baseUrl = normalizeBaseUrl(options.baseUrl ?? DEFAULT_BASE_URL);
         this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
         const f = options.fetch ?? globalThis.fetch;
@@ -161,7 +192,7 @@ export class Rewloy extends RewloyMethods {
         const { res, data, meta } = await this.#exchange(id, op, args[0]);
         return {
             data: data, meta, status: res.status, headers: res.headers,
-            requestId: res.headers.get('x-request-id'), mode: res.headers.get('rewloy-mode'),
+            requestId: res.headers.get('x-request-id'), rateLimit: parseRateLimit(res.headers), mode: res.headers.get('rewloy-mode'),
             replayed: res.headers.get('idempotent-replayed') === 'true',
         };
     }
@@ -251,7 +282,7 @@ export class Rewloy extends RewloyMethods {
         const qs = query.toString();
         return `${this.baseUrl}${path}${qs ? `?${qs}` : ''}`;
     }
-    #headers(op, a, lastEventId) {
+    #headers(id, op, a, lastEventId) {
         const h = new Headers();
         h.set('accept', op.stream ? 'text/event-stream' : op.response === 'json' || op.response === 'raw-json' ? 'application/json' : '*/*');
         if (this.#userAgent)
@@ -264,15 +295,21 @@ export class Rewloy extends RewloyMethods {
         const merchant = a.merchant ?? (this.credential === 'staff' ? this.merchant : null);
         if (op.merchant && merchant)
             h.set('rewloy-merchant', merchant);
-        if (op.idempotency)
-            h.set('idempotency-key', a.idempotencyKey ?? randomUUID());
+        if (op.idempotency) {
+            if (a.idempotencyKey === undefined && op.idempotency === 'required') {
+                throw new TypeError(`Rewloy: ${id} needs idempotencyKey: Idempotency-Key gerekli, kütüphane uydurmaz (8–64 ASCII karakter) / the Idempotency-Key is required and is never generated for you (8–64 printable ASCII characters)`);
+            }
+            h.set('idempotency-key', a.idempotencyKey === undefined ? randomUUID() : checkIdempotencyKey(a.idempotencyKey));
+        }
         if (op.body)
             h.set('content-type', 'application/json');
         if (lastEventId)
             h.set('last-event-id', lastEventId);
-        for (const [k, v] of Object.entries(a.headers ?? {}))
-            if (v !== undefined && v !== null)
-                h.set(k, String(v));
+        for (const [k, v] of Object.entries(a.headers ?? {})) {
+            if (v === undefined || v === null)
+                continue;
+            h.set(k, k.toLowerCase() === 'idempotency-key' ? checkIdempotencyKey(v) : String(v));
+        }
         return h;
     }
     #notice(id, op, headers) {
@@ -290,7 +327,7 @@ export class Rewloy extends RewloyMethods {
     async #exchange(id, op, args, stream) {
         const a = args ?? {};
         const url = this.#url(id, op, a);
-        const headers = this.#headers(op, a, stream?.lastEventId);
+        const headers = this.#headers(id, op, a, stream?.lastEventId);
         const body = op.body ? JSON.stringify(a.body ?? {}) : undefined;
         const retryable = IDEMPOTENT_METHODS.has(op.method) || headers.has('idempotency-key');
         const maxRetries = Math.max(0, a.maxRetries ?? this.maxRetries);
@@ -369,7 +406,7 @@ export class Rewloy extends RewloyMethods {
     #invalid(id, res, body) {
         return new RewloyError({
             status: res.status, code: 'INVALID_RESPONSE', detail: `the answer is not the JSON the API documents (${res.headers.get('content-type') ?? 'no content type'})`,
-            requestId: res.headers.get('x-request-id'), body, headers: res.headers, operation: id,
+            requestId: res.headers.get('x-request-id'), body, headers: res.headers, rateLimit: parseRateLimit(res.headers), operation: id,
         });
     }
     #failure(id, res, text) {
@@ -386,7 +423,7 @@ export class Rewloy extends RewloyMethods {
             detail: e && typeof e.message === 'string' ? e.message : res.statusText || `HTTP ${String(res.status)}`,
             details: e?.details, docs: e && typeof e.docs === 'string' ? e.docs : null,
             requestId: res.headers.get('x-request-id') ?? (e && typeof e.requestId === 'string' ? e.requestId : null),
-            body: parsed, headers: res.headers, operation: id,
+            body: parsed, headers: res.headers, rateLimit: parseRateLimit(res.headers), operation: id,
         };
         if (res.status === 429) {
             const header = parseRetryAfter(res.headers.get('retry-after'));

package/dist/errors.d.ts

@@ -4,6 +4,7 @@
  * answer that is not what the API documents, or no answer at all.
  */
 import type { ErrorCode } from './generated/types.js';
+import type { RateLimitInfo } from './types.js';
 export interface RewloyErrorInit {
     status: number;
     code: string;
@@ -14,6 +15,7 @@ export interface RewloyErrorInit {
     requestId?: string | null | undefined;
     body?: unknown;
     headers?: Headers | null | undefined;
+    rateLimit?: RateLimitInfo | null | undefined;
     operation?: string | null | undefined;
     cause?: unknown;
 }
@@ -49,6 +51,8 @@ export declare class RewloyError extends Error {
     /** The parsed answer body (or its text, when it is not JSON). */
     readonly body: unknown;
     readonly headers: Headers | null;
+    /** The `RateLimit-*` headers of the answer; `null` when it carried none. */
+    readonly rateLimit: RateLimitInfo | null;
     /** The operationId of the call. */
     readonly operation: string | null;
     constructor(init: RewloyErrorInit);

package/dist/errors.js

@@ -35,6 +35,8 @@ export class RewloyError extends Error {
     /** The parsed answer body (or its text, when it is not JSON). */
     body;
     headers;
+    /** The `RateLimit-*` headers of the answer; `null` when it carried none. */
+    rateLimit;
     /** The operationId of the call. */
     operation;
     constructor(init) {
@@ -49,6 +51,7 @@ export class RewloyError extends Error {
         this.requestId = init.requestId ?? null;
         this.body = init.body;
         this.headers = init.headers ?? null;
+        this.rateLimit = init.rateLimit ?? null;
         this.operation = init.operation ?? null;
     }
 }