@clocknext/sdk 0.1.0 → 0.4.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/config.ts
-var DEFAULT_BASE_URL = "https://app.clocknext.com";
+var DEFAULT_BASE_URL = "https://payments.clocknext.com";
 function num(value, fallback, min) {
   return typeof value === "number" && Number.isFinite(value) && value >= min ? value : fallback;
 }
@@ -121,7 +121,8 @@ var Flusher = class {
         method: "POST",
         path: "/api/v1/usage",
         body: item.body,
-        idempotencyKey: item.idempotencyKey
+        // Best-effort metering opts into retries on transient failures.
+        retry: true
       });
       return true;
     } catch (error) {
@@ -144,15 +145,12 @@ var Flusher = class {
 var ClockNextError = class extends Error {
   /** HTTP status, when the failure came from a server response. */
   status;
-  /** The idempotency key of the offending signal, when applicable. */
-  idempotencyKey;
   /** Whether the SDK considers this failure worth retrying. */
   retryable;
   constructor(message, opts = {}) {
     super(message);
     this.name = new.target.name;
     this.status = opts.status;
-    this.idempotencyKey = opts.idempotencyKey;
     this.retryable = opts.retryable ?? false;
     Object.setPrototypeOf(this, new.target.prototype);
   }
@@ -172,28 +170,29 @@ var ConflictError = class extends ClockNextError {
 var RateLimitError = class extends ClockNextError {
   retryAfterMs;
   constructor(message, opts = {}) {
-    super(message, { status: 429, idempotencyKey: opts.idempotencyKey, retryable: true });
+    super(message, { status: 429, retryable: true });
     this.retryAfterMs = opts.retryAfterMs;
   }
 };
 var ServerError = class extends ClockNextError {
 };
 var NetworkError = class extends ClockNextError {
-  constructor(message, opts = {}) {
-    super(message, { idempotencyKey: opts.idempotencyKey, retryable: true });
+  constructor(message) {
+    super(message, { retryable: true });
   }
 };
-function errorFromResponse(status, message, idempotencyKey, retryAfterMs) {
+function errorFromResponse(status, message, retryAfterMs) {
   const msg = message || `Request failed with status ${status}.`;
-  const opts = { status, idempotencyKey };
+  const opts = { status };
   if (status === 400) return new ValidationError(msg, opts);
   if (status === 401) return new AuthError(msg, opts);
   if (status === 404) return new NotFoundError(msg, opts);
+  if (status === 408) return new ClockNextError(msg, { ...opts, retryable: true });
   if (status === 409) return new ConflictError(msg, { ...opts, retryable: true });
   if (status === 422) {
     return /insufficient/i.test(msg) ? new AllowanceError(msg, opts) : new PlanError(msg, opts);
   }
-  if (status === 429) return new RateLimitError(msg, { idempotencyKey, retryAfterMs });
+  if (status === 429) return new RateLimitError(msg, { retryAfterMs });
   if (status >= 500) return new ServerError(msg, { ...opts, retryable: true });
   return new ClockNextError(msg, opts);
 }
@@ -228,7 +227,7 @@ function sleep(ms) {
 }
 
 // src/http.ts
-var SDK_VERSION = "0.1.0";
+var SDK_VERSION = "0.4.0" ;
 var Transport = class {
   constructor(cfg) {
     this.cfg = cfg;
@@ -236,8 +235,9 @@ var Transport = class {
   cfg;
   async request(opts) {
     const url = this.buildUrl(opts.path, opts.query);
-    const replaySafe = opts.method === "GET" || opts.method === "DELETE" || opts.idempotencyKey != null;
-    const maxAttempts = opts.retry === false || !replaySafe ? 1 : this.cfg.retry.maxAttempts;
+    const replaySafe = opts.method === "GET" || opts.method === "PUT" || opts.method === "DELETE";
+    const allowRetry = opts.retry ?? replaySafe;
+    const maxAttempts = allowRetry ? this.cfg.retry.maxAttempts : 1;
     let attempt = 0;
     while (true) {
       attempt++;
@@ -271,7 +271,7 @@ var Transport = class {
       });
     } catch (err) {
       const message2 = controller.signal.aborted ? `Request to ${opts.path} timed out after ${this.cfg.timeoutMs}ms.` : `Network error calling ${opts.path}: ${err instanceof Error ? err.message : String(err)}`;
-      throw new NetworkError(message2, { idempotencyKey: opts.idempotencyKey });
+      throw new NetworkError(message2);
     } finally {
       clearTimeout(timer);
     }
@@ -291,24 +291,14 @@ var Transport = class {
         return obj.result ?? {};
       }
       const message2 = detail?.message ?? `Request failed with status ${res.status}.`;
-      throw errorFromResponse(
-        res.status,
-        message2,
-        opts.idempotencyKey,
-        parseRetryAfter(res.headers)
-      );
+      throw errorFromResponse(res.status, message2, parseRetryAfter(res.headers));
     }
     const envelope = obj;
     if (res.ok && envelope.ok !== false) {
       return envelope;
     }
     const message = envelope.error ?? text ?? `Request failed with status ${res.status}.`;
-    throw errorFromResponse(
-      res.status,
-      message,
-      opts.idempotencyKey,
-      parseRetryAfter(res.headers)
-    );
+    throw errorFromResponse(res.status, message, parseRetryAfter(res.headers));
   }
   headers(opts) {
     const h = {
@@ -316,7 +306,6 @@ var Transport = class {
       "User-Agent": `clocknext-sdk-js/${SDK_VERSION}`
     };
     if (opts.body !== void 0) h["Content-Type"] = "application/json";
-    if (opts.idempotencyKey) h["Idempotency-Key"] = opts.idempotencyKey;
     return h;
   }
   buildUrl(path, query) {
@@ -333,6 +322,63 @@ var Transport = class {
   }
 };
 
+// src/resources/credits.ts
+var Credits = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /** List credit types. Pass `{ active: true }` to only return active ones. */
+  async list(params = {}) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: "/api/v1/credits",
+      query: { active: params.active === void 0 ? void 0 : String(params.active) }
+    });
+    return res.credits;
+  }
+  /** Create a credit type. `POST /api/v1/credits`. */
+  async create(input) {
+    await this.transport.request({
+      method: "POST",
+      path: "/api/v1/credits",
+      body: input
+    });
+  }
+  /** 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. `PATCH /api/v1/credits/:id`. */
+  async update(id, input) {
+    await this.transport.request({
+      method: "PATCH",
+      path: `/api/v1/credits/${encodeURIComponent(id)}`,
+      body: input
+    });
+  }
+  /** 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) {
@@ -424,6 +470,269 @@ var Customers = class {
       query: { range: params.range }
     });
   }
+  // --- Members -------------------------------------------------------------
+  /** List a customer's members. `GET …/:id/members`. */
+  async listMembers(id) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: `/api/v1/customers/${encodeURIComponent(id)}/members`
+    });
+    return res.members;
+  }
+  /** Add a member to a customer. Duplicate `employeeId` → ConflictError. */
+  async addMember(id, input) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/customers/${encodeURIComponent(id)}/members`,
+      body: input
+    });
+    return res.member;
+  }
+  /** Update a member's profile (role is fixed). `PATCH …/:id/members/:memberId`. */
+  async updateMember(id, memberId, input) {
+    const res = await this.transport.request({
+      method: "PATCH",
+      path: `/api/v1/customers/${encodeURIComponent(id)}/members/${encodeURIComponent(memberId)}`,
+      body: input
+    });
+    return res.member;
+  }
+  /** Remove a member from a customer. `DELETE …/:id/members/:memberId`. */
+  async removeMember(id, memberId) {
+    await this.transport.request({
+      method: "DELETE",
+      path: `/api/v1/customers/${encodeURIComponent(id)}/members/${encodeURIComponent(memberId)}`
+    });
+  }
+  // --- 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
+    });
+  }
+  // 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. `POST …/:id/credits/adjust`. */
+  async adjustCredit(id, input) {
+    await this.transport.request({
+      method: "POST",
+      path: `/api/v1/customers/${encodeURIComponent(id)}/credits/adjust`,
+      body: input
+    });
+  }
+  /** Grant or claw back an outcome balance. Returns the remaining balance. */
+  async adjustOutcome(id, input) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/customers/${encodeURIComponent(id)}/outcomes/adjust`,
+      body: input
+    });
+    return { remaining: res.remaining };
+  }
+  /** Grant or claw back a unit balance. Returns the remaining balance. */
+  async adjustUnit(id, input) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: `/api/v1/customers/${encodeURIComponent(id)}/units/adjust`,
+      body: input
+    });
+    return { remaining: res.remaining };
+  }
+};
+
+// src/resources/invoices.ts
+var Invoices = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /** List invoices, most-recent first. Filter by customer and/or status. */
+  async list(params = {}) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: "/api/v1/invoices",
+      query: {
+        customerId: params.customerId,
+        status: params.status,
+        limit: params.limit
+      }
+    });
+    return res.invoices;
+  }
+  /** Fetch one full invoice + its plan snapshot. `GET /api/v1/invoices/:id`. */
+  get(id) {
+    return this.transport.request({
+      method: "GET",
+      path: `/api/v1/invoices/${encodeURIComponent(id)}`
+    });
+  }
+  /**
+   * Mint a hosted pay link for an OPEN invoice. PAID/VOID invoices are rejected
+   * with a `ConflictError`. `GET /api/v1/invoices/:id/pay-link`.
+   */
+  payLink(id) {
+    return this.transport.request({
+      method: "GET",
+      path: `/api/v1/invoices/${encodeURIComponent(id)}/pay-link`
+    });
+  }
+};
+
+// src/resources/outcomes.ts
+var Outcomes = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /** List outcome types. Pass `{ active: true }` to only return active ones. */
+  async list(params = {}) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: "/api/v1/outcomes",
+      query: { active: params.active === void 0 ? void 0 : String(params.active) }
+    });
+    return res.outcomes;
+  }
+  /** 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. */
+  async setActive(id, isActive) {
+    await this.transport.request({
+      method: "PATCH",
+      path: `/api/v1/outcomes/${encodeURIComponent(id)}`,
+      body: { isActive }
+    });
+  }
+  /** 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) {
+    this.transport = transport;
+  }
+  transport;
+  /** List payments (paid invoices), most-recent first. Filter by customer. */
+  async list(params = {}) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: "/api/v1/payments",
+      query: { customerId: params.customerId, limit: params.limit }
+    });
+    return res.payments;
+  }
+  /** Fetch one payment + its plan snapshot. `GET /api/v1/payments/:id`. */
+  get(id) {
+    return this.transport.request({
+      method: "GET",
+      path: `/api/v1/payments/${encodeURIComponent(id)}`
+    });
+  }
+};
+
+// src/resources/plans.ts
+var Plans = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /** List plans, oldest-first. Pass `{ active: true }` to only return active plans. */
+  async list(params = {}) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: "/api/v1/plans",
+      query: { active: params.active === void 0 ? void 0 : String(params.active) }
+    });
+    return res.plans;
+  }
+  /** 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
@@ -450,20 +759,71 @@ var Portal = class {
   }
 };
 
+// src/resources/purchases.ts
+var Purchases = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  /** List purchases, most-recent first. Filter by customer and/or status. */
+  async list(params = {}) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: "/api/v1/purchases",
+      query: {
+        customerId: params.customerId,
+        status: params.status,
+        limit: params.limit
+      }
+    });
+    return res.purchases;
+  }
+  /** Subscribe a customer to a plan. `POST /api/v1/purchases`. */
+  async create(input) {
+    const res = await this.transport.request({
+      method: "POST",
+      path: "/api/v1/purchases",
+      body: input
+    });
+    return res.purchase;
+  }
+  /** Fetch one purchase. `GET /api/v1/purchases/:id`. */
+  async get(id) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: `/api/v1/purchases/${encodeURIComponent(id)}`
+    });
+    return res.purchase;
+  }
+  /**
+   * Turn automatic billing on or off for a purchase. When pausing, an optional
+   * `pauseReason` is recorded. `PATCH /api/v1/purchases/:id`.
+   */
+  async setAutoPayment(id, autoPayment, opts = {}) {
+    return this.transport.request({
+      method: "PATCH",
+      path: `/api/v1/purchases/${encodeURIComponent(id)}`,
+      body: { autoPayment, pauseReason: opts.pauseReason }
+    });
+  }
+  /** Cancel a purchase (voids any open invoice). `POST /api/v1/purchases/:id/cancel`. */
+  async cancel(id) {
+    await this.transport.request({
+      method: "POST",
+      path: `/api/v1/purchases/${encodeURIComponent(id)}/cancel`
+    });
+  }
+};
+
 // src/idempotency.ts
