@clocknext/sdk 0.13.0 → 0.15.0

package/dist/index.js

@@ -75,7 +75,8 @@ function translateFieldPaths(message) {
   }
   return out;
 }
-var ALLOWANCE_MESSAGE = /\binsufficient\b|\bno allowance left\b|\bno slots left\b|\boutcomes remaining\b|\btop up the (?:allowance|balance)\b/i;
+var ALLOWANCE_MESSAGE = /\binsufficient\b|\bno allowance left\b|\bno slots left\b|\boutcomes remaining\b|\btop up the (?:allowance|balance)\b|\bbelow zero\b/i;
+var IDEMPOTENCY_KEY_REUSED = /\bidempotency key was already used\b/i;
 function isAllowanceFailure(message, code) {
   if (code) return code === "ALLOWANCE_EXHAUSTED";
   return ALLOWANCE_MESSAGE.test(message);
@@ -99,6 +100,9 @@ function errorFromResponse(status, message, retryAfterMs, meta = {}) {
     });
   }
   if (status === 422) {
+    if (IDEMPOTENCY_KEY_REUSED.test(raw)) {
+      return new ConflictError(raw, { ...opts, retryable: false });
+    }
     return isAllowanceFailure(raw, code) ? new AllowanceError(raw, opts) : new PlanError(raw, opts);
   }
   if (status === 429) return new RateLimitError(raw, { retryAfterMs, idempotencyKey });
@@ -326,7 +330,7 @@ function sleep(ms) {
 }
 
 // src/http.ts
