@commet/node 4.6.0 → 5.0.0

package/dist/index.js

@@ -35,7 +35,6 @@ __export(index_exports, {
   CommetAPIError: () => CommetAPIError,
   CommetError: () => CommetError,
   CommetValidationError: () => CommetValidationError,
-  CustomerContext: () => CustomerContext,
   SDK_VERSION: () => SDK_VERSION,
   Webhooks: () => Webhooks,
   createCommet: () => createCommet,
@@ -45,82 +44,54 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/customer.ts
-var CustomerContext = class {
-  constructor(customerId, resources) {
-    this.features = {
-      get: (code, options) => this.featuresResource.get({ code, customerId: this.customerId }, options),
-      check: (code, options) => this.featuresResource.check(
-        { code, customerId: this.customerId },
-        options
-      ),
-      canUse: (code, options) => this.featuresResource.canUse(
-        { code, customerId: this.customerId },
-        options
-      ),
-      list: (options) => this.featuresResource.list(this.customerId, options)
-    };
-    this.seats = {
-      add: (featureCode, count = 1, options) => this.seatsResource.add(
-        { customerId: this.customerId, featureCode, count },
-        options
-      ),
-      remove: (featureCode, count = 1, options) => this.seatsResource.remove(
-        { customerId: this.customerId, featureCode, count },
-        options
-      ),
-      set: (featureCode, count, options) => this.seatsResource.set(
-        { customerId: this.customerId, featureCode, count },
-        options
-      ),
-      getBalance: (featureCode) => this.seatsResource.getBalance({
-        customerId: this.customerId,
-        featureCode
-      })
-    };
-    this.usage = {
-      track: (feature, value, properties, options) => this.usageResource.track(
-        { customerId: this.customerId, feature, value, properties },
-        options
-      )
-    };
-    this.subscription = {
-      get: () => this.subscriptionsResource.get(this.customerId)
-    };
-    this.portal = {
-      getUrl: (options) => this.portalResource.getUrl({ customerId: this.customerId }, options)
-    };
-    this.customerId = customerId;
-    this.featuresResource = resources.features;
-    this.seatsResource = resources.seats;
-    this.usageResource = resources.usage;
-    this.subscriptionsResource = resources.subscriptions;
-    this.portalResource = resources.portal;
-  }
-};
-
 // src/resources/addons.ts
 var AddonsResource = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
   }
-  /**
-   * Get active addons for a customer's subscription
-   *
-   * @example
-   * ```typescript
-   * const { data } = await commet.addons.getActive({
-   *   customerId: 'cus_xxx',
-   * });
-   * ```
-   */
-  async getActive(params, options) {
+  async listActive(params, options) {
     return this.httpClient.get(
       "/addons/active",
       { customerId: params.customerId },
       options
     );
   }
+  async list(params, options) {
+    return this.httpClient.get("/addons", params, options);
+  }
+  async get(params, options) {
+    const { id } = params;
+    return this.httpClient.get(`/addons/${id}`, void 0, options);
+  }
+  async create(params, options) {
+    return this.httpClient.post("/addons", params, options);
+  }
+  async update(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.put(`/addons/${id}`, body, options);
+  }
+  /** Fails if addon has active subscriptions. */
+  async delete(params, options) {
+    const { id } = params;
+    return this.httpClient.delete(`/addons/${id}`, void 0, options);
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeysResource = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async list(params) {
+    return this.httpClient.get("/api-keys", params);
+  }
+  /** Response includes full `apiKey` which is only returned once. */
+  async create(params, options) {
+    return this.httpClient.post("/api-keys", params, options);
+  }
+  async delete(params, options) {
+    return this.httpClient.delete(`/api-keys/${params.id}`, void 0, options);
+  }
 };
 
 // src/resources/credit-packs.ts
@@ -128,18 +99,20 @@ var CreditPacksResource = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
   }
-  /**
-   * List all active credit packs
-   *
-   * @example
-   * ```typescript
-   * const packs = await commet.creditPacks.list();
-   * console.log(packs.data); // [{ id: "cp_xxx", name: "100 Credits", ... }]
-   * ```
-   */
   async list() {
     return this.httpClient.get("/credit-packs");
   }
+  async create(params, options) {
+    return this.httpClient.post("/credit-packs/manage", params, options);
+  }
+  async update(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.put(`/credit-packs/${id}`, body, options);
+  }
+  async delete(params, options) {
+    const { id } = params;
+    return this.httpClient.delete(`/credit-packs/${id}`, void 0, options);
+  }
 };
 
 // src/resources/customers.ts
