@garuhq/node 2.0.0 → 4.0.0

package/CHANGELOG.md

@@ -3,6 +3,97 @@
 All notable changes to `@garuhq/node` are documented in this file. Format:
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Versioning: [SemVer](https://semver.org/).
 
+## [4.0.0] — 2026-08-22
+
+**Breaking:** `scheduledCharges` now targets the versioned public API
+`/api/v1/scheduled-charges`. `id` was already a stable, non-enumerable
+string (`sch_...`) — no identifier change — but the list envelope shape
+changed. If you use `garu.scheduledCharges.*`, read the migration below.
+
+### Breaking
+
+- **`scheduledCharges` moved to `/api/v1/scheduled-charges`.**
+  - **`scheduledCharges.list()` and `.listAttempts()` now return
+    `{ data, count, totalCount, totalPages }`** (was `{ data, meta }`).
+  - No method signatures changed — every method already took/returned the
+    same shapes, since `id` was never a numeric internal id here.
+
+### Added
+
+- `ScheduledChargeRecord` now explicitly types `recurrence`,
+  `cancelAtPeriodEnd`, `trialEndsAt`, and `subscriptionId` (previously only
+  reachable via the type's index signature, untyped).
+- Test coverage for `cancelRecurrence`, `setCancelAtPeriodEnd`,
+  `changePaymentMethod`, `clearPaymentMethod`, and `listAttempts` — none of
+  these five methods had a single test before this release.
+
+### Fixed
+
+- `ScheduledChargeLinkedTransaction.value`'s docstring claimed centavos;
+  `/api/v1/charges`' own mapper treats the same `transaction.value` column
+  as decimal reais with no conversion. Corrected to match reality — this is
+  a documentation fix, not a behavior or wire-format change.
+- `scheduledCharges.create()`'s docstring claimed the SDK's
+  `X-Idempotency-Key` prevents duplicate creates on retry. The gateway does
+  not deduplicate `/scheduled-charges` creates against it (same pre-existing
+  gap as `webhookEvents.resend()` had). Corrected the docstring; the header
+  is still sent (harmless) in case the gateway adds this later.
+
+### Migration
+
+```ts
+// before (≤ 3.x)
+const { data, meta } = await garu.scheduledCharges.list({ status: 'overdue' });
+meta.total; // number
+
+// after (4.0.0)
+const { data, totalCount } = await garu.scheduledCharges.list({ status: 'overdue' });
+totalCount; // number
+```
+
+## [3.0.0] — 2026-08-22
+
+**Breaking:** `webhookEvents` now targets the versioned public API
+`/api/v1/webhook-events`, keyed on `uuid`. If you use `garu.webhookEvents.*`,
+read the migration below.
+
+### Breaking
+
+- **`webhookEvents` moved to `/api/v1/webhook-events`** and an event is
+  keyed by **`uuid`**, not a numeric `id`.
+  - `webhookEvents.get(id: number)` → **`webhookEvents.get(uuid: string)`**.
+  - `webhookEvents.retry(id)` / `webhookEvents.resend(id, params?)` — same
+    signature shape, but the id argument is now the `uuid`.
+  - `WebhookEvent.id` is **removed**; there is no numeric id in the public
+    shape. Use `WebhookEvent.uuid` everywhere. `WebhookEvent.endpointId` is
+    also removed — read `webhookEndpoint.id` instead (endpoint configuration
+    stays numeric; it did not move to `/api/v1`).
+  - `WebhookEvent.manualResendOf` is now a **`uuid` string** (was a numeric
+    id), pointing at the source event's `uuid`.
+  - **`webhookEvents.list()` returns `{ data, count, totalCount, totalPages }`**
+    (was `{ data, meta }`).
+  - The gateway's outbound `Idempotency-Key` for `/resend` clones is now
+    `resend_<uuid>` (was `resend_<numeric id>`), to match the public
+    identifier the SDK/CLI/MCP now expose.
+
+### Migration
+
+```ts
+// before (0.x – 2.x)
+const failed = await garu.webhookEvents.list({ status: 'failed', limit: 5 });
+const event = failed.data[0];
+event.id; // number
+const clone = await garu.webhookEvents.resend(event.id);
+clone.manualResendOf === event.id; // true
+
+// after (3.0.0)
+const failed = await garu.webhookEvents.list({ status: 'failed', limit: 5 });
+const event = failed.data[0];
+event.uuid; // string
+const clone = await garu.webhookEvents.resend(event.uuid);
+clone.manualResendOf === event.uuid; // true
+```
+
 ## [2.0.0] — 2026-08-22
 
 **Breaking:** `customers` now targets the versioned public API `/api/v1/customers`,
@@ -35,14 +126,14 @@ keyed on `uuid`. If you use `garu.customers.*`, read the migration below.
 ```ts
 // before (1.x)
 const c = await garu.customers.create({ name, email, document, phone, personType });
-c.id;                    // number
+c.id; // number
 const one = await garu.customers.get(c.id);
 await garu.customers.update(c.id, { name: 'Maria Santos' });
 await garu.customers.delete(c.id);
 
 // after (2.0.0)
 const c = await garu.customers.create({ name, email, document, phone, personType });
-c.uuid;                   // string
+c.uuid; // string
 const one = await garu.customers.get(c.uuid);
 await garu.customers.update(c.uuid, { name: 'Maria Santos' });
 const { removed } = await garu.customers.delete(c.uuid);
@@ -50,7 +141,6 @@ const { removed } = await garu.customers.delete(c.uuid);
 
 ## [1.1.0] — 2026-08-15
 
-
 ### Added
 
 - **`garu.installmentPlans` — boleto parcelado (carnê).** One product sold as N
@@ -127,22 +217,26 @@ webhook-events) changed.
 ```ts
 // before (0.16.x)
 const c = await garu.charges.create({
-  productId, paymentMethod: 'credit_card', customer,
+  productId,
+  paymentMethod: 'credit_card',
+  customer,
   cardInfo: { cardNumber: '4111…', cvv, expirationDate, holderName, installments: 2 }
 });
-c.id;                 // number
-c.paymentMethodId;    // 'creditcard'
+c.id; // number
+c.paymentMethodId; // 'creditcard'
 const one = await garu.charges.get(c.id);
 await garu.charges.refund(c.id, { amount: 1000 }); // "R$10,00" (bug: reais)
 
 // after (1.0.0)
 const c = await garu.charges.create({
-  productId, paymentMethod: 'creditCard', customer,
+  productId,
+  paymentMethod: 'creditCard',
+  customer,
   card: { number: '4111…', cvv, expirationDate, holderName, installments: 2 }
 });
-c.uuid;               // string
-c.paymentMethod;      // 'creditCard'
-c.chargedTotal;       // what was actually charged
+c.uuid; // string
+c.paymentMethod; // 'creditCard'
+c.chargedTotal; // what was actually charged
 const one = await garu.charges.retrieve(c.uuid);
 await garu.charges.refund(c.uuid, { amount: 10.0 }); // R$10,00
 ```

package/README.md

@@ -147,10 +147,13 @@ await garu.charges.refund('6f1c9b2e-…', { amount: 10.0 }); // partial refund (
 ## Customers
 
 Backed by `/api/v1/customers`, keyed on `uuid` — there is no numeric id in
-this shape. `installmentPlans.create` and `scheduledCharges.create` still
-link customers by the internal numeric id (unmigrated resources); fetch that
-id from the dashboard or the internal `/api/customers` endpoint until they
-move to `/api/v1` too.
+this shape. `installmentPlans.create` still links customers by the internal
+numeric id (unmigrated resource); fetch that id from the dashboard or the
+internal `/api/customers` endpoint until it moves to `/api/v1` too.
+`scheduledCharges.create` also takes the internal numeric `customerId` —
+customers and scheduled charges are on separate `/api/v1` resources, and
+neither exposes a cross-reference between a customer's `uuid` and their
+numeric id yet.
 
 | Method                                  | Description                                     |
 | --------------------------------------- | ----------------------------------------------- |
@@ -206,20 +209,25 @@ await garu.products.portalConfig.patch('b3f2c1e8-6e4a-4b9f-9d1c-2a1f6c3d4e5f', {
 
 Bill an existing customer on a future date — one-time or recurring with card tokenization. The Garu drives email reminders, dunning, retries, and the lifecycle state machine.
 
-| Method                               | Description                                                                 |
-| ------------------------------------ | --------------------------------------------------------------------------- |
-| `create(params)`                     | Create one-time or recurring schedule. Auto-attaches `X-Idempotency-Key`.   |
-| `list(params?)`                      | Paginated list with status / type / dueFrom / dueTo / customerId filters.   |
-| `get(id)`                            | Detail bundle: charge + event timeline + linked transactions.               |
-| `chargeNow(id)`                      | Force-bill the current cycle now instead of waiting for the due date.       |
-| `markPaid(id, params)`               | Mark cycle paid (off-Garu reconciliation).                                  |
-| `postpone(id, params)`               | Move the next cycle's due date forward.                                     |
-| `pause(id, params?)` / `resume(id)`  | Suspend / re-enable a series.                                               |
-| `cancelRecurrence(id, params?)`      | Hard-stop future cycles (recurring only).                                   |
-| `cancelAtPeriodEnd(id, { enabled })` | Stripe-style soft-cancel; reversible.                                       |
-| `changePaymentMethod(id, params)`    | Swap the saved card.                                                        |
-| `clearPaymentMethod(id)`             | Remove the saved card; future cycles email-with-link.                       |
-| `listAttempts(id, params?)`          | Per-attempt billing log — every silent-charge / retry / mark-paid (v0.8.2). |
+Backed by `/api/v1/scheduled-charges`. Unlike products/customers/webhook-events,
+`id` here was already a stable, non-enumerable string (`sch_...`) before this
+move — there is no separate uuid and no id change, only the path and the list
+envelope (`totalCount`/`totalPages`, not `meta.total`/`meta.totalPages`).
+
+| Method                                  | Description                                                               |
+| --------------------------------------- | ------------------------------------------------------------------------- |
+| `create(params)`                        | Create one-time or recurring schedule.                                    |
+| `list(params?)`                         | Paginated list with status / type / dueFrom / dueTo / customerId filters. |
+| `get(id)`                               | Detail bundle: charge + event timeline + linked transactions.             |
+| `chargeNow(id)`                         | Force-bill the current cycle now instead of waiting for the due date.     |
+| `markPaid(id, params)`                  | Mark cycle paid (off-Garu reconciliation).                                |
+| `postpone(id, params)`                  | Move the next cycle's due date forward.                                   |
+| `pause(id, params?)` / `resume(id)`     | Suspend / re-enable a series.                                             |
+| `cancelRecurrence(id, params?)`         | Hard-stop future cycles (recurring only).                                 |
+| `setCancelAtPeriodEnd(id, { enabled })` | Stripe-style soft-cancel; reversible.                                     |
+| `changePaymentMethod(id, params)`       | Swap the saved card.                                                      |
+| `clearPaymentMethod(id)`                | Remove the saved card; future cycles email-with-link.                     |
+| `listAttempts(id, params?)`             | Per-attempt billing log — every silent-charge / retry / mark-paid.        |
 
 ```ts
 // Recurring with 7-day trial. `maxRecoveryDays` caps how long past the due
@@ -240,11 +248,10 @@ const series = await garu.scheduledCharges.create({
 // Idempotent: a cycle already dispatched today reports `already_sent`.
 const result = await garu.scheduledCharges.chargeNow(series.id);
 if (result.outcome === 'failed') {
-  // result.reason is e.g. 'card_expired' or a gateway decline code
-  console.error(`${result.message} (${result.reason})`);
+  result.reason; // e.g. 'card_expired' or a gateway decline code
 }
 
-// Audit why cycle 3 failed (v0.8.2)
+// Audit why cycle 3 failed
 const { data } = await garu.scheduledCharges.listAttempts(series.id, {
   cycleNumber: 3
 });
@@ -308,7 +315,7 @@ const series = await garu.scheduledCharges.create({
 });
 ```
 
-Cancel and the rest of the lifecycle use the **same methods** as card-backed series — `cancelRecurrence(id)`, `cancelAtPeriodEnd(id, { enabled })`, `pause(id)` / `resume(id)`. The customer can also revoke the authorization directly in their bank app; Garu surfaces that as a `subscription.cancelled` event.
+Cancel and the rest of the lifecycle use the **same methods** as card-backed series — `cancelRecurrence(id)`, `setCancelAtPeriodEnd(id, { enabled })`, `pause(id)` / `resume(id)`. The customer can also revoke the authorization directly in their bank app; Garu surfaces that as a `subscription.cancelled` event.
 
 ### 3. Handle the webhooks
 
@@ -397,18 +404,19 @@ The seller-facing delivery log for outbound webhooks. Use it to audit deliveries
 const failed = await garu.webhookEvents.list({ status: 'failed', limit: 50 });
 
 // Inspect one event end-to-end
-const event = await garu.webhookEvents.get(42);
-console.log(event.responseStatus, event.responseBody);
+const event = await garu.webhookEvents.get('a1b2c3d4-e5f6-7890-abcd-ef1234567890');
+event.responseStatus;
+event.responseBody;
 
 // Audit-trail-preserving replay (recommended)
-const clone = await garu.webhookEvents.resend(42);
-clone.id !== event.id; // true — fresh row with its own id
-clone.manualResendOf === event.id; // true — points back at the source
+const clone = await garu.webhookEvents.resend(event.uuid);
+clone.uuid !== event.uuid; // true — fresh row with its own uuid
+clone.manualResendOf === event.uuid; // true — points back at the source
 ```
 
-`resend(id)` is the audit-preserving counterpart to `retry(id)` — the backend inserts a fresh event whose `manualResendOf` points back at the source, then dispatches that clone. The original row stays exactly as it was, so the historical record of the prior failure (status, response status/body, attempts) survives. Works on any source status (`success` / `failed` / `pending`).
+`resend(uuid)` is the audit-preserving counterpart to `retry(uuid)` — the backend inserts a fresh event whose `manualResendOf` points back at the source, then dispatches that clone. The original row stays exactly as it was, so the historical record of the prior failure (status, response status/body, attempts) survives. Works on any source status (`success` / `failed` / `pending`).
 
-Outbound deliveries of a resent event carry `Idempotency-Key: resend_<originalId>`, so recipient handlers can distinguish a resend from a fresh delivery both by the header prefix and by reading the response payload's `manualResendOf` field.
+Outbound deliveries of a resent event carry `Idempotency-Key: resend_<cloneUuid>`, so recipient handlers can distinguish a resend from a fresh delivery both by the header prefix and by reading the response payload's `manualResendOf` field.
 
 > [!NOTE]
 > The SDK auto-attaches `X-Idempotency-Key` (UUIDv4) on `resend()` so transient transport retries can't create duplicate clones. Pass `{ idempotencyKey }` to dedupe across your own retry layer.

package/dist/index.cjs

@@ -942,9 +942,13 @@ var ScheduledCharges = class {
   }
   http;
   /**
-   * Create a new scheduled charge. Auto-attaches `X-Idempotency-Key`
-   * (UUIDv4 if you don't pass `idempotencyKey`) so retries on transient
-   * network failures don't silently double-create.
+   * Create a new scheduled charge. The SDK attaches an `X-Idempotency-Key`
+   * header (UUIDv4 unless you pass `idempotencyKey`), but the gateway does
+   * not currently deduplicate `/scheduled-charges` creates against it — a
+   * retry after a network failure can create more than one series. Pair
+   * this with your own retry-suppression (e.g. check `list` for an existing
+   * series with the same `externalReference`) if that matters for your
+   * integration.
    *
    * @example
    * const charge = await garu.scheduledCharges.create({
@@ -974,7 +978,7 @@ var ScheduledCharges = class {
     const idempotencyKey = params.idempotencyKey ?? generateIdempotencyKey();
     const { idempotencyKey: _omit, ...body } = params;
     return this.http.call(
-      (signal) => this.http.client.POST("/api/scheduled-charges", {
+      (signal) => this.http.client.POST("/api/v1/scheduled-charges", {
         body,
         headers: { "X-Idempotency-Key": idempotencyKey },
         signal
@@ -1009,7 +1013,7 @@ var ScheduledCharges = class {
       for (const s of statuses) qs.append("status", s);
     }
     const query = qs.toString();
-    const url = `/api/scheduled-charges${query ? `?${query}` : ""}`;
+    const url = `/api/v1/scheduled-charges${query ? `?${query}` : ""}`;
     return this.http.call(
       (signal) => this.http.client.GET(url, { signal }).then(
         (r) => r
@@ -1026,7 +1030,7 @@ var ScheduledCharges = class {
    */
   async get(id) {
     return this.http.call(
-      (signal) => this.http.client.GET(`/api/scheduled-charges/${encodeURIComponent(id)}`, {
+      (signal) => this.http.client.GET(`/api/v1/scheduled-charges/${encodeURIComponent(id)}`, {
         signal
       }).then((r) => r)
     );
@@ -1045,7 +1049,7 @@ var ScheduledCharges = class {
   async postpone(id, params) {
     return this.http.call(
       (signal) => this.http.client.POST(
-        `/api/scheduled-charges/${encodeURIComponent(id)}/postpone`,
+        `/api/v1/scheduled-charges/${encodeURIComponent(id)}/postpone`,
         {
           body: params,
           signal
@@ -1064,7 +1068,7 @@ var ScheduledCharges = class {
   async pause(id, params = {}) {
     return this.http.call(
       (signal) => this.http.client.POST(
-        `/api/scheduled-charges/${encodeURIComponent(id)}/pause`,
+        `/api/v1/scheduled-charges/${encodeURIComponent(id)}/pause`,
         {
           body: params,
           signal
@@ -1081,7 +1085,7 @@ var ScheduledCharges = class {
   async resume(id) {
     return this.http.call(
       (signal) => this.http.client.POST(
-        `/api/scheduled-charges/${encodeURIComponent(id)}/resume`,
+        `/api/v1/scheduled-charges/${encodeURIComponent(id)}/resume`,
         {
           body: {},
           signal
@@ -1115,7 +1119,7 @@ var ScheduledCharges = class {
   async markPaid(id, params) {
     return this.http.call(
       (signal) => this.http.client.POST(
-        `/api/scheduled-charges/${encodeURIComponent(id)}/mark-paid`,
+        `/api/v1/scheduled-charges/${encodeURIComponent(id)}/mark-paid`,
         {
           body: params,
           signal
@@ -1137,24 +1141,22 @@ var ScheduledCharges = class {
    * const result = await garu.scheduledCharges.chargeNow('sch_abc123');
    * switch (result.outcome) {
    *   case 'dispatched':
-   *     console.log(`Cobrança enviada (ciclo ${result.cycleNumber}).`);
+   *     result.cycleNumber; // billed this cycle
    *     break;
    *   case 'already_sent':
-   *     console.log('Já havia sido enviada — nada a fazer.');
-   *     break;
+   *     break; // nothing to do
    *   case 'failed':
-   *     // result.reason is e.g. 'card_expired' or a gateway decline code
-   *     console.error(`Falha na cobrança: ${result.reason}. ${result.message}`);
+   *     result.reason; // e.g. 'card_expired' or a gateway decline code
    *     break;
    *   case 'not_sent':
-   *     console.warn(`Não enviada (${result.reason}): ${result.message}`);
+   *     result.reason;
    *     break;
    * }
    */
   async chargeNow(id) {
     return this.http.call(
       (signal) => this.http.client.POST(
-        `/api/scheduled-charges/${encodeURIComponent(id)}/charge-now`,
+        `/api/v1/scheduled-charges/${encodeURIComponent(id)}/charge-now`,
         {
           body: {},
           signal
@@ -1176,7 +1178,7 @@ var ScheduledCharges = class {
   async cancelRecurrence(id, params = {}) {
     return this.http.call(
       (signal) => this.http.client.POST(
-        `/api/scheduled-charges/${encodeURIComponent(id)}/cancel-recurrence`,
+        `/api/v1/scheduled-charges/${encodeURIComponent(id)}/cancel-recurrence`,
         {
           body: params,
           signal
@@ -1196,7 +1198,7 @@ var ScheduledCharges = class {
   async setCancelAtPeriodEnd(id, params) {
     return this.http.call(
       (signal) => this.http.client.POST(
-        `/api/scheduled-charges/${encodeURIComponent(id)}/cancel-at-period-end`,
+        `/api/v1/scheduled-charges/${encodeURIComponent(id)}/cancel-at-period-end`,
         {
           body: params,
           signal
@@ -1215,7 +1217,7 @@ var ScheduledCharges = class {
   async changePaymentMethod(id, params) {
     return this.http.call(
       (signal) => this.http.client.POST(
-        `/api/scheduled-charges/${encodeURIComponent(id)}/payment-method`,
+        `/api/v1/scheduled-charges/${encodeURIComponent(id)}/payment-method`,
         {
           body: params,
           signal
@@ -1234,7 +1236,7 @@ var ScheduledCharges = class {
   async clearPaymentMethod(id) {
     return this.http.call(
       (signal) => this.http.client.DELETE(
-        `/api/scheduled-charges/${encodeURIComponent(id)}/payment-method`,
+        `/api/v1/scheduled-charges/${encodeURIComponent(id)}/payment-method`,
         {
           body: {},
           signal
@@ -1261,7 +1263,7 @@ var ScheduledCharges = class {
     if (params.limit !== void 0) qs.set("limit", String(params.limit));
     if (params.cycleNumber !== void 0) qs.set("cycleNumber", String(params.cycleNumber));
     const query = qs.toString();
-    const url = `/api/scheduled-charges/${encodeURIComponent(id)}/attempts${query ? `?${query}` : ""}`;
+    const url = `/api/v1/scheduled-charges/${encodeURIComponent(id)}/attempts${query ? `?${query}` : ""}`;
     return this.http.call(
       (signal) => this.http.client.GET(url, { signal }).then(
         (r) => r
@@ -1293,42 +1295,31 @@ var WebhookEvents = class {
    * });
    */
   async list(params = {}) {
-    const qs = new URLSearchParams();
-    if (params.page !== void 0) qs.set("page", String(params.page));
-    if (params.limit !== void 0) qs.set("limit", String(params.limit));
-    if (params.status) qs.set("status", params.status);
-    if (params.eventType) qs.set("event_type", params.eventType);
-    if (params.endpointId !== void 0) qs.set("endpoint_id", String(params.endpointId));
-    const query = qs.toString();
-    const url = `/api/webhook-events${query ? `?${query}` : ""}`;
-    const raw = await this.http.call(
+    const query = {};
+    if (params.page !== void 0) query.page = String(params.page);
+    if (params.limit !== void 0) query.limit = String(params.limit);
+    if (params.status) query.status = params.status;
+    if (params.eventType) query.eventType = params.eventType;
+    if (params.endpointId !== void 0) query.endpointId = String(params.endpointId);
+    const qs = new URLSearchParams(query).toString();
+    const url = `/api/v1/webhook-events${qs ? `?${qs}` : ""}`;
+    return this.http.call(
       (signal) => this.http.client.GET(url, { signal }).then(
         (r) => r
       )
     );
-    return {
-      data: raw.events,
-      meta: {
-        page: raw.page,
-        limit: raw.limit,
-        total: raw.total,
-        totalPages: raw.pages
-      }
-    };
   }
   /**
-   * Fetch one webhook event by numeric ID — includes the full payload, the
+   * Fetch one webhook event by uuid — includes the full payload, the
    * embedded endpoint snapshot, and the most recent response status/body.
    *
    * @example
-   * const event = await garu.webhookEvents.get(42);
-   * if (event.status === 'failed') {
-   *   console.log(event.responseStatus, event.responseBody);
-   * }
+   * const event = await garu.webhookEvents.get('a1b2c3d4-e5f6-7890-abcd-ef1234567890');
+   * event.status === 'failed' && event.responseStatus;
    */
-  async get(id) {
+  async get(uuid) {
     return this.http.call(
-      (signal) => this.http.client.GET(`/api/webhook-events/${id}`, { signal }).then(
+      (signal) => this.http.client.GET(`/api/v1/webhook-events/${uuid}`, { signal }).then(
         (r) => r
       )
     );
@@ -1341,28 +1332,28 @@ var WebhookEvents = class {
    * explicitly want the legacy in-place semantics (and for backwards
    * compatibility with older CLI / MCP releases).
    *
-   * Re-deliver a webhook event by ID. Resets it to `pending`, clears the
+   * Re-deliver a webhook event by uuid. Resets it to `pending`, clears the
    * retry schedule, and triggers an immediate delivery attempt. Works on
    * any status (`success`, `failed`, `pending`).
    *
    * @example
    * const failed = await garu.webhookEvents.list({ status: 'failed', limit: 5 });
    * for (const event of failed.data) {
-   *   await garu.webhookEvents.retry(event.id);
+   *   await garu.webhookEvents.retry(event.uuid);
    * }
    */
-  async retry(id) {
+  async retry(uuid) {
     return this.http.call(
-      (signal) => this.http.client.POST(`/api/webhook-events/${id}/retry`, {
+      (signal) => this.http.client.POST(`/api/v1/webhook-events/${uuid}/retry`, {
         body: {},
         signal
       }).then((r) => r)
     );
   }
   /**
-   * Re-deliver a webhook event by ID, audit-trail preserving. Unlike
+   * Re-deliver a webhook event by uuid, audit-trail preserving. Unlike
    * {@link retry}, this does *not* mutate the original row — it inserts a
-   * fresh event (new numeric id) that points back at the source via
+   * fresh event (new uuid) that points back at the source via
    * `manualResendOf`, then dispatches that clone. The original row is
    * untouched, so the historical record of the prior failure (and its
    * response status / body) is preserved.
@@ -1373,30 +1364,30 @@ var WebhookEvents = class {
    * delivery's outcome to remain on the record.
    *
    * **Outbound delivery semantics**: the gateway POSTs the clone with
-   * `Idempotency-Key: resend_<originalId>` (where `<originalId>` is the id
-   * of the source event, not the clone). Recipient handlers that key off
+   * `Idempotency-Key: resend_<cloneUuid>`. Recipient handlers that key off
    * `Idempotency-Key` will see this as a distinct delivery from the
    * original — distinguishable both by the `resend_` prefix and by reading
    * the response payload's `manualResendOf` field.
    *
-   * **SDK→gateway dedup**: the SDK auto-attaches `X-Idempotency-Key`
-   * (UUIDv4 unless you pass `idempotencyKey`) so transient transport
-   * retries (5xx → SDK backoff) cannot create duplicate clones — the
-   * backend returns the original clone on the second call within 24h.
+   * The SDK also attaches an `X-Idempotency-Key` header (UUIDv4 unless you
+   * pass `idempotencyKey`); the gateway does not currently deduplicate
+   * `/resend` calls against it, so retrying this call from your own code
+   * after a network failure can create more than one clone — pair it with
+   * your own retry-suppression if that matters for your integration.
    *
-   * Returns the *clone* event (new id), not the original. The original is
+   * Returns the *clone* event (new uuid), not the original. The original is
    * unchanged on the server.
    *
    * @example
-   * const event = await garu.webhookEvents.get(42);
-   * const clone = await garu.webhookEvents.resend(42);
-   * clone.id !== event.id;            // true — clone has its own id
-   * clone.manualResendOf === event.id; // true — points back at the source
+   * const event = await garu.webhookEvents.get('a1b2c3d4-e5f6-7890-abcd-ef1234567890');
+   * const clone = await garu.webhookEvents.resend(event.uuid);
+   * clone.uuid !== event.uuid;            // true — clone has its own uuid
+   * clone.manualResendOf === event.uuid; // true — points back at the source
    */
-  async resend(id, params = {}) {
+  async resend(uuid, params = {}) {
     const idempotencyKey = params.idempotencyKey ?? generateIdempotencyKey();
     return this.http.call(
-      (signal) => this.http.client.POST(`/api/webhook-events/${id}/resend`, {
+      (signal) => this.http.client.POST(`/api/v1/webhook-events/${uuid}/resend`, {
         body: {},
         headers: { "X-Idempotency-Key": idempotencyKey },
         signal