-function newIdempotencyKey() {
-  const webcrypto = globalThis.crypto;
-  if (webcrypto?.randomUUID) return webcrypto.randomUUID();
-  const b = new Uint8Array(16);
-  if (webcrypto?.getRandomValues) {
-    webcrypto.getRandomValues(b);
-  } else {
-    for (let i = 0; i < 16; i++) b[i] = Math.floor(Math.random() * 256);
-  }
-  b[6] = b[6] & 15 | 64;
-  b[8] = b[8] & 63 | 128;
-  const hex = Array.from(b, (n) => n.toString(16).padStart(2, "0")).join("");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+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/signals.ts
@@ -474,18 +834,15 @@ function signalToWire(signal) {
     model: signal.model
   };
   if (signal.member) body.member = signal.member;
-  if (signal.status) body.status = signal.status;
   if (signal.custom) body.custom = signal.custom;
-  if (signal.idempotencyKey) body.idempotencyKey = signal.idempotencyKey;
   const t = signal.tokens;
-  if (t) {
-    if (t.input != null) body.inputTokens = t.input;
-    if (t.output != null) body.outputTokens = t.output;
-    if (t.cache != null) body.cacheTokens = t.cache;
-  }
+  body.inputTokens = t.input;
+  body.outputTokens = t.output;
+  if (t.cache != null) body.cacheTokens = t.cache;
   if (signal.type === "credit" || signal.type === "outcome") {
-    body.key = signal.key;
+    body.agentKey = signal.agentKey;
   }
+  if (signal.idempotencyKey) body.idempotencyKey = signal.idempotencyKey;
   return body;
 }
 var Signals = class {
@@ -498,25 +855,42 @@ var Signals = class {
   flusher;
   cfg;
   async track(signal, opts = {}) {
-    const idempotencyKey = signal.idempotencyKey ?? newIdempotencyKey();
-    const body = signalToWire({ ...signal, idempotencyKey });
+    const body = signalToWire(signal);
+    if (body.idempotencyKey == null) body.idempotencyKey = newKey();
     const sendNow = opts.wait || this.cfg.mode === "sync";
     if (!sendNow) {
-      this.flusher.enqueue({ body, idempotencyKey, signal });
-      return { idempotencyKey, queued: true };
+      this.flusher.enqueue({ body, signal });
+      return { queued: true };
     }
     const res = await this.transport.request({
       method: "POST",
       path: "/api/v1/usage",
       body,
-      idempotencyKey
+      // Best-effort metering opts into retries on transient failures.
+      retry: true
     });
     return {
-      idempotencyKey,
       queued: false,
       usageLog: res.usageLog ?? null
     };
   }
+  /**
+   * Validate + price a signal WITHOUT recording it (server `dryRun`). Returns
+   * the projected usage log so an integration can preflight before sending real
+   * traffic — no inbox row, wallet / outcome writes, or webhooks fire.
+   */
+  async verify(signal) {
+    const body = signalToWire(signal);
+    body.dryRun = true;
+    const res = await this.transport.request({
+      method: "POST",
+      path: "/api/v1/usage",
+      body,
+      // A dry run writes nothing, so it is always safe to retry.
+      retry: true
+    });
+    return res.usageLog ?? null;
+  }
   /** Meter a named credit. */
   credit(input, opts) {
     return this.track({ ...input, type: "credit" }, opts);
@@ -538,16 +912,178 @@ var Signals = class {
     });
     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
+   * events are not buffered. `POST /api/v1/units`.
+   */
+  async unit(input) {
+    return this.transport.request({
+      method: "POST",
+      path: "/api/v1/units",
+      body: {
+        customerId: input.customerId,
+        agentKey: input.agentKey,
+        ...input.member ? { member: input.member } : {}
+      },
+      // Best-effort metering opts into retries on transient failures.
+      retry: true
+    });
+  }
+  /** A customer's unit balances + recent unit events. `GET /api/v1/units`. */
+  unitUsage(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. */
+  async list(params = {}) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: "/api/v1/units-catalog",
+      query: { active: params.active === void 0 ? void 0 : String(params.active) }
+    });
+    return res.units;
+  }
+  /** 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. */
+  async models(params = {}) {
+    const res = await this.transport.request({
+      method: "GET",
+      path: "/api/v1/models",
+      query: {
+        active: params.active === void 0 ? void 0 : String(params.active)
+      }
+    });
+    return res.models;
+  }
 };
 
 // src/client.ts
 var ClockNext = class {
-  /** Record + read usage signals. */
+  /** Record + read usage signals (credit / wallet / outcome / unit). */
   signals;
-  /** Manage customers and read their insights. */
+  /** Manage customers, their members, wallet, and balances. */
   customers;
+  /** Define and manage billing plans. */
+  plans;
+  /** Subscribe customers to plans (purchases). */
+  purchases;
+  /** Read invoices and mint hosted pay links. */
+  invoices;
+  /** Read payments (paid invoices). */
+  payments;
+  /** Manage the credit-type catalog. */
+  credits;
+  /** 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) {
@@ -561,7 +1097,16 @@ var ClockNext = class {
     this.flusher = new Flusher(transport, this.cfg);
     this.signals = new Signals(transport, this.flusher, this.cfg);
     this.customers = new Customers(transport);
+    this.plans = new Plans(transport);
+    this.purchases = new Purchases(transport);
+    this.invoices = new Invoices(transport);
+    this.payments = new Payments(transport);
+    this.credits = new Credits(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() {
@@ -577,6 +1122,6 @@ var ClockNext = class {
   }
 };
 
-export { AllowanceError, AuthError, ClockNext, ClockNextError, ConflictError, NetworkError, NotFoundError, PlanError, RateLimitError, ServerError, ValidationError, newIdempotencyKey, signalToWire };
+export { AllowanceError, AuthError, ClockNext, ClockNextError, ConflictError, NetworkError, NotFoundError, PlanError, RateLimitError, ServerError, ValidationError, signalToWire };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map