@@ -147,15 +120,13 @@ var CustomersResource = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
   }
-  /**
-   * Create a customer (idempotent when id is provided)
-   */
+  /** Idempotent when `id` is provided — returns existing customer instead of duplicating. */
   async create(params, options) {
     return this.httpClient.post(
       "/customers",
       {
         billingEmail: params.email,
-        externalId: params.id,
+        id: params.id,
         fullName: params.fullName,
         domain: params.domain,
         website: params.website,
@@ -168,13 +139,10 @@ var CustomersResource = class {
       options
     );
   }
-  /**
-   * Create multiple customers in batch
-   */
   async createBatch(params, options) {
     const customers = params.customers.map((c) => ({
       billingEmail: c.email,
-      externalId: c.id,
+      id: c.id,
       fullName: c.fullName,
       domain: c.domain,
       website: c.website,
@@ -186,18 +154,12 @@ var CustomersResource = class {
     }));
     return this.httpClient.post("/customers/batch", { customers }, options);
   }
-  /**
-   * Get a customer by ID
-   */
-  async get(customerId) {
-    return this.httpClient.get(`/customers/${customerId}`);
+  async get(params) {
+    return this.httpClient.get(`/customers/${params.id}`);
   }
-  /**
-   * Update a customer
-   */
   async update(params, options) {
     return this.httpClient.put(
-      `/customers/${params.customerId}`,
+      `/customers/${params.id}`,
       {
         billingEmail: params.email,
         fullName: params.fullName,
@@ -212,9 +174,6 @@ var CustomersResource = class {
       options
     );
   }
-  /**
-   * List customers with optional filters
-   */
   async list(params) {
     return this.httpClient.get("/customers", params);
   }
@@ -232,34 +191,113 @@ var FeaturesResource = class {
       options
     );
   }
-  async check(params, options) {
-    const result = await this.httpClient.get(
+  /** Checks if the customer can consume one more unit — returns billing impact and reason if blocked. */
+  async canUse(params, options) {
+    return this.httpClient.get(
       `/features/${params.code}`,
-      { customerId: params.customerId },
+      { customerId: params.customerId, action: "canUse" },
       options
     );
-    if (!result.success || !result.data) {
-      return {
-        success: false,
-        code: result.code,
-        message: result.message,
-        details: result.details
-      };
-    }
-    return {
-      success: true,
-      data: { allowed: result.data.allowed }
-    };
   }
-  async canUse(params, options) {
+  async list(params, options) {
     return this.httpClient.get(
-      `/features/${params.code}`,
-      { customerId: params.customerId, action: "canUse" },
+      "/features",
+      { customerId: params.customerId },
+      options
+    );
+  }
+  async create(params, options) {
+    return this.httpClient.post("/features/manage", params, options);
+  }
+  async update(params, options) {
+    const { code, ...body } = params;
+    return this.httpClient.put(`/features/${code}/manage`, body, options);
+  }
+  /** Fails if feature is attached to active plans or has an active addon. */
+  async delete(params, options) {
+    const { code } = params;
+    return this.httpClient.delete(
+      `/features/${code}/manage`,
+      void 0,
       options
     );
   }
-  async list(customerId, options) {
-    return this.httpClient.get("/features", { customerId }, options);
+};
+
+// src/resources/invoices.ts
+var InvoicesResource = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async list(params) {
+    return this.httpClient.get("/invoices", params);
+  }
+  async get(params) {
+    return this.httpClient.get(`/invoices/${params.id}`);
+  }
+  /** Negative amount creates a credit. */
+  async createAdjustment(params, options) {
+    return this.httpClient.post("/invoices", params, options);
+  }
+  /** Signed URL, expires after 7 days. */
+  async getDownloadUrl(params) {
+    return this.httpClient.get(`/invoices/${params.id}/download`);
+  }
+  async send(params, options) {
+    return this.httpClient.post(`/invoices/${params.id}/send`, {}, options);
+  }
+  /** Only outstanding invoices can be changed to paid or void. */
+  async updateStatus(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.put(`/invoices/${id}/status`, body, options);
+  }
+};
+
+// src/resources/plan-groups.ts
+var PlanGroupsResource = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async list(params) {
+    return this.httpClient.get("/plan-groups", params);
+  }
+  async get(params) {
+    return this.httpClient.get(`/plan-groups/${params.id}`);
+  }
+  async create(params, options) {
+    return this.httpClient.post("/plan-groups", params, options);
+  }
+  async update(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.put(`/plan-groups/${id}`, body, options);
+  }
+  /** Plans in the group are unlinked, not deleted. */
+  async delete(params, options) {
+    return this.httpClient.delete(
+      `/plan-groups/${params.id}`,
+      void 0,
+      options
+    );
+  }
+  async addPlan(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.post(`/plan-groups/${id}/plans`, body, options);
+  }
+  async removePlan(params, options) {
+    const { id, planId } = params;
+    return this.httpClient.delete(
+      `/plan-groups/${id}/plans/${planId}`,
+      void 0,
+      options
+    );
+  }
+  async reorderPlans(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.put(
+      `/plan-groups/${id}/plans/reorder`,
+      body,
+      options
+    );
   }
 };
 
@@ -268,33 +306,93 @@ var PlansResource = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
   }
-  /**
-   * List all available plans
-   *
-   * @example
-   * ```typescript
-   * // List public plans
-   * const plans = await commet.plans.list();
-   *
-   * // Include private plans
-   * const allPlans = await commet.plans.list({ includePrivate: true });
-   * ```
-   */
   async list(params) {
     return this.httpClient.get("/plans", params);
   }
-  /**
-   * Get a specific plan by code
-   *
-   * @example
-   * ```typescript
-   * const plan = await commet.plans.get('pro');
-   * console.log(plan.data.name); // "Pro"
-   * console.log(plan.data.prices); // [{ billingInterval: 'monthly', price: 9900 }]
-   * ```
-   */
-  async get(planCode) {
-    return this.httpClient.get(`/plans/${planCode}`);
+  async get(params) {
+    return this.httpClient.get(`/plans/${params.id}`);
+  }
+  async create(params, options) {
+    return this.httpClient.post("/plans/manage", params, options);
+  }
+  async update(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.put(`/plans/${id}/manage`, body, options);
+  }
+  async delete(params, options) {
+    return this.httpClient.delete(
+      `/plans/${params.id}/manage`,
+      void 0,
+      options
+    );
+  }
+  async setVisibility(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.put(`/plans/${id}/visibility`, body, options);
+  }
+  async addFeature(params, options) {
+    const { planId, ...body } = params;
+    return this.httpClient.post(`/plans/${planId}/features`, body, options);
+  }
+  async updateFeature(params, options) {
+    const { planId, featureId, ...body } = params;
+    return this.httpClient.put(
+      `/plans/${planId}/features/${featureId}`,
+      body,
+      options
+    );
+  }
+  async removeFeature(params, options) {
+    const { planId, featureId } = params;
+    return this.httpClient.delete(
+      `/plans/${planId}/features/${featureId}`,
+      void 0,
+      options
+    );
+  }
+  async addPrice(params, options) {
+    const { planId, ...body } = params;
+    return this.httpClient.post(`/plans/${planId}/prices`, body, options);
+  }
+  async updatePrice(params, options) {
+    const { planId, priceId, ...body } = params;
+    return this.httpClient.put(
+      `/plans/${planId}/prices/${priceId}`,
+      body,
+      options
+    );
+  }
+  async deletePrice(params, options) {
+    const { planId, priceId } = params;
+    return this.httpClient.delete(
+      `/plans/${planId}/prices/${priceId}`,
+      void 0,
+      options
+    );
+  }
+  async setDefaultPrice(params, options) {
+    const { planId, priceId } = params;
+    return this.httpClient.put(
+      `/plans/${planId}/prices/${priceId}/default`,
+      {},
+      options
+    );
+  }
+  async setRegionalPrices(params, options) {
+    const { planId, priceId, ...body } = params;
+    return this.httpClient.put(
+      `/plans/${planId}/prices/${priceId}/regional`,
+      body,
+      options
+    );
+  }
+  async deleteRegionalPrices(params, options) {
+    const { planId, priceId } = params;
+    return this.httpClient.delete(
+      `/plans/${planId}/prices/${priceId}/regional`,
+      void 0,
+      options
+    );
   }
 };
 
@@ -308,39 +406,63 @@ var PortalResource = class {
   }
 };
 
-// src/resources/seats.ts
-function resolveCode(params) {
-  const code = params.featureCode ?? params.seatType;
-  if (!code) {
-    throw new Error("Either featureCode or seatType must be provided");
+// src/resources/promo-codes.ts
+var PromoCodesResource = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
   }
-  return code;
-}
+  async list(params) {
+    return this.httpClient.get("/promo-codes", params);
+  }
+  async get(params) {
+    return this.httpClient.get(`/promo-codes/${params.id}`);
+  }
+  async create(params, options) {
+    return this.httpClient.post("/promo-codes", params, options);
+  }
+  async update(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.put(`/promo-codes/${id}`, body, options);
+  }
+};
+
+// src/resources/seats.ts
 var SeatsResource = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
   }
+  /** Prorates charges for the current billing period. */
   async add(params, options) {
-    const code = resolveCode(params);
     return this.httpClient.post(
       "/seats",
-      { customerId: params.customerId, seatType: code, count: params.count },
+      {
+        customerId: params.customerId,
+        featureCode: params.featureCode,
+        count: params.count ?? 1
+      },
       options
     );
   }
+  /** Removal takes effect at the end of the billing period. */
   async remove(params, options) {
-    const code = resolveCode(params);
     return this.httpClient.delete(
       "/seats",
-      { customerId: params.customerId, seatType: code, count: params.count },
+      {
+        customerId: params.customerId,
+        featureCode: params.featureCode,
+        count: params.count ?? 1
+      },
       options
     );
   }
   async set(params, options) {
-    const code = resolveCode(params);
     return this.httpClient.put(
       "/seats",
-      { customerId: params.customerId, seatType: code, count: params.count },
+      {
+        customerId: params.customerId,
+        featureCode: params.featureCode,
+        count: params.count
+      },
       options
     );
   }
@@ -348,10 +470,9 @@ var SeatsResource = class {
     return this.httpClient.put("/seats/bulk", params, options);
   }
   async getBalance(params) {
-    const code = resolveCode(params);
     return this.httpClient.get("/seats/balance", {
       customerId: params.customerId,
-      seatType: code
+      featureCode: params.featureCode
     });
   }
   async getAllBalances(params) {
@@ -366,92 +487,113 @@ var SubscriptionsResource = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
   }
-  /**
-   * Create a subscription with a plan
-   *
-   * @example
-   * ```typescript
-   * await commet.subscriptions.create({
-   *   externalId: 'user_123',
-   *   planCode: 'pro', // autocomplete works after `commet pull`
-   *   billingInterval: 'yearly',
-   *   initialSeats: { editor: 5 }
-   * });
-   * ```
-   */
+  /** Returns a `checkoutUrl` when payment is required before activation. */
   async create(params, options) {
     return this.httpClient.post("/subscriptions", params, options);
   }
-  /**
-   * Get the active subscription for a customer
-   *
-   * @example
-   * ```typescript
-   * const sub = await commet.subscriptions.get('user_123');
-   * ```
-   */
-  async get(customerId) {
-    return this.httpClient.get("/subscriptions/active", { customerId });
+  async getActive(params) {
+    return this.httpClient.get("/subscriptions/active", {
+      customerId: params.customerId
+    });
   }
-  /**
-   * Cancel a subscription
-   *
-   * @example
-   * ```typescript
-   * await commet.subscriptions.cancel({
-   *   subscriptionId: 'sub_xxx',
-   *   reason: 'switched_to_competitor'
-   * });
-   * ```
-   */
+  /** Schedules cancellation at period end by default. Set `immediate: true` to cancel now. */
   async cancel(params, options) {
-    return this.httpClient.post(
-      `/subscriptions/${params.subscriptionId}/cancel`,
-      params || {},
-      options
-    );
+    const { id, ...body } = params;
+    return this.httpClient.post(`/subscriptions/${id}/cancel`, body, options);
   }
-  /**
-   * Revert a scheduled cancellation
-   *
-   * Only works on subscriptions with a pending cancellation (canceledAt is set
-   * but status is not yet "canceled"). Cannot revert already-canceled subscriptions.
-   *
-   * @example
-   * ```typescript
-   * await commet.subscriptions.uncancel({
-   *   subscriptionId: 'sub_xxx',
-   * });
-   * ```
-   */
+  /** Only works on subscriptions with a pending cancellation — cannot revert already-canceled. */
   async uncancel(params, options) {
     return this.httpClient.post(
-      `/subscriptions/${params.subscriptionId}/uncancel`,
+      `/subscriptions/${params.id}/uncancel`,
       {},
       options
     );
   }
-  /**
-   * Change the plan of a subscription (upgrade/downgrade)
-   *
-   * Upgrades execute immediately. Downgrades are scheduled for end of period.
-   *
-   * @example
-   * ```typescript
-   * await commet.subscriptions.changePlan({
-   *   subscriptionId: 'sub_xxx',
-   *   newPlanId: 'pln_xxx',
-   * });
-   * ```
-   */
+  /** Upgrades execute immediately with proration. Downgrades are scheduled for end of period. */
   async changePlan(params, options) {
-    const { subscriptionId, ...body } = params;
+    const { id, ...body } = params;
+    return this.httpClient.post(
+      `/subscriptions/${id}/change-plan`,
+      body,
+      options
+    );
+  }
+  async list(params) {
+    return this.httpClient.get("/subscriptions", params);
+  }
+  /** Dry-run: returns proration details without applying the change. */
+  async previewChange(params, options) {
+    const { id, ...body } = params;
     return this.httpClient.post(
-      `/subscriptions/${subscriptionId}/change-plan`,
+      `/subscriptions/${id}/preview-change`,
       body,
       options
     );
   }
+  /** Prorated charge for the current billing period. */
+  async activateAddon(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.post(`/subscriptions/${id}/addons`, body, options);
+  }
+  async deactivateAddon(params, options) {
+    const { id, addonId } = params;
+    return this.httpClient.delete(
+      `/subscriptions/${id}/addons/${addonId}`,
+      void 0,
+      options
+    );
+  }
+  /** Positive amount adds, negative subtracts. */
+  async adjustBalance(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.post(
+      `/subscriptions/${id}/balance/adjust`,
+      body,
+      options
+    );
+  }
+  /** Charges the customer's payment method. */
+  async topupBalance(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.post(
+      `/subscriptions/${id}/balance/topup`,
+      body,
+      options
+    );
+  }
+  async purchaseCredits(params, options) {
+    const { id, ...body } = params;
+    return this.httpClient.post(`/subscriptions/${id}/credits`, body, options);
+  }
+};
+
+// src/resources/transactions.ts
+var TransactionsResource = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async list(params) {
+    return this.httpClient.get("/transactions", params);
+  }
+  async get(params) {
+    return this.httpClient.get(`/transactions/${params.id}`);
+  }
+  /** Full refund only. */
+  async refund(params, options) {
+    return this.httpClient.post(
+      `/transactions/${params.id}/refund`,
+      {},
+      options
+    );
+  }
+  /** Creates a new invoice and initiates a new payment attempt. */
+  async retry(params, options) {
+    return this.httpClient.post(
+      `/transactions/${params.id}/retry`,
+      {},
+      options
+    );
+  }
 };
 
 // src/resources/usage.ts
@@ -459,6 +601,7 @@ var UsageResource = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
   }