-var SDK_VERSION = "0.13.0" ;
+var SDK_VERSION = "0.15.0" ;
 var Transport = class {
   constructor(cfg) {
     this.cfg = cfg;
@@ -430,105 +434,17 @@ var Transport = class {
   }
 };
 
-// src/filters.ts
-function activeQuery(active) {
-  return active === true ? "true" : void 0;
-}
-function filterByActive(rows, active) {
-  return active === false ? rows.filter((row) => !row.isActive) : rows;
+// src/idempotency.ts
+function newKey() {
+  const c = globalThis.crypto;
+  if (typeof c?.randomUUID === "function") return c.randomUUID();
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (ch) => {
+    const r = Math.random() * 16 | 0;
+    const v = ch === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
 }
 
-// src/resources/composites.ts
-var Composites = class {
-  constructor(transport) {
-    this.transport = transport;
-  }
-  transport;
-  /** List composites. Pass `{ active: true }` for only the ones a signal can
-   *  still be tagged with — the default list INCLUDES archived ones, which
-   *  keep every row they already own.
-   *  `{ active: false }` returns only archived ones; omitting it returns
-   *  both. See `activeQuery` — the API itself only supports `true`. */
-  async list(params = {}) {
-    const res = await this.transport.request({
-      method: "GET",
-      path: "/api/v1/composites",
-      query: { active: activeQuery(params.active) }
-    });
-    return filterByActive(res.composites, params.active);
-  }
-  /** Create a composite. `POST /api/v1/composites`. */
-  async create(input) {
-    const res = await this.transport.request({
-      method: "POST",
-      path: "/api/v1/composites",
-      body: input
-    });
-    return res.composite;
-  }
-};
-
-// src/resources/credits.ts
-var Credits = class {
-  constructor(transport) {
-    this.transport = transport;
-  }
-  transport;
-  /** List credit types. Pass `{ active: true }` to only return active ones.
-   *  `{ active: false }` returns only archived ones; omitting it returns
-   *  both. See `activeQuery` — the API itself only supports `true`. */
-  async list(params = {}) {
-    const res = await this.transport.request({
-      method: "GET",
-      path: "/api/v1/credits",
-      query: { active: activeQuery(params.active) }
-    });
-    return filterByActive(res.credits, params.active);
-  }
-  /** Create a credit type; returns the created credit. `POST /api/v1/credits`. */
-  async create(input) {
-    const res = await this.transport.request({
-      method: "POST",
-      path: "/api/v1/credits",
-      body: input
-    });
-    return res.credit;
-  }
-  /** Fetch one credit type with usage stats. `GET /api/v1/credits/:id`. */
-  async get(id) {
-    const res = await this.transport.request({
-      method: "GET",
-      path: `/api/v1/credits/${encodeURIComponent(id)}`
-    });
-    return res.credit;
-  }
-  /** Update a credit type's definition; returns the updated credit. `PATCH /api/v1/credits/:id`. */
-  async update(id, input) {
-    const res = await this.transport.request({
-      method: "PATCH",
-      path: `/api/v1/credits/${encodeURIComponent(id)}`,
-      body: input
-    });
-    return res.credit;
-  }
-  /** Activate or deactivate a credit type. */
-  async setActive(id, isActive) {
-    const res = await this.transport.request({
-      method: "PATCH",
-      path: `/api/v1/credits/${encodeURIComponent(id)}`,
-      body: { isActive }
-    });
-    return res.credit;
-  }
-  /** Delete a credit type. Refused while a customer is linked to it. */
-  async delete(id) {
-    await this.transport.request({
-      method: "DELETE",
-      path: `/api/v1/credits/${encodeURIComponent(id)}`
-    });
-  }
-};
-
 // src/resources/customers.ts
 var Customers = class {
   constructor(transport) {
@@ -582,6 +498,36 @@ var Customers = class {
     });
     return res.customer;
   }
+  /**
+   * Fetch one customer by YOUR id for them (its `externalId`), instead of
+   * ours. Same result as {@link get}. `GET /api/v1/customers/ext/:externalId`.
+   * An unknown external id is a `NotFoundError`; only active customers match.
+   */
+  async getByExternalId(externalId) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: `/api/v1/customers/ext/${encodeURIComponent(externalId)}`
+    });
+    return res.customer;
+  }
+  /** Update a customer (partial), addressed by its `externalId`. Same body as
+   *  {@link update}. `PATCH /api/v1/customers/ext/:externalId`. */
+  async updateByExternalId(externalId, input) {
+    const res = await this.transport.request({
+      method: "PATCH",
+      path: `/api/v1/customers/ext/${encodeURIComponent(externalId)}`,
+      body: input
+    });
+    return res.customer;
+  }
+  /** {@link delete}, addressing the customer by its `externalId`.
+   *  `DELETE /api/v1/customers/ext/:externalId`. */
+  async deleteByExternalId(externalId) {
+    await this.transport.request({
+      method: "DELETE",
+      path: `/api/v1/customers/ext/${encodeURIComponent(externalId)}`
+    });
+  }
   /** Delete a customer (members, invitations, usage logs cascade). */
   async delete(id) {
     await this.transport.request({
@@ -589,15 +535,6 @@ var Customers = class {
       path: `/api/v1/customers/${encodeURIComponent(id)}`
     });
   }
-  /** A customer's usage history. `GET /api/v1/usage?customerId=`. */
-  async usage(id, params = {}) {
-    const res = await this.transport.request({
-      method: "GET",
-      path: `/api/v1/usage`,
-      query: { customerId: id, limit: params.limit }
-    });
-    return { customer: res.customer, totals: res.totals, logs: res.logs };
-  }
   /** Wallet / credit / outcome / unit balances. `GET …/:id/balances`. */
   balances(id) {
     return this.transport.request({
@@ -605,6 +542,14 @@ var Customers = class {
       path: `/api/v1/customers/${encodeURIComponent(id)}/balances`
     });
   }
+  /** {@link balances}, addressing the customer by its `externalId`.
+   *  `GET /api/v1/customers/ext/:externalId/balances`. */
+  balancesByExternalId(externalId) {
+    return this.transport.request({
+      method: "GET",
+      path: `/api/v1/customers/ext/${encodeURIComponent(externalId)}/balances`
+    });
+  }
   /**
    * One credit balance for a customer, matched by `creditId` or `creditName`;
    * `null` when the customer has no plan or no matching credit. Convenience
@@ -643,6 +588,14 @@ var Customers = class {
       path: `/api/v1/customers/${encodeURIComponent(id)}/plan`
     });
   }
+  /** {@link plan}, addressing the customer by its `externalId`.
+   *  `GET /api/v1/customers/ext/:externalId/plan`. */
+  planByExternalId(externalId) {
+    return this.transport.request({
+      method: "GET",
+      path: `/api/v1/customers/ext/${encodeURIComponent(externalId)}/plan`
+    });
+  }
   // --- Members -------------------------------------------------------------
   /** List a customer's members. `GET …/:id/members`. */
   async listMembers(id) {
@@ -678,72 +631,129 @@ var Customers = class {
     });
     return res.member;
   }
-  // --- Wallet & billing config --------------------------------------------
-  /** The customer's wallet balance + transactions. `GET …/:id/wallet`. */
-  wallet(id, params = {}) {
-    return this.transport.request({
-      method: "GET",
-      path: `/api/v1/customers/${encodeURIComponent(id)}/wallet`,
-      query: { limit: params.limit }
-    });
-  }
-  /**
-   * Record a manual wallet entry (top-up or deduction). `amount` is always
-   * positive; the sign comes from `type`. `POST …/:id/wallet`.
-   */
-  async addWalletEntry(id, input) {
-    return this.transport.request({
-      method: "POST",
-      path: `/api/v1/customers/${encodeURIComponent(id)}/wallet`,
-      body: input
-    });
-  }
+  // --- Billing config -----------------------------------------------------
   // Note: a customer's currency is set through `update(id, { currencyCode })`
   // (PATCH …/:id) — there is no separate currency endpoint. Credit-type
   // assignment has no public API.
   // --- Balance adjustments -------------------------------------------------
-  /** Grant or claw back a credit balance. Returns the remaining balance.
-   *  `POST …/:id/credits/adjust`. */
-  async adjustCredit(id, input) {
-    const res = await this.transport.request({
-      method: "POST",
-      path: `/api/v1/customers/${encodeURIComponent(id)}/credits/adjust`,
-      body: input
-    });
-    return { remaining: res.remaining };
+  /** Grant or claw back a credit balance. The credit must be a prepaid part of
+   *  the customer's current plan. Pass `idempotencyKey` to make it safe to
+   *  retry. `POST …/:id/credits/adjust`. */
+  adjustCredit(id, input) {
+    return this.adjust(`/api/v1/customers/${encodeURIComponent(id)}/credits/adjust`, input);
+  }
+  /** Grant or claw back an outcome balance. The outcome must be a prepaid part
+   *  of the customer's current plan. `POST …/:id/outcomes/adjust`. */
+  adjustOutcome(id, input) {
+    return this.adjust(`/api/v1/customers/${encodeURIComponent(id)}/outcomes/adjust`, input);
+  }
+  /** Grant or claw back a unit balance. The unit must be a prepaid part of the
+   *  customer's current plan. `POST …/:id/units/adjust`. */
+  adjustUnit(id, input) {
+    return this.adjust(`/api/v1/customers/${encodeURIComponent(id)}/units/adjust`, input);
+  }
+  /** Grant or claw back slots on a customer's ADVANCE composite pool for the
+   *  current billing cycle. `remaining` is the resulting slot count.
+   *  `POST …/:id/composites/adjust`. */
+  adjustComposite(id, input) {
+    return this.adjust(`/api/v1/customers/${encodeURIComponent(id)}/composites/adjust`, input);
   }
-  /** Grant or claw back an outcome balance. Returns the remaining balance. */
-  async adjustOutcome(id, input) {
+  /**
+   * Top up (positive `delta`) or draw down (negative `delta`) a customer's
+   * wallet, in USD — allowed whatever the customer's plan. `remaining` is the
+   * resulting USD balance. No `agentKey` — a customer has exactly one wallet.
+   * Pass `pool: "RESERVED"` to move the Reserved Wallet instead (then
+   * `remaining` is its balance). `POST …/:id/wallet/adjust`.
+   */
+  adjustWallet(id, input) {
+    return this.adjust(`/api/v1/customers/${encodeURIComponent(id)}/wallet/adjust`, input);
+  }
+  /** {@link adjustCredit}, addressing the customer by its `externalId` (`id`
+   *  here). `POST /api/v1/customers/ext/:externalId/credits/adjust`. */
+  adjustCreditByExternalId(id, input) {
+    return this.adjust(`/api/v1/customers/ext/${encodeURIComponent(id)}/credits/adjust`, input);
+  }
+  /** {@link adjustOutcome}, addressing the customer by its `externalId` (`id`
+   *  here). `POST /api/v1/customers/ext/:externalId/outcomes/adjust`. */
+  adjustOutcomeByExternalId(id, input) {
+    return this.adjust(`/api/v1/customers/ext/${encodeURIComponent(id)}/outcomes/adjust`, input);
+  }
+  /** {@link adjustUnit}, addressing the customer by its `externalId` (`id`
+   *  here). `POST /api/v1/customers/ext/:externalId/units/adjust`. */
+  adjustUnitByExternalId(id, input) {
+    return this.adjust(`/api/v1/customers/ext/${encodeURIComponent(id)}/units/adjust`, input);
+  }
+  /** {@link adjustComposite}, addressing the customer by its `externalId`
+   *  (`id` here). `POST /api/v1/customers/ext/:externalId/composites/adjust`. */
+  adjustCompositeByExternalId(id, input) {
+    return this.adjust(`/api/v1/customers/ext/${encodeURIComponent(id)}/composites/adjust`, input);
+  }
+  /** {@link adjustWallet}, addressing the customer by its `externalId` (`id`
+   *  here). `POST /api/v1/customers/ext/:externalId/wallet/adjust`. */
+  adjustWalletByExternalId(id, input) {
+    return this.adjust(`/api/v1/customers/ext/${encodeURIComponent(id)}/wallet/adjust`, input);
+  }
+  /**
+   * The one body behind all ten adjust calls.
+   *
+   * Every adjustment carries an idempotency key — the caller's, or one
+   * generated here ONCE per call, exactly like signals. The server
+   * deduplicates on it, so a transient failure is safe to retry: the same key
+   * rides every attempt, and a retry of one that already landed comes back as
+   * `replayed: true` instead of adjusting again. The key is also copied onto
+   * any thrown error (`error.idempotencyKey`) so the caller can replay safely.
+   */
+  async adjust(path, input) {
+    const idempotencyKey = input.idempotencyKey ?? newKey();
     const res = await this.transport.request({
       method: "POST",
-      path: `/api/v1/customers/${encodeURIComponent(id)}/outcomes/adjust`,
-      body: input
+      path,
+      idempotencyKey,
+      body: { ...input, idempotencyKey },
+      retry: true
     });
-    return { remaining: res.remaining };
+    const result = {
+      remaining: res.remaining,
+      replayed: res.replayed === true,
+      customerArchived: res.customerArchived === true
+    };
+    if (result.replayed && typeof res.adjustedAt === "string") {
+      result.adjustedAt = res.adjustedAt;
+    }
+    return result;
   }
-  /** Grant or claw back a unit balance. Returns the remaining balance. */
-  async adjustUnit(id, input) {
+  // --- Recurring grants ----------------------------------------------------
+  /**
+   * Change how much a customer is granted every billing cycle (wallet top-up,
+   * credits, outcomes, units or a composite pool). Any increase or decrease
+   * applies to their current balance immediately. `PUT …/:id/recurring-grant`.
+   */
+  async updateRecurringGrant(id, input) {
     const res = await this.transport.request({
-      method: "POST",
-      path: `/api/v1/customers/${encodeURIComponent(id)}/units/adjust`,
+      method: "PUT",
+      path: `/api/v1/customers/${encodeURIComponent(id)}/recurring-grant`,
       body: input
     });
-    return { remaining: res.remaining };
+    return toRecurringGrantResult(res);
   }
-  /**
-   * Grant or claw back slots on a customer's ADVANCE composite pool for the
-   * current billing cycle. Returns the resulting `remaining` slot count.
-   * `POST …/:id/composites/adjust`.
-   */
-  async adjustComposite(id, input) {
+  /** {@link updateRecurringGrant}, addressing the customer by its
+   *  `externalId`. `PUT /api/v1/customers/ext/:externalId/recurring-grant`. */
+  async updateRecurringGrantByExternalId(externalId, input) {
     const res = await this.transport.request({
-      method: "POST",
-      path: `/api/v1/customers/${encodeURIComponent(id)}/composites/adjust`,
+      method: "PUT",
+      path: `/api/v1/customers/ext/${encodeURIComponent(externalId)}/recurring-grant`,
       body: input
     });
-    return { remaining: res.remaining };
+    return toRecurringGrantResult(res);
   }
 };
+function toRecurringGrantResult(res) {
+  return {
+    kind: res.kind,
+    quantity: res.quantity,
+    ...res.balanceUsd !== void 0 ? { balanceUsd: res.balanceUsd } : {}
+  };
+}
 
 // src/resources/invoices.ts
 var Invoices = class {
@@ -772,7 +782,7 @@ var Invoices = class {
     });
   }
   /**
-   * Mint a hosted pay link for an OPEN invoice. PAID/VOID invoices are rejected
+   * Mint a hosted pay link for an OPEN invoice. PAID/VOID/AUTO_CLOSED invoices are rejected
    * with a `ConflictError`. `GET /api/v1/invoices/:id/pay-link`.
    */
   payLink(id) {
@@ -783,67 +793,6 @@ var Invoices = class {
   }
 };
 
-// src/resources/outcomes.ts
-var Outcomes = class {
-  constructor(transport) {
-    this.transport = transport;
-  }
-  transport;
-  /** List outcome types. Pass `{ active: true }` to only return active ones.
-   *  `{ active: false }` returns only archived ones; omitting it returns
-   *  both. See `activeQuery` — the API itself only supports `true`. */
-  async list(params = {}) {
-    const res = await this.transport.request({
-      method: "GET",
-      path: "/api/v1/outcomes",
-      query: { active: activeQuery(params.active) }
-    });
-    return filterByActive(res.outcomes, params.active);
-  }
-  /** Create an outcome type with its steps. `POST /api/v1/outcomes`. */
-  async create(input) {
-    const res = await this.transport.request({
-      method: "POST",
-      path: "/api/v1/outcomes",
-      body: input
-    });
-    return res.outcome;
-  }
-  /** Fetch one outcome type with steps + stats. `GET /api/v1/outcomes/:id`. */
-  async get(id) {
-    const res = await this.transport.request({
-      method: "GET",
-      path: `/api/v1/outcomes/${encodeURIComponent(id)}`
-    });
-    return res.outcome;
-  }
-  /** Update an outcome type's definition. `PATCH /api/v1/outcomes/:id`. */
-  async update(id, input) {
-    const res = await this.transport.request({
-      method: "PATCH",
-      path: `/api/v1/outcomes/${encodeURIComponent(id)}`,
-      body: input
-    });
-    return res.outcome;
-  }
-  /** Activate or deactivate an outcome type; returns the updated outcome. */
-  async setActive(id, isActive) {
-    const res = await this.transport.request({
-      method: "PATCH",
-      path: `/api/v1/outcomes/${encodeURIComponent(id)}`,
-      body: { isActive }
-    });
-    return res.outcome;
-  }
-  /** Delete an outcome type. */
-  async delete(id) {
-    await this.transport.request({
-      method: "DELETE",
-      path: `/api/v1/outcomes/${encodeURIComponent(id)}`
-    });
-  }
-};
-
 // src/resources/payments.ts
 var Payments = class {
   constructor(transport) {
@@ -868,6 +817,14 @@ var Payments = class {
   }
 };
 
+// src/filters.ts
+function activeQuery(active) {
+  return active === true ? "true" : void 0;
+}
+function filterByActive(rows, active) {
+  return active === false ? rows.filter((row) => !row.isActive) : rows;
+}
+
 // src/resources/plans.ts
 var Plans = class {
   constructor(transport) {
@@ -885,48 +842,6 @@ var Plans = class {
     });
     return filterByActive(res.plans, params.active);
   }
-  /** Create a plan. `POST /api/v1/plans`. */
-  async create(input) {
-    const res = await this.transport.request({
-      method: "POST",
-      path: "/api/v1/plans",
-      body: input
-    });
-    return res.plan;
-  }
-  /** Fetch one plan with aggregate subscriber/invoice stats. `GET /api/v1/plans/:id`. */
-  async get(id) {
-    const res = await this.transport.request({
-      method: "GET",
-      path: `/api/v1/plans/${encodeURIComponent(id)}`
-    });
-    return res.plan;
-  }
-  /** Replace a plan's definition (components + settings). `PATCH /api/v1/plans/:id`. */
-  async update(id, input) {
-    const res = await this.transport.request({
-      method: "PATCH",
-      path: `/api/v1/plans/${encodeURIComponent(id)}`,
-      body: input
-    });
-    return res.plan;
-  }
-  /** Activate or deactivate a plan without rewriting it. */
-  async setActive(id, isActive) {
-    const res = await this.transport.request({
-      method: "PATCH",
-      path: `/api/v1/plans/${encodeURIComponent(id)}`,
-      body: { isActive }
-    });
-    return res.plan;
-  }
-  /** Delete a plan. Refused once any customer has purchased it. */
-  async delete(id) {
-    await this.transport.request({
-      method: "DELETE",
-      path: `/api/v1/plans/${encodeURIComponent(id)}`
-    });
-  }
 };
 
 // src/resources/portal.ts
@@ -1009,15 +924,12 @@ var Purchases = class {
   }
 };
 
-// src/idempotency.ts
-function newKey() {
-  const c = globalThis.crypto;
-  if (typeof c?.randomUUID === "function") return c.randomUUID();
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (ch) => {
-    const r = Math.random() * 16 | 0;
-    const v = ch === "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
+// src/customer-ref.ts
+function customerRefToWire(ref) {
+  return {
+    ...ref.customerId != null ? { customerId: ref.customerId } : {},
+    ...ref.externalId != null ? { externalId: ref.externalId } : {}
+  };
 }
 
 // src/resources/signals.ts
@@ -1029,10 +941,11 @@ var SIGNAL_PATHS = {
 var UNIT_PATH = "/api/v1/signal/unit";
 var COMPOSITE_COMPLETE_PATH = "/api/v1/signal/composite/complete";
 var OUTCOME_COMPLETE_PATH = "/api/v1/signal/outcome/complete";
+var USAGE_LOG_PATH = "/api/v1/signal/usage-log";
 function signalToWire(signal) {
   const t = signal.tokens;
   const body = {
-    customerId: signal.customerId,
+    ...customerRefToWire(signal),
     // `usage` is required on all three model-priced kinds. input/output are
     // always sent; `cacheTokens` only when provided (the server defaults 0).
     usage: {
@@ -1143,9 +1056,8 @@ var Signals = class {
       path: OUTCOME_COMPLETE_PATH,
       idempotencyKey,
       body: {
-        customerId: input.customerId,
+        ...customerRefToWire(input),
         runId: input.runId,
-        complete: true,
         ...input.member ? { member: input.member } : {},
         idempotencyKey
       },
@@ -1160,23 +1072,6 @@ var Signals = class {
       ...handles(res)
     };
   }
-  /**
-   * Recent usage logs + totals for a customer. `GET /api/v1/usage`.
-   *
-   * Still the legacy path, deliberately. The `/api/v1/signal/*` family is
-   * POST-only — it replaced how usage is INGESTED, not how it is read — so
-   * `GET /api/v1/usage` has no successor and is not deprecated. It is also the
-   * only way to prove a signal landed, which matters more now that ingestion
-   * answers `202` for everything.
-   */
-  async list(params) {
-    const res = await this.transport.request({
-      method: "GET",
-      path: "/api/v1/usage",
-      query: { customerId: params.customerId, limit: params.limit }
-    });
-    return { customer: res.customer, totals: res.totals, logs: res.logs };
-  }
   /**
    * Record one unit-metered event (a fixed-price meter with no tokens),
    * addressed to a catalog unit by its `agentKey`. Sent immediately — unit
@@ -1196,7 +1091,7 @@ var Signals = class {
       path: UNIT_PATH,
       idempotencyKey,
       body: {
-        customerId: input.customerId,
+        ...customerRefToWire(input),
         agentKey: input.agentKey,
         ...input.quantity != null ? { quantity: input.quantity } : {},
         ...input.member ? { member: input.member } : {},
@@ -1253,7 +1148,7 @@ var Signals = class {
       path: COMPOSITE_COMPLETE_PATH,
       idempotencyKey,
       body: {
-        customerId: input.customerId,
+        ...customerRefToWire(input),
         composite: { [input.composite.ref]: input.composite.value },
         // Auto-assigned like the others. A retry here could not double-BILL
         // even without it — closing a closed occurrence is a server-side
@@ -1275,147 +1170,45 @@ var Signals = class {
     };
   }
   /**
-   * A customer's unit balances + recent unit events. `GET /api/v1/units`.
+   * One customer's usage history, merged from every meter kind — credit,
+   * outcome, unit, wallet, and completed composite occurrences — into one
+   * feed sorted by time. `GET /api/v1/signal/usage-log`. Exactly the same
+   * rows the customer portal's own "Usage logs" table shows, so a caller can
+   * build against this instead of the portal UI.
+   *
+   * Cursor-paginated, NOT page-numbered: `limit` + `cursor` in, `nextCursor`
+   * out. Omit `cursor` for the first page; pass the previous page's
+   * `nextCursor` back to fetch the next one, and stop once it comes back
+   * `null`. Unlike offset pagination, the cost of a page never grows with how
+   * deep you've paged — each page only asks for rows strictly before the
+   * cursor's position.
    *
-   * Legacy path for the same reason as {@link list}: the signal family is
-   * POST-only, so the read side has no successor and is not deprecated.
+   * Read-only; unlike {@link track}/{@link unit}/etc., there is nothing to
+   * buffer or retry here.
    */
-  unitUsage(params) {
+  usageLog(params) {
     return this.transport.request({
       method: "GET",
-      path: "/api/v1/units",
-      query: { customerId: params.customerId, limit: params.limit }
-    });
-  }
-};
-
-// src/resources/units.ts
-var Units = class {
-  constructor(transport) {
-    this.transport = transport;
-  }
-  transport;
-  /** List unit types. Pass `{ active: true }` to only return active ones.
-   *  `{ active: false }` returns only archived ones; omitting it returns
-   *  both. See `activeQuery` — the API itself only supports `true`. */
-  async list(params = {}) {
-    const res = await this.transport.request({
-      method: "GET",
-      path: "/api/v1/units-catalog",
-      query: { active: activeQuery(params.active) }
-    });
-    return filterByActive(res.units, params.active);
-  }
-  /** Create a unit type. `POST /api/v1/units-catalog`. */
-  async create(input) {
-    const res = await this.transport.request({
-      method: "POST",
-      path: "/api/v1/units-catalog",
-      body: input
-    });
-    return res.unit;
-  }
-  /** Fetch one unit type with stats. `GET /api/v1/units-catalog/:id`. */
-  async get(id) {
-    const res = await this.transport.request({
-      method: "GET",
-      path: `/api/v1/units-catalog/${encodeURIComponent(id)}`
-    });
-    return res.unit;
-  }
-  /** Update a unit type's definition. `PATCH /api/v1/units-catalog/:id`. */
-  async update(id, input) {
-    const res = await this.transport.request({
-      method: "PATCH",
-      path: `/api/v1/units-catalog/${encodeURIComponent(id)}`,
-      body: input
-    });
-    return res.unit;
-  }
-  /** Activate or deactivate a unit type. */
-  async setActive(id, isActive) {
-    const res = await this.transport.request({
-      method: "PATCH",
-      path: `/api/v1/units-catalog/${encodeURIComponent(id)}`,
-      body: { isActive }
-    });
-    return res.unit;
-  }
-  /** Delete a unit type. */
-  async delete(id) {
-    await this.transport.request({
-      method: "DELETE",
-      path: `/api/v1/units-catalog/${encodeURIComponent(id)}`
-    });
-  }
-};
-
-// src/resources/webhooks.ts
-var Webhooks = class {
-  constructor(transport) {
-    this.transport = transport;
-  }
-  transport;
-  /** List configured webhooks. `GET /api/v1/webhooks`. */
-  async list() {
-    const res = await this.transport.request({
-      method: "GET",
-      path: "/api/v1/webhooks"
-    });
-    return res.webhooks;
-  }
-  /** Create or replace the webhook for a kind. `POST /api/v1/webhooks`. */
-  async upsert(input) {
-    const res = await this.transport.request({
-      method: "POST",
-      path: "/api/v1/webhooks",
-      body: input
-    });
-    return res.webhook;
-  }
-  /** Delete the webhook for a kind (idempotent). `DELETE /api/v1/webhooks/:kind`. */
-  async delete(kind) {
-    await this.transport.request({
-      method: "DELETE",
-      path: `/api/v1/webhooks/${encodeURIComponent(kind)}`
-    });
-  }
-};
-
-// src/resources/workspace.ts
-var Workspace = class {
-  constructor(transport) {
-    this.transport = transport;
-  }
-  transport;
-  /** Identify the org + key behind the request, incl. `sandbox` | `live`. */
-  me() {
-    return this.transport.request({
-      method: "GET",
-      path: "/api/v1/me"
-    });
-  }
-  /** The org's enabled models with live prices. `{ active: true }` returns only
-   *  the models that can be metered right now.
-   *  `{ active: false }` returns only archived ones; omitting it returns
-   *  both. See `activeQuery` — the API itself only supports `true`. */
-  async models(params = {}) {
-    const res = await this.transport.request({
-      method: "GET",
-      path: "/api/v1/models",
-      query: { active: activeQuery(params.active) }
+      path: USAGE_LOG_PATH,
+      query: {
+        customerId: params.customerId,
+        limit: params.limit,
+        cursor: params.cursor,
+        period: params.period,
+        from: params.from,
+        to: params.to
+      }
     });
-    return filterByActive(res.models, params.active);
   }
 };
 
 // src/client.ts
 var ClockNext = class {
-  /** Record + read usage signals (credit / wallet / outcome / unit). */
+  /** Record usage signals (credit / wallet / outcome / unit) and read the usage log. */
   signals;
-  /** Manage customers, their members, wallet, and balances. */
+  /** Manage customers, their members, and balances. */
   customers;
-  /** Define and manage billing plans. */
+  /** List billing plans. */
   plans;
   /** Subscribe customers to plans (purchases). */
   purchases;
@@ -1423,20 +1216,8 @@ var ClockNext = class {
   invoices;
   /** Read payments (paid invoices). */
   payments;
-  /** Manage the credit-type catalog. */
-  credits;
-  /** Manage the composite catalog — bundles billed as one thing. */
-  composites;
-  /** Manage the outcome-type catalog. */
-  outcomes;
-  /** Manage the unit-type catalog. */
-  units;
-  /** Configure threshold webhooks. */
-  webhooks;
   /** Mint customer-portal embed tokens. */
   portal;
-  /** Identify the workspace (sandbox/live) + list its models. `/me`, `/models`. */
-  workspace;
   cfg;
   flusher;
   constructor(config) {
@@ -1454,13 +1235,7 @@ var ClockNext = class {
     this.purchases = new Purchases(transport);
     this.invoices = new Invoices(transport);
     this.payments = new Payments(transport);
-    this.credits = new Credits(transport);
-    this.composites = new Composites(transport);
-    this.outcomes = new Outcomes(transport);
-    this.units = new Units(transport);
-    this.webhooks = new Webhooks(transport);
     this.portal = new Portal(transport);
-    this.workspace = new Workspace(transport);
   }
   /** Number of signals currently buffered (async mode). */
   get pending() {