+  /** Deducts from balance/credits if the plan uses consumption. Duplicate `idempotencyKey` is rejected. */
   async track(params, options) {
     const eventData = {
       feature: params.feature,
@@ -485,21 +628,7 @@ var UsageResource = class {
     }
     return this.httpClient.post("/usage/events", eventData, options);
   }
-  /**
-   * Check if a usage event would be allowed before tracking it
-   *
-   * @example
-   * ```typescript
-   * const { data } = await commet.usage.check({
-   *   customerId: 'cus_xxx',
-   *   featureCode: 'api_calls',
-   *   quantity: 1,
-   * });
-   * if (data.allowed) {
-   *   // proceed with the operation
-   * }
-   * ```
-   */
+  /** Dry-run: checks if a usage event would be allowed without actually tracking it. */
   async check(params, options) {
     return this.httpClient.post("/usage/check", params, options);
   }
@@ -508,39 +637,10 @@ var UsageResource = class {
 // src/resources/webhooks.ts
 var import_node_crypto = __toESM(require("crypto"));
 var Webhooks = class {
-  /**
-   * Verify HMAC-SHA256 webhook signature
-   *
-   * Use this method to verify that webhooks are authentically from Commet.
-   * The signature is included in the `X-Commet-Signature` header.
-   *
-   * @param payload - Raw request body as string (IMPORTANT: Do not parse JSON first)
-   * @param signature - Value from X-Commet-Signature header
-   * @param secret - Your webhook secret from Commet dashboard
-   * @returns true if signature is valid, false otherwise
-   *
-   * @example
-   * ```typescript
-   * // Next.js API route example
-   * export async function POST(request: Request) {
-   *   const rawBody = await request.text();
-   *   const signature = request.headers.get('x-commet-signature');
-   *
-   *   const isValid = commet.webhooks.verify(
-   *     rawBody,
-   *     signature,
-   *     process.env.COMMET_WEBHOOK_SECRET
-   *   );
-   *
-   *   if (!isValid) {
-   *     return new Response('Invalid signature', { status: 401 });
-   *   }
-   *
-   *   const payload = JSON.parse(rawBody);
-   *   // Handle webhook event...
-   * }
-   * ```
-   */
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /** HMAC-SHA256 verification. Payload must be the raw request body string, not parsed JSON. */
   verify(params) {
     const { payload, signature, secret } = params;
     if (!signature || !secret || !payload) {
@@ -556,35 +656,11 @@ var Webhooks = class {
       return false;
     }
   }
-  /**
-   * Generate HMAC-SHA256 signature (internal use)
-   * @internal
-   */
   generateSignature(params) {
     const { payload, secret } = params;
     return import_node_crypto.default.createHmac("sha256", secret).update(payload).digest("hex");
   }
-  /**
-   * Parse and verify webhook payload in one step
-   *
-   * @example
-   * ```typescript
-   * const payload = commet.webhooks.verifyAndParse({
-   *   rawBody,
-   *   signature,
-   *   secret: process.env.COMMET_WEBHOOK_SECRET
-   * });
-   *
-   * if (!payload) {
-   *   return new Response('Invalid signature', { status: 401 });
-   * }
-   *
-   * // payload is typed and validated
-   * if (payload.event === 'subscription.activated') {
-   *   // Handle activation...
-   * }
-   * ```
-   */
+  /** Verifies signature and parses JSON in one step. Returns null if invalid. */
   verifyAndParse(params) {
     const { rawBody, signature, secret } = params;
     if (!this.verify({ payload: rawBody, signature, secret })) {
@@ -596,6 +672,21 @@ var Webhooks = class {
       return null;
     }
   }
+  async list(params, options) {
+    return this.httpClient.get("/webhooks", params, options);
+  }
+  /** Response includes `secretKey` which is only returned once. */
+  async create(params, options) {
+    return this.httpClient.post("/webhooks", params, options);
+  }
+  async delete(params, options) {
+    const { id } = params;
+    return this.httpClient.delete(`/webhooks/${id}`, void 0, options);
+  }
+  async test(params, options) {
+    const { id } = params;
+    return this.httpClient.post(`/webhooks/${id}/test`, void 0, options);
+  }
 };
 
 // src/types/common.ts
@@ -609,12 +700,15 @@ var CommetError = class extends Error {
   }
 };
 var CommetAPIError = class extends CommetError {
-  constructor(message, statusCode, code, details) {
+  constructor(message, statusCode, code, details, errorDetail) {
     super(message, code, statusCode, details);
     this.statusCode = statusCode;
     this.code = code;
     this.details = details;
     this.name = "CommetAPIError";
+    this.type = errorDetail?.type;
+    this.param = errorDetail?.param;
+    this.docUrl = errorDetail?.doc_url;
   }
 };
 var CommetValidationError = class extends CommetError {
@@ -626,8 +720,8 @@ var CommetValidationError = class extends CommetError {
 };
 
 // src/version.ts
-var API_VERSION = "2026-05-18";
-var SDK_VERSION = "4.6.0";
+var API_VERSION = "2026-05-25";
+var SDK_VERSION = "5.0.0";
 
 // src/utils/telemetry.ts
 var registeredIntegrations = /* @__PURE__ */ new Set();
@@ -691,7 +785,7 @@ var DEFAULT_RETRY_CONFIG = {
   // 8s
   retryableStatusCodes: [408, 429, 500, 502, 503, 504]
 };
-var CommetHTTPClient = class {
+var _CommetHTTPClient = class _CommetHTTPClient {
   constructor(config) {
     this.lastRequestMetrics = null;
     this.config = config;
@@ -702,7 +796,13 @@ var CommetHTTPClient = class {
     };
   }
   async get(endpoint, params, options) {
-    return this.request("GET", endpoint, void 0, options, params);
+    return this.request(
+      "GET",
+      endpoint,
+      void 0,
+      options,
+      params
+    );
   }
   async post(endpoint, data, options) {
     return this.request("POST", endpoint, data, options);
@@ -718,6 +818,9 @@ var CommetHTTPClient = class {
   }
   async request(method, endpoint, data, options, params) {
     const url = this.buildURL(endpoint, params);
+    if (_CommetHTTPClient.BODY_METHODS.has(method) && this.retryConfig.maxRetries > 0 && !options?.idempotencyKey) {
+      options = { ...options, idempotencyKey: this.generateIdempotencyKey() };
+    }
     return this.executeRequest(method, url, data, options);
   }
   /**
@@ -743,8 +846,6 @@ var CommetHTTPClient = class {
       }
       if (options?.idempotencyKey) {
         headers["Idempotency-Key"] = options.idempotencyKey;
-      } else if (method === "POST" && data) {
-        headers["Idempotency-Key"] = this.generateIdempotencyKey();
       }
       const requestConfig = {
         method,
@@ -813,26 +914,30 @@ var CommetHTTPClient = class {
             JSON.stringify(responseData, null, 2)
           );
         }
-        const isErrorResponse = (data2) => {
-          return typeof data2 === "object" && data2 !== null;
+        const parsed = typeof responseData === "object" && responseData !== null ? responseData : {};
+        const errorObj = typeof parsed.error === "object" && parsed.error !== null ? parsed.error : {};
+        const errorDetail = {
+          type: errorObj.type ?? "api_error",
+          code: errorObj.code ?? "unknown",
+          message: errorObj.message ?? `Request failed with status ${response.status}`,
+          param: errorObj.param,
+          details: errorObj.details,
+          doc_url: errorObj.doc_url
         };
-        const errorData = isErrorResponse(responseData) ? responseData : {};
-        if (errorData.code === "validation_error" && Array.isArray(errorData.details)) {
+        if (errorDetail.code === "validation_error" && Array.isArray(errorDetail.details)) {
           const errors = {};
-          for (const detail of errorData.details) {
+          for (const detail of errorDetail.details) {
             if (!errors[detail.field]) errors[detail.field] = [];
             errors[detail.field].push(detail.message);
           }
-          throw new CommetValidationError(
-            errorData.message || "Validation failed",
-            errors
-          );
+          throw new CommetValidationError(errorDetail.message, errors);
         }
         throw new CommetAPIError(
-          errorData.message || `Request failed with status ${response.status}`,
+          errorDetail.message,
           response.status,
-          errorData.code,
-          errorData.details
+          errorDetail.code,
+          errorDetail.details,
+          errorDetail
         );
       }
       if (this.config.debug) {
@@ -890,11 +995,8 @@ var CommetHTTPClient = class {
     }
     return finalUrl;
   }
-  /**
-   * Generate idempotency key
-   */
   generateIdempotencyKey() {
-    return `sdk_${Date.now()}_${Math.random().toString(36).substring(2)}`;
+    return `commet-node-retry-${crypto.randomUUID()}`;
   }
   /**
    * Sleep for specified milliseconds
@@ -903,6 +1005,8 @@ var CommetHTTPClient = class {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 };
+_CommetHTTPClient.BODY_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+var CommetHTTPClient = _CommetHTTPClient;
 
 // src/client.ts
 var Commet = class {
@@ -917,41 +1021,20 @@ var Commet = class {
     }
     this.httpClient = new CommetHTTPClient(config);
     this.addons = new AddonsResource(this.httpClient);
-    this.customers = new CustomersResource(this.httpClient);
+    this.apiKeys = new ApiKeysResource(this.httpClient);
     this.creditPacks = new CreditPacksResource(this.httpClient);
+    this.customers = new CustomersResource(this.httpClient);
+    this.features = new FeaturesResource(this.httpClient);
+    this.invoices = new InvoicesResource(this.httpClient);
+    this.planGroups = new PlanGroupsResource(this.httpClient);
     this.plans = new PlansResource(this.httpClient);
-    this.usage = new UsageResource(this.httpClient);
+    this.portal = new PortalResource(this.httpClient);
+    this.promoCodes = new PromoCodesResource(this.httpClient);
     this.seats = new SeatsResource(this.httpClient);
     this.subscriptions = new SubscriptionsResource(this.httpClient);
-    this.portal = new PortalResource(this.httpClient);
-    this.features = new FeaturesResource(this.httpClient);
-    this.webhooks = new Webhooks();
-    if (config.debug) {
-      console.log("[Commet SDK] Initialized");
-      console.log("API Key:", `${config.apiKey.substring(0, 12)}...`);
-    }
-  }
-  /**
-   * Create a customer-scoped context for cleaner API usage
-   *
-   * @example
-   * ```typescript
-   * const customer = commet.customer("user_123");
-   *
-   * // All operations are now scoped to this customer
-   * const seats = await customer.features.get("team_members");
-   * await customer.seats.add("member");
-   * await customer.usage.track("api_call");
-   * ```
-   */
-  customer(customerId) {
-    return new CustomerContext(customerId, {
-      features: this.features,
-      seats: this.seats,
-      usage: this.usage,
-      subscriptions: this.subscriptions,
-      portal: this.portal
-    });
+    this.transactions = new TransactionsResource(this.httpClient);
+    this.usage = new UsageResource(this.httpClient);
+    this.webhooks = new Webhooks(this.httpClient);
   }
 };
 function createCommet(_billingConfig, options) {
@@ -972,7 +1055,6 @@ var index_default = Commet;
   CommetAPIError,
   CommetError,
   CommetValidationError,
-  CustomerContext,
   SDK_VERSION,
   Webhooks,
   createCommet,