@dodopayments/hono 0.2.4 → 0.2.6

package/dist/index.js

@@ -4178,7 +4178,7 @@ const safeJSON = (text) => {
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-const VERSION = '2.4.6'; // x-release-please-version
+const VERSION = '2.23.2'; // x-release-please-version
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 /**
@@ -4388,6 +4388,25 @@ const FallbackEncoder = ({ headers, body }) => {
     };
 };
 
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Basic re-implementation of `qs.stringify` for primitive types.
+ */
+function stringifyQuery(query) {
+    return Object.entries(query)
+        .filter(([_, value]) => typeof value !== 'undefined')
+        .map(([key, value]) => {
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+        }
+        if (value === null) {
+            return `${encodeURIComponent(key)}=`;
+        }
+        throw new DodoPaymentsError(`Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`);
+    })
+        .join('&');
+}
+
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const levelNumbers = {
     off: 0,
@@ -4481,6 +4500,11 @@ async function defaultParseResponse(client, props) {
         const mediaType = contentType?.split(';')[0]?.trim();
         const isJSON = mediaType?.includes('application/json') || mediaType?.endsWith('+json');
         if (isJSON) {
+            const contentLength = response.headers.get('content-length');
+            if (contentLength === '0') {
+                // if there is no content we can't do anything
+                return undefined;
+            }
             const json = await response.json();
             return json;
         }
@@ -4901,6 +4925,16 @@ class Addons extends APIResource {
     }
 }
 
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+let Balances$1 = class Balances extends APIResource {
+    retrieveLedger(query = {}, options) {
+        return this._client.getAPIList('/balances/ledger', (DefaultPageNumberPagination), {
+            query,
+            ...options,
+        });
+    }
+};
+
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 class Brands extends APIResource {
     create(body, options) {
@@ -4931,66 +4965,155 @@ class CheckoutSessions extends APIResource {
     retrieve(id, options) {
         return this._client.get(path `/checkouts/${id}`, options);
     }
-}
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-let CustomerPortal$1 = class CustomerPortal extends APIResource {
-    create(customerID, params = {}, options) {
-        const { send_email } = params ?? {};
-        return this._client.post(path `/customers/${customerID}/customer-portal/session`, {
-            query: { send_email },
-            ...options,
-        });
-    }
-};
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-class LedgerEntries extends APIResource {
-    create(customerID, body, options) {
-        return this._client.post(path `/customers/${customerID}/wallets/ledger-entries`, { body, ...options });
-    }
-    list(customerID, query = {}, options) {
-        return this._client.getAPIList(path `/customers/${customerID}/wallets/ledger-entries`, (DefaultPageNumberPagination), { query, ...options });
-    }
-}
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-class Wallets extends APIResource {
-    constructor() {
-        super(...arguments);
-        this.ledgerEntries = new LedgerEntries(this._client);
-    }
-    list(customerID, options) {
-        return this._client.get(path `/customers/${customerID}/wallets`, options);
+    preview(body, options) {
+        return this._client.post('/checkouts/preview', { body, ...options });
     }
 }
-Wallets.LedgerEntries = LedgerEntries;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-class Customers extends APIResource {
-    constructor() {
-        super(...arguments);
-        this.customerPortal = new CustomerPortal$1(this._client);
-        this.wallets = new Wallets(this._client);
+class Balances extends APIResource {
+    /**
+     * Returns the credit balance details for a specific customer and credit
+     * entitlement.
+     *
+     * # Authentication
+     *
+     * Requires an API key with `Viewer` role or higher.
+     *
+     * # Path Parameters
+     *
+     * - `credit_entitlement_id` - The unique identifier of the credit entitlement
+     * - `customer_id` - The unique identifier of the customer
+     *
+     * # Responses
+     *
+     * - `200 OK` - Returns the customer's balance
+     * - `404 Not Found` - Credit entitlement or customer balance not found
+     * - `500 Internal Server Error` - Database or server error
+     */
+    retrieve(customerID, params, options) {
+        const { credit_entitlement_id } = params;
+        return this._client.get(path `/credit-entitlements/${credit_entitlement_id}/balances/${customerID}`, options);
     }
-    create(body, options) {
-        return this._client.post('/customers', { body, ...options });
+    /**
+     * Returns a paginated list of customer credit balances for the given credit
+     * entitlement.
+     *
+     * # Authentication
+     *
+     * Requires an API key with `Viewer` role or higher.
+     *
+     * # Path Parameters
+     *
+     * - `credit_entitlement_id` - The unique identifier of the credit entitlement
+     *
+     * # Query Parameters
+     *
+     * - `page_size` - Number of items per page (default: 10, max: 100)
+     * - `page_number` - Zero-based page number (default: 0)
+     * - `customer_id` - Optional filter by specific customer
+     *
+     * # Responses
+     *
+     * - `200 OK` - Returns list of customer balances
+     * - `404 Not Found` - Credit entitlement not found
+     * - `500 Internal Server Error` - Database or server error
+     */
+    list(creditEntitlementID, query = {}, options) {
+        return this._client.getAPIList(path `/credit-entitlements/${creditEntitlementID}/balances`, (DefaultPageNumberPagination), { query, ...options });
     }
-    retrieve(customerID, options) {
-        return this._client.get(path `/customers/${customerID}`, options);
+    /**
+     * For credit entries, a new grant is created. For debit entries, credits are
+     * deducted from existing grants using FIFO (oldest first).
+     *
+     * # Authentication
+     *
+     * Requires an API key with `Editor` role.
+     *
+     * # Path Parameters
+     *
+     * - `credit_entitlement_id` - The unique identifier of the credit entitlement
+     * - `customer_id` - The unique identifier of the customer
+     *
+     * # Request Body
+     *
+     * - `entry_type` - "credit" or "debit"
+     * - `amount` - Amount to credit or debit
+     * - `reason` - Optional human-readable reason
+     * - `expires_at` - Optional expiration for credited amount (only for credit type)
+     * - `idempotency_key` - Optional key to prevent duplicate entries
+     *
+     * # Responses
+     *
+     * - `201 Created` - Ledger entry created successfully
+     * - `400 Bad Request` - Invalid request (e.g., debit with insufficient balance)
+     * - `404 Not Found` - Credit entitlement or customer not found
+     * - `409 Conflict` - Idempotency key already exists
+     * - `500 Internal Server Error` - Database or server error
+     */
+    createLedgerEntry(customerID, params, options) {
+        const { credit_entitlement_id, ...body } = params;
+        return this._client.post(path `/credit-entitlements/${credit_entitlement_id}/balances/${customerID}/ledger-entries`, { body, ...options });
     }
-    update(customerID, body, options) {
-        return this._client.patch(path `/customers/${customerID}`, { body, ...options });
+    /**
+     * Returns a paginated list of credit grants with optional filtering by status.
+     *
+     * # Authentication
+     *
+     * Requires an API key with `Viewer` role or higher.
+     *
+     * # Path Parameters
+     *
+     * - `credit_entitlement_id` - The unique identifier of the credit entitlement
+     * - `customer_id` - The unique identifier of the customer
+     *
+     * # Query Parameters
+     *
+     * - `page_size` - Number of items per page (default: 10, max: 100)
+     * - `page_number` - Zero-based page number (default: 0)
+     * - `status` - Filter by status: active, expired, depleted
+     *
+     * # Responses
+     *
+     * - `200 OK` - Returns list of grants
+     * - `404 Not Found` - Credit entitlement not found
+     * - `500 Internal Server Error` - Database or server error
+     */
+    listGrants(customerID, params, options) {
+        const { credit_entitlement_id, ...query } = params;
+        return this._client.getAPIList(path `/credit-entitlements/${credit_entitlement_id}/balances/${customerID}/grants`, (DefaultPageNumberPagination), { query, ...options });
     }
-    list(query = {}, options) {
-        return this._client.getAPIList('/customers', (DefaultPageNumberPagination), {
-            query,
-            ...options,
-        });
+    /**
+     * Returns a paginated list of credit transaction history with optional filtering.
+     *
+     * # Authentication
+     *
+     * Requires an API key with `Viewer` role or higher.
+     *
+     * # Path Parameters
+     *
+     * - `credit_entitlement_id` - The unique identifier of the credit entitlement
+     * - `customer_id` - The unique identifier of the customer
+     *
+     * # Query Parameters
+     *
+     * - `page_size` - Number of items per page (default: 10, max: 100)
+     * - `page_number` - Zero-based page number (default: 0)
+     * - `transaction_type` - Filter by transaction type
+     * - `start_date` - Filter entries from this date
+     * - `end_date` - Filter entries until this date
+     *
+     * # Responses
+     *
+     * - `200 OK` - Returns list of ledger entries
+     * - `404 Not Found` - Credit entitlement not found
+     * - `500 Internal Server Error` - Database or server error
+     */
+    listLedger(customerID, params, options) {
+        const { credit_entitlement_id, ...query } = params;
+        return this._client.getAPIList(path `/credit-entitlements/${credit_entitlement_id}/balances/${customerID}/ledger`, (DefaultPageNumberPagination), { query, ...options });
     }
 }
-Customers.CustomerPortal = CustomerPortal$1;
-Customers.Wallets = Wallets;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 const brand_privateNullableHeaders = /* @__PURE__ */ Symbol('brand.privateNullableHeaders');
@@ -5060,6 +5183,313 @@ const buildHeaders = (newHeaders) => {
     return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders };
 };
 
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class CreditEntitlements extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.balances = new Balances(this._client);
+    }
+    /**
+     * Credit entitlements define reusable credit templates that can be attached to
+     * products. Each entitlement defines how credits behave in terms of expiration,
+     * rollover, and overage.
+     *
+     * # Authentication
+     *
+     * Requires an API key with `Editor` role.
+     *
+     * # Request Body
+     *
+     * - `name` - Human-readable name of the credit entitlement (1-255 characters,
+     *   required)
+     * - `description` - Optional description (max 1000 characters)
+     * - `precision` - Decimal precision for credit amounts (0-10 decimal places)
+     * - `unit` - Unit of measurement for the credit (e.g., "API Calls", "Tokens",
+     *   "Credits")
+     * - `expires_after_days` - Number of days after which credits expire (optional)
+     * - `rollover_enabled` - Whether unused credits can rollover to the next period
+     * - `rollover_percentage` - Percentage of unused credits that rollover (0-100)
+     * - `rollover_timeframe_count` - Count of timeframe periods for rollover limit
+     * - `rollover_timeframe_interval` - Interval type (day, week, month, year)
+     * - `max_rollover_count` - Maximum number of times credits can be rolled over
+     * - `overage_enabled` - Whether overage charges apply when credits run out
+     *   (requires price_per_unit)
+     * - `overage_limit` - Maximum overage units allowed (optional)
+     * - `currency` - Currency for pricing (required if price_per_unit is set)
+     * - `price_per_unit` - Price per credit unit (decimal)
+     *
+     * # Responses
+     *
+     * - `201 Created` - Credit entitlement created successfully, returns the full
+     *   entitlement object
+     * - `422 Unprocessable Entity` - Invalid request parameters or validation failure
+     * - `500 Internal Server Error` - Database or server error
+     *
+     * # Business Logic
+     *
+     * - A unique ID with prefix `cde_` is automatically generated for the entitlement
+     * - Created and updated timestamps are automatically set
+     * - Currency is required when price_per_unit is set
+     * - price_per_unit is required when overage_enabled is true
+     * - rollover_timeframe_count and rollover_timeframe_interval must both be set or
+     *   both be null
+     */
+    create(body, options) {
+        return this._client.post('/credit-entitlements', { body, ...options });
+    }
+    /**
+     * Returns the full details of a single credit entitlement including all
+     * configuration settings for expiration, rollover, and overage policies.
+     *
+     * # Authentication
+     *
+     * Requires an API key with `Viewer` role or higher.
+     *
+     * # Path Parameters
+     *
+     * - `id` - The unique identifier of the credit entitlement (format: `cde_...`)
+     *
+     * # Responses
+     *
+     * - `200 OK` - Returns the full credit entitlement object
+     * - `404 Not Found` - Credit entitlement does not exist or does not belong to the
+     *   authenticated business
+     * - `500 Internal Server Error` - Database or server error
+     *
+     * # Business Logic
+     *
+     * - Only non-deleted credit entitlements can be retrieved through this endpoint
+     * - The entitlement must belong to the authenticated business (business_id check)
+     * - Deleted entitlements return a 404 error and must be retrieved via the list
+     *   endpoint with `deleted=true`
+     */
+    retrieve(id, options) {
+        return this._client.get(path `/credit-entitlements/${id}`, options);
+    }
+    /**
+     * Allows partial updates to a credit entitlement's configuration. Only the fields
+     * provided in the request body will be updated; all other fields remain unchanged.
+     * This endpoint supports nullable fields using the double option pattern.
+     *
+     * # Authentication
+     *
+     * Requires an API key with `Editor` role.
+     *
+     * # Path Parameters
+     *
+     * - `id` - The unique identifier of the credit entitlement to update (format:
+     *   `cde_...`)
+     *
+     * # Request Body (all fields optional)
+     *
+     * - `name` - Human-readable name of the credit entitlement (1-255 characters)
+     * - `description` - Optional description (max 1000 characters)
+     * - `unit` - Unit of measurement for the credit (1-50 characters)
+     *
+     * Note: `precision` cannot be modified after creation as it would invalidate
+     * existing grants.
+     *
+     * - `expires_after_days` - Number of days after which credits expire (use `null`
+     *   to remove expiration)
+     * - `rollover_enabled` - Whether unused credits can rollover to the next period
+     * - `rollover_percentage` - Percentage of unused credits that rollover (0-100,
+     *   nullable)
+     * - `rollover_timeframe_count` - Count of timeframe periods for rollover limit
+     *   (nullable)
+     * - `rollover_timeframe_interval` - Interval type (day, week, month, year,
+     *   nullable)
+     * - `max_rollover_count` - Maximum number of times credits can be rolled over
+     *   (nullable)
+     * - `overage_enabled` - Whether overage charges apply when credits run out
+     * - `overage_limit` - Maximum overage units allowed (nullable)
+     * - `currency` - Currency for pricing (nullable)
+     * - `price_per_unit` - Price per credit unit (decimal, nullable)
+     *
+     * # Responses
+     *
+     * - `200 OK` - Credit entitlement updated successfully
+     * - `404 Not Found` - Credit entitlement does not exist or does not belong to the
+     *   authenticated business
+     * - `422 Unprocessable Entity` - Invalid request parameters or validation failure
+     * - `500 Internal Server Error` - Database or server error
+     *
+     * # Business Logic
+     *
+     * - Only non-deleted credit entitlements can be updated
+     * - Fields set to `null` explicitly will clear the database value (using double
+     *   option pattern)
+     * - The `updated_at` timestamp is automatically updated on successful modification
+     * - Changes take effect immediately but do not retroactively affect existing
+     *   credit grants
+     * - The merged state is validated: currency required with price, rollover
+     *   timeframe fields together, price required for overage
+     */
+    update(id, body, options) {
+        return this._client.patch(path `/credit-entitlements/${id}`, {
+            body,
+            ...options,
+            headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        });
+    }
+    /**
+     * Returns a paginated list of credit entitlements, allowing filtering of deleted
+     * entitlements. By default, only non-deleted entitlements are returned.
+     *
+     * # Authentication
+     *
+     * Requires an API key with `Viewer` role or higher.
+     *
+     * # Query Parameters
+     *
+     * - `page_size` - Number of items per page (default: 10, max: 100)
+     * - `page_number` - Zero-based page number (default: 0)
+     * - `deleted` - Boolean flag to list deleted entitlements instead of active ones
+     *   (default: false)
+     *
+     * # Responses
+     *
+     * - `200 OK` - Returns a list of credit entitlements wrapped in a response object
+     * - `422 Unprocessable Entity` - Invalid query parameters (e.g., page_size > 100)
+     * - `500 Internal Server Error` - Database or server error
+     *
+     * # Business Logic
+     *
+     * - Results are ordered by creation date in descending order (newest first)
+     * - Only entitlements belonging to the authenticated business are returned
+     * - The `deleted` parameter controls visibility of soft-deleted entitlements
+     * - Pagination uses offset-based pagination (offset = page_number \* page_size)
+     */
+    list(query = {}, options) {
+        return this._client.getAPIList('/credit-entitlements', (DefaultPageNumberPagination), {
+            query,
+            ...options,
+        });
+    }
+    delete(id, options) {
+        return this._client.delete(path `/credit-entitlements/${id}`, {
+            ...options,
+            headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        });
+    }
+    /**
+     * Undeletes a soft-deleted credit entitlement by clearing `deleted_at`, making it
+     * available again through standard list and get endpoints.
+     *
+     * # Authentication
+     *
+     * Requires an API key with `Editor` role.
+     *
+     * # Path Parameters
+     *
+     * - `id` - The unique identifier of the credit entitlement to restore (format:
+     *   `cde_...`)
+     *
+     * # Responses
+     *
+     * - `200 OK` - Credit entitlement restored successfully
+     * - `500 Internal Server Error` - Database error, entitlement not found, or
+     *   entitlement is not deleted
+     *
+     * # Business Logic
+     *
+     * - Only deleted credit entitlements can be restored
+     * - The query filters for `deleted_at IS NOT NULL`, so non-deleted entitlements
+     *   will result in 0 rows affected
+     * - If no rows are affected (entitlement doesn't exist, doesn't belong to
+     *   business, or is not deleted), returns 500
+     * - The `updated_at` timestamp is automatically updated on successful restoration
+     * - Once restored, the entitlement becomes immediately available in the standard
+     *   list and get endpoints
+     * - All configuration settings are preserved during delete/restore operations
+     *
+     * # Error Handling
+     *
+     * This endpoint returns 500 Internal Server Error in several cases:
+     *
+     * - The credit entitlement does not exist
+     * - The credit entitlement belongs to a different business
+     * - The credit entitlement is not currently deleted (already active)
+     *
+     * Callers should verify the entitlement exists and is deleted before calling this
+     * endpoint.
+     */
+    undelete(id, options) {
+        return this._client.post(path `/credit-entitlements/${id}/undelete`, {
+            ...options,
+            headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        });
+    }
+}
+CreditEntitlements.Balances = Balances;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+let CustomerPortal$1 = class CustomerPortal extends APIResource {
+    create(customerID, params = {}, options) {
+        const { send_email } = params ?? {};
+        return this._client.post(path `/customers/${customerID}/customer-portal/session`, {
+            query: { send_email },
+            ...options,
+        });
+    }
+};
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class LedgerEntries extends APIResource {
+    create(customerID, body, options) {
+        return this._client.post(path `/customers/${customerID}/wallets/ledger-entries`, { body, ...options });
+    }
+    list(customerID, query = {}, options) {
+        return this._client.getAPIList(path `/customers/${customerID}/wallets/ledger-entries`, (DefaultPageNumberPagination), { query, ...options });
+    }
+}
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Wallets extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.ledgerEntries = new LedgerEntries(this._client);
+    }
+    list(customerID, options) {
+        return this._client.get(path `/customers/${customerID}/wallets`, options);
+    }
+}
+Wallets.LedgerEntries = LedgerEntries;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Customers extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.customerPortal = new CustomerPortal$1(this._client);
+        this.wallets = new Wallets(this._client);
+    }
+    create(body, options) {
+        return this._client.post('/customers', { body, ...options });
+    }
+    retrieve(customerID, options) {
+        return this._client.get(path `/customers/${customerID}`, options);
+    }
+    update(customerID, body, options) {
+        return this._client.patch(path `/customers/${customerID}`, { body, ...options });
+    }
+    list(query = {}, options) {
+        return this._client.getAPIList('/customers', (DefaultPageNumberPagination), {
+            query,
+            ...options,
+        });
+    }
+    /**
+     * List all credit entitlements for a customer with their current balances
+     */
+    listCreditEntitlements(customerID, options) {
+        return this._client.get(path `/customers/${customerID}/credit-entitlements`, options);
+    }
+    retrievePaymentMethods(customerID, options) {
+        return this._client.get(path `/customers/${customerID}/payment-methods`, options);
+    }
+}
+Customers.CustomerPortal = CustomerPortal$1;
+Customers.Wallets = Wallets;
+
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 class Discounts extends APIResource {
     /**
@@ -5099,6 +5529,14 @@ class Discounts extends APIResource {
             headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
         });
     }
+    /**
+     * Validate and fetch a discount by its code name (e.g., "SAVE20"). This allows
+     * real-time validation directly against the API using the human-readable discount
+     * code instead of requiring the internal discount_id.
+     */
+    retrieveByCode(code, options) {
+        return this._client.get(path `/discounts/code/${code}`, options);
+    }
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
@@ -5297,6 +5735,9 @@ class Misc extends APIResource {
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 class Payments extends APIResource {
+    /**
+     * @deprecated
+     */
     create(body, options) {
         return this._client.post('/payments', { body, ...options });
     }
@@ -5332,11 +5773,29 @@ class Images extends APIResource {
     }
 }
 
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class ShortLinks extends APIResource {
+    /**
+     * Gives a Short Checkout URL with custom slug for a product. Uses a Static
+     * Checkout URL under the hood.
+     */
+    create(id, body, options) {
+        return this._client.post(path `/products/${id}/short_links`, { body, ...options });
+    }
+    /**
+     * Lists all short links created by the business.
+     */
+    list(query = {}, options) {
+        return this._client.getAPIList('/products/short_links', (DefaultPageNumberPagination), { query, ...options });
+    }
+}
+
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 class Products extends APIResource {
     constructor() {
         super(...arguments);
         this.images = new Images(this._client);
+        this.shortLinks = new ShortLinks(this._client);
     }
     create(body, options) {
         return this._client.post('/products', { body, ...options });
@@ -5374,6 +5833,7 @@ class Products extends APIResource {
     }
 }
 Products.Images = Images;
+Products.ShortLinks = ShortLinks;
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 class Refunds extends APIResource {
@@ -5393,6 +5853,9 @@ class Refunds extends APIResource {
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 class Subscriptions extends APIResource {
+    /**
+     * @deprecated
+     */
     create(body, options) {
         return this._client.post('/subscriptions', { body, ...options });
     }
@@ -5418,6 +5881,15 @@ class Subscriptions extends APIResource {
     charge(subscriptionID, body, options) {
         return this._client.post(path `/subscriptions/${subscriptionID}/charge`, { body, ...options });
     }
+    previewChangePlan(subscriptionID, body, options) {
+        return this._client.post(path `/subscriptions/${subscriptionID}/change-plan/preview`, {
+            body,
+            ...options,
+        });
+    }
+    retrieveCreditUsage(subscriptionID, options) {
+        return this._client.get(path `/subscriptions/${subscriptionID}/credit-usage`, options);
+    }
     /**
      * Get detailed usage history for a subscription that includes usage-based billing
      * (metered components). This endpoint provides insights into customer usage
@@ -5465,6 +5937,12 @@ class Subscriptions extends APIResource {
     retrieveUsageHistory(subscriptionID, query = {}, options) {
         return this._client.getAPIList(path `/subscriptions/${subscriptionID}/usage-history`, (DefaultPageNumberPagination), { query, ...options });
     }
+    updatePaymentMethod(subscriptionID, body, options) {
+        return this._client.post(path `/subscriptions/${subscriptionID}/update-payment-method`, {
+            body,
+            ...options,
+        });
+    }
 }
 
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
@@ -6586,6 +7064,8 @@ class DodoPayments {
         this.webhookEvents = new WebhookEvents(this);
         this.usageEvents = new UsageEvents(this);
         this.meters = new Meters(this);
+        this.balances = new Balances$1(this);
+        this.creditEntitlements = new CreditEntitlements(this);
         if (bearerToken === undefined) {
             throw new DodoPaymentsError("The DODO_PAYMENTS_API_KEY environment variable is missing or empty; either provide it, or instantiate the DodoPayments client with an bearerToken option, like new DodoPayments({ bearerToken: 'My Bearer Token' }).");
         }
@@ -6650,18 +7130,7 @@ class DodoPayments {
      * Basic re-implementation of `qs.stringify` for primitive types.
      */
     stringifyQuery(query) {
-        return Object.entries(query)
-            .filter(([_, value]) => typeof value !== 'undefined')
-            .map(([key, value]) => {
-            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-                return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-            }
-            if (value === null) {
-                return `${encodeURIComponent(key)}=`;
-            }
-            throw new DodoPaymentsError(`Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`);
-        })
-            .join('&');
+        return stringifyQuery(query);
     }
     getUserAgent() {
         return `${this.constructor.name}/JS ${VERSION}`;
@@ -6825,7 +7294,9 @@ class DodoPayments {
         return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
     }
     getAPIList(path, Page, opts) {
-        return this.requestAPIList(Page, { method: 'get', path, ...opts });
+        return this.requestAPIList(Page, opts && 'then' in opts ?
+            opts.then((opts) => ({ method: 'get', path, ...opts }))
+            : { method: 'get', path, ...opts });
     }
     requestAPIList(Page, options) {
         const request = this.makeRequest(options, null, undefined);
@@ -6833,9 +7304,10 @@ class DodoPayments {
     }
     async fetchWithTimeout(url, init, ms, controller) {
         const { signal, method, ...options } = init || {};
+        const abort = this._makeAbort(controller);
         if (signal)
-            signal.addEventListener('abort', () => controller.abort());
-        const timeout = setTimeout(() => controller.abort(), ms);
+            signal.addEventListener('abort', abort, { once: true });
+        const timeout = setTimeout(abort, ms);
         const isReadableBody = (globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream) ||
             (typeof options.body === 'object' && options.body !== null && Symbol.asyncIterator in options.body);
         const fetchOptions = {
@@ -6900,9 +7372,9 @@ class DodoPayments {
                 timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
             }
         }
-        // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
-        // just do what it says, but otherwise calculate a default
-        if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1000)) {
+        // If the API asks us to wait a certain amount of time, just do what it
+        // says, but otherwise calculate a default
+        if (timeoutMillis === undefined) {
             const maxRetries = options.maxRetries ?? this.maxRetries;
             timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
         }
@@ -6964,6 +7436,11 @@ class DodoPayments {
         this.validateHeaders(headers);
         return headers.values;
     }
+    _makeAbort(controller) {
+        // note: we can't just inline this method inside `fetchWithTimeout()` because then the closure
+        //       would capture all request options, and cause a memory leak.
+        return () => controller.abort();
+    }
     buildBody({ options: { body, headers: rawHeaders } }) {
         if (!body) {
             return { bodyHeaders: undefined, body: undefined };
@@ -6992,6 +7469,13 @@ class DodoPayments {
                 (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))) {
             return { bodyHeaders: undefined, body: ReadableStreamFrom(body) };
         }
+        else if (typeof body === 'object' &&
+            headers.values.get('content-type') === 'application/x-www-form-urlencoded') {
+            return {
+                bodyHeaders: { 'content-type': 'application/x-www-form-urlencoded' },
+                body: this.stringifyQuery(body),
+            };
+        }
         else {
             return __classPrivateFieldGet(this, _DodoPayments_encoder, "f").call(this, { body, headers });
         }
@@ -7036,6 +7520,8 @@ DodoPayments.Webhooks = Webhooks$1;
 DodoPayments.WebhookEvents = WebhookEvents;
 DodoPayments.UsageEvents = UsageEvents;
 DodoPayments.Meters = Meters;
+DodoPayments.Balances = Balances$1;
+DodoPayments.CreditEntitlements = CreditEntitlements;
 
 // src/checkout/checkout.ts
 var checkoutQuerySchema = objectType({
@@ -7506,6 +7992,32 @@ var buildCheckoutUrl = async ({
   }
 };
 
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+
 const Checkout = (config) => {
     const getHandler = async (c) => {
         const queryParams = c.req.query();
@@ -7618,23 +8130,33 @@ var PaymentSchema = objectType({
   payload_type: literalType("Payment"),
   billing: objectType({
     city: stringType().nullable(),
-    country: stringType().nullable(),
+    country: stringType(),
     state: stringType().nullable(),
     street: stringType().nullable(),
     zipcode: stringType().nullable()
   }),
   brand_id: stringType(),
   business_id: stringType(),
+  card_holder_name: stringType().nullable(),
   card_issuing_country: stringType().nullable(),
   card_last_four: stringType().nullable(),
   card_network: stringType().nullable(),
   card_type: stringType().nullable(),
+  checkout_session_id: stringType().nullable(),
   created_at: stringType().transform((d) => new Date(d)),
   currency: stringType(),
+  custom_field_responses: arrayType(
+    objectType({
+      key: stringType(),
+      value: stringType()
+    })
+  ).nullable(),
   customer: objectType({
     customer_id: stringType(),
     email: stringType(),
-    name: stringType().nullable()
+    metadata: recordType(anyType()),
+    name: stringType(),
+    phone_number: stringType().nullable()
   }),
   digital_products_delivered: booleanType(),
   discount_id: stringType().nullable(),
@@ -7645,27 +8167,25 @@ var PaymentSchema = objectType({
       created_at: stringType().transform((d) => new Date(d)),
       currency: stringType(),
       dispute_id: stringType(),
-      dispute_stage: enumType([
-        "pre_dispute",
-        "dispute_opened",
-        "dispute_won",
-        "dispute_lost"
-      ]),
+      dispute_stage: enumType(["pre_dispute", "dispute", "pre_arbitration"]),
       dispute_status: enumType([
         "dispute_opened",
-        "dispute_won",
-        "dispute_lost",
+        "dispute_expired",
         "dispute_accepted",
         "dispute_cancelled",
-        "dispute_challenged"
+        "dispute_challenged",
+        "dispute_won",
+        "dispute_lost"
       ]),
       payment_id: stringType(),
       remarks: stringType().nullable()
     })
-  ).nullable(),
+  ).default([]),
   error_code: stringType().nullable(),
   error_message: stringType().nullable(),
-  metadata: recordType(anyType()).nullable(),
+  invoice_id: stringType().nullable(),
+  invoice_url: stringType().nullable(),
+  metadata: recordType(anyType()),
   payment_id: stringType(),
   payment_link: stringType().nullable(),
   payment_method: stringType().nullable(),
@@ -7678,21 +8198,34 @@ var PaymentSchema = objectType({
   ).nullable(),
   refunds: arrayType(
     objectType({
-      amount: numberType(),
+      amount: numberType().nullable(),
       business_id: stringType(),
       created_at: stringType().transform((d) => new Date(d)),
-      currency: stringType(),
+      currency: stringType().nullable(),
       is_partial: booleanType(),
       payment_id: stringType(),
       reason: stringType().nullable(),
       refund_id: stringType(),
-      status: enumType(["succeeded", "failed", "pending"])
+      status: enumType(["succeeded", "failed", "pending", "review"])
     })
-  ).nullable(),
+  ),
+  refund_status: enumType(["partial", "full"]).nullable(),
   settlement_amount: numberType(),
   settlement_currency: stringType(),
   settlement_tax: numberType().nullable(),
-  status: enumType(["succeeded", "failed", "pending", "processing", "cancelled"]),
+  status: enumType([
+    "succeeded",
+    "failed",
+    "cancelled",
+    "processing",
+    "requires_customer_action",
+    "requires_merchant_action",
+    "requires_payment_method",
+    "requires_confirmation",
+    "requires_capture",
+    "partially_captured",
+    "partially_captured_and_capturable"
+  ]).nullable(),
   subscription_id: stringType().nullable(),
   tax: numberType().nullable(),
   total_amount: numberType(),
@@ -7705,10 +8238,10 @@ var SubscriptionSchema = objectType({
       addon_id: stringType(),
       quantity: numberType()
     })
-  ).nullable(),
+  ),
   billing: objectType({
     city: stringType().nullable(),
-    country: stringType().nullable(),
+    country: stringType(),
     state: stringType().nullable(),
     street: stringType().nullable(),
     zipcode: stringType().nullable()
@@ -7720,15 +8253,72 @@ var SubscriptionSchema = objectType({
   customer: objectType({
     customer_id: stringType(),
     email: stringType(),
-    name: stringType().nullable()
+    metadata: recordType(anyType()),
+    name: stringType(),
+    phone_number: stringType().nullable()
   }),
+  custom_field_responses: arrayType(
+    objectType({
+      key: stringType(),
+      value: stringType()
+    })
+  ).nullable(),
+  discount_cycles_remaining: numberType().nullable(),
   discount_id: stringType().nullable(),
-  metadata: recordType(anyType()).nullable(),
-  next_billing_date: stringType().transform((d) => new Date(d)).nullable(),
+  expires_at: stringType().transform((d) => new Date(d)).nullable(),
+  credit_entitlement_cart: arrayType(
+    objectType({
+      credit_entitlement_id: stringType(),
+      credit_entitlement_name: stringType(),
+      credits_amount: stringType(),
+      overage_balance: stringType(),
+      overage_behavior: enumType([
+        "forgive_at_reset",
+        "invoice_at_billing",
+        "carry_deficit",
+        "carry_deficit_auto_repay"
+      ]),
+      overage_enabled: booleanType(),
+      product_id: stringType(),
+      remaining_balance: stringType(),
+      rollover_enabled: booleanType(),
+      unit: stringType(),
+      expires_after_days: numberType().nullable(),
+      low_balance_threshold_percent: numberType().nullable(),
+      max_rollover_count: numberType().nullable(),
+      overage_limit: stringType().nullable(),
+      rollover_percentage: numberType().nullable(),
+      rollover_timeframe_count: numberType().nullable(),
+      rollover_timeframe_interval: enumType(["Day", "Week", "Month", "Year"]).nullable()
+    })
+  ),
+  meter_credit_entitlement_cart: arrayType(
+    objectType({
+      credit_entitlement_id: stringType(),
+      meter_id: stringType(),
+      meter_name: stringType(),
+      meter_units_per_credit: stringType(),
+      product_id: stringType()
+    })
+  ),
+  meters: arrayType(
+    objectType({
+      currency: stringType(),
+      description: stringType().nullable(),
+      free_threshold: numberType(),
+      measurement_unit: stringType(),
+      meter_id: stringType(),
+      name: stringType(),
+      price_per_unit: stringType().nullable()
+    })
+  ),
+  metadata: recordType(anyType()),
+  next_billing_date: stringType().transform((d) => new Date(d)),
   on_demand: booleanType(),
   payment_frequency_count: numberType(),
   payment_frequency_interval: enumType(["Day", "Week", "Month", "Year"]),
-  previous_billing_date: stringType().transform((d) => new Date(d)).nullable(),
+  payment_method_id: stringType().nullable(),
+  previous_billing_date: stringType().transform((d) => new Date(d)),
   product_id: stringType(),
   quantity: numberType(),
   recurring_pre_tax_amount: numberType(),
@@ -7736,7 +8326,6 @@ var SubscriptionSchema = objectType({
     "pending",
     "active",
     "on_hold",
-    "paused",
     "cancelled",
     "expired",
     "failed"
@@ -7744,20 +8333,29 @@ var SubscriptionSchema = objectType({
   subscription_id: stringType(),
   subscription_period_count: numberType(),
   subscription_period_interval: enumType(["Day", "Week", "Month", "Year"]),
+  tax_id: stringType().nullable(),
   tax_inclusive: booleanType(),
   trial_period_days: numberType()
 });
 var RefundSchema = objectType({
   payload_type: literalType("Refund"),
-  amount: numberType(),
+  amount: numberType().nullable(),
   business_id: stringType(),
   created_at: stringType().transform((d) => new Date(d)),
-  currency: stringType(),
+  customer: objectType({
+    customer_id: stringType(),
+    email: stringType(),
+    metadata: recordType(anyType()),
+    name: stringType(),
+    phone_number: stringType().nullable()
+  }),
+  currency: stringType().nullable(),
   is_partial: booleanType(),
+  metadata: recordType(anyType()),
   payment_id: stringType(),
   reason: stringType().nullable(),
   refund_id: stringType(),
-  status: enumType(["succeeded", "failed", "pending"])
+  status: enumType(["succeeded", "failed", "pending", "review"])
 });
 var DisputeSchema = objectType({
   payload_type: literalType("Dispute"),
@@ -7765,27 +8363,31 @@ var DisputeSchema = objectType({
   business_id: stringType(),
   created_at: stringType().transform((d) => new Date(d)),
   currency: stringType(),
+  customer: objectType({
+    customer_id: stringType(),
+    email: stringType(),
+    metadata: recordType(anyType()),
+    name: stringType(),
+    phone_number: stringType().nullable()
+  }),
   dispute_id: stringType(),
-  dispute_stage: enumType([
-    "pre_dispute",
-    "dispute_opened",
-    "dispute_won",
-    "dispute_lost"
-  ]),
+  dispute_stage: enumType(["pre_dispute", "dispute", "pre_arbitration"]),
   dispute_status: enumType([
     "dispute_opened",
-    "dispute_won",
-    "dispute_lost",
+    "dispute_expired",
     "dispute_accepted",
     "dispute_cancelled",
-    "dispute_challenged"
+    "dispute_challenged",
+    "dispute_won",
+    "dispute_lost"
   ]),
   payment_id: stringType(),
+  reason: stringType().nullable(),
   remarks: stringType().nullable()
 });
 var LicenseKeySchema = objectType({
   payload_type: literalType("LicenseKey"),
-  activations_limit: numberType(),
+  activations_limit: numberType().nullable(),
   business_id: stringType(),
   created_at: stringType().transform((d) => new Date(d)),
   customer_id: stringType(),
@@ -7795,7 +8397,7 @@ var LicenseKeySchema = objectType({
   key: stringType(),
   payment_id: stringType(),
   product_id: stringType(),
-  status: enumType(["active", "inactive", "expired"]),
+  status: enumType(["active", "expired", "disabled"]),
   subscription_id: stringType().nullable()
 });
 var PaymentSucceededPayloadSchema = objectType({
@@ -7894,12 +8496,6 @@ var SubscriptionRenewedPayloadSchema = objectType({
   timestamp: stringType().transform((d) => new Date(d)),
   data: SubscriptionSchema
 });
-var SubscriptionPausedPayloadSchema = objectType({
-  business_id: stringType(),
-  type: literalType("subscription.paused"),
-  timestamp: stringType().transform((d) => new Date(d)),
-  data: SubscriptionSchema
-});
 var SubscriptionPlanChangedPayloadSchema = objectType({
   business_id: stringType(),
   type: literalType("subscription.plan_changed"),
@@ -7936,6 +8532,94 @@ var LicenseKeyCreatedPayloadSchema = objectType({
   timestamp: stringType().transform((d) => new Date(d)),
   data: LicenseKeySchema
 });
+var CreditLedgerEntrySchema = objectType({
+  payload_type: literalType("CreditLedgerEntry"),
+  id: stringType(),
+  amount: stringType(),
+  balance_after: stringType(),
+  balance_before: stringType(),
+  business_id: stringType(),
+  created_at: stringType().transform((d) => new Date(d)),
+  credit_entitlement_id: stringType(),
+  customer_id: stringType(),
+  is_credit: booleanType(),
+  overage_after: stringType(),
+  overage_before: stringType(),
+  transaction_type: enumType([
+    "credit_added",
+    "credit_deducted",
+    "credit_expired",
+    "credit_rolled_over",
+    "rollover_forfeited",
+    "overage_charged",
+    "auto_top_up",
+    "manual_adjustment",
+    "refund"
+  ]),
+  description: stringType().nullable(),
+  grant_id: stringType().nullable(),
+  reference_id: stringType().nullable(),
+  reference_type: stringType().nullable()
+});
+var CreditBalanceLowSchema = objectType({
+  payload_type: literalType("CreditBalanceLow"),
+  customer_id: stringType(),
+  subscription_id: stringType(),
+  credit_entitlement_id: stringType(),
+  credit_entitlement_name: stringType(),
+  available_balance: stringType(),
+  subscription_credits_amount: stringType(),
+  threshold_percent: numberType(),
+  threshold_amount: stringType()
+});
+var CreditAddedPayloadSchema = objectType({
+  business_id: stringType(),
+  type: literalType("credit.added"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: CreditLedgerEntrySchema
+});
+var CreditDeductedPayloadSchema = objectType({
+  business_id: stringType(),
+  type: literalType("credit.deducted"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: CreditLedgerEntrySchema
+});
+var CreditExpiredPayloadSchema = objectType({
+  business_id: stringType(),
+  type: literalType("credit.expired"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: CreditLedgerEntrySchema
+});
+var CreditRolledOverPayloadSchema = objectType({
+  business_id: stringType(),
+  type: literalType("credit.rolled_over"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: CreditLedgerEntrySchema
+});
+var CreditRolloverForfeitedPayloadSchema = objectType({
+  business_id: stringType(),
+  type: literalType("credit.rollover_forfeited"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: CreditLedgerEntrySchema
+});
+var CreditOverageChargedPayloadSchema = objectType({
+  business_id: stringType(),
+  type: literalType("credit.overage_charged"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: CreditLedgerEntrySchema
+});
+var CreditManualAdjustmentPayloadSchema = objectType({
+  business_id: stringType(),
+  type: literalType("credit.manual_adjustment"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: CreditLedgerEntrySchema
+});
+var CreditBalanceLowPayloadSchema = objectType({
+  business_id: stringType(),
+  type: literalType("credit.balance_low"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: CreditBalanceLowSchema
+});
 var WebhookPayloadSchema = discriminatedUnionType("type", [
   PaymentSucceededPayloadSchema,
   PaymentFailedPayloadSchema,
@@ -7953,15 +8637,691 @@ var WebhookPayloadSchema = discriminatedUnionType("type", [
   SubscriptionActivePayloadSchema,
   SubscriptionOnHoldPayloadSchema,
   SubscriptionRenewedPayloadSchema,
-  SubscriptionPausedPayloadSchema,
   SubscriptionPlanChangedPayloadSchema,
   SubscriptionCancelledPayloadSchema,
   SubscriptionFailedPayloadSchema,
   SubscriptionExpiredPayloadSchema,
   SubscriptionUpdatedPayloadSchema,
-  LicenseKeyCreatedPayloadSchema
+  LicenseKeyCreatedPayloadSchema,
+  CreditAddedPayloadSchema,
+  CreditDeductedPayloadSchema,
+  CreditExpiredPayloadSchema,
+  CreditRolledOverPayloadSchema,
+  CreditRolloverForfeitedPayloadSchema,
+  CreditOverageChargedPayloadSchema,
+  CreditManualAdjustmentPayloadSchema,
+  CreditBalanceLowPayloadSchema
 ]);
 
+// ../../node_modules/@stablelib/base64/lib/base64.js
+var require_base64 = __commonJS({
+  "../../node_modules/@stablelib/base64/lib/base64.js"(exports) {
+    var __extends = exports && exports.__extends || /* @__PURE__ */ function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var INVALID_BYTE = 256;
+    var Coder = (
+      /** @class */
+      function() {
+        function Coder2(_paddingCharacter) {
+          if (_paddingCharacter === void 0) {
+            _paddingCharacter = "=";
+          }
+          this._paddingCharacter = _paddingCharacter;
+        }
+        Coder2.prototype.encodedLength = function(length) {
+          if (!this._paddingCharacter) {
+            return (length * 8 + 5) / 6 | 0;
+          }
+          return (length + 2) / 3 * 4 | 0;
+        };
+        Coder2.prototype.encode = function(data) {
+          var out = "";
+          var i = 0;
+          for (; i < data.length - 2; i += 3) {
+            var c = data[i] << 16 | data[i + 1] << 8 | data[i + 2];
+            out += this._encodeByte(c >>> 3 * 6 & 63);
+            out += this._encodeByte(c >>> 2 * 6 & 63);
+            out += this._encodeByte(c >>> 1 * 6 & 63);
+            out += this._encodeByte(c >>> 0 * 6 & 63);
+          }
+          var left = data.length - i;
+          if (left > 0) {
+            var c = data[i] << 16 | (left === 2 ? data[i + 1] << 8 : 0);
+            out += this._encodeByte(c >>> 3 * 6 & 63);
+            out += this._encodeByte(c >>> 2 * 6 & 63);
+            if (left === 2) {
+              out += this._encodeByte(c >>> 1 * 6 & 63);
+            } else {
+              out += this._paddingCharacter || "";
+            }
+            out += this._paddingCharacter || "";
+          }
+          return out;
+        };
+        Coder2.prototype.maxDecodedLength = function(length) {
+          if (!this._paddingCharacter) {
+            return (length * 6 + 7) / 8 | 0;
+          }
+          return length / 4 * 3 | 0;
+        };
+        Coder2.prototype.decodedLength = function(s) {
+          return this.maxDecodedLength(s.length - this._getPaddingLength(s));
+        };
+        Coder2.prototype.decode = function(s) {
+          if (s.length === 0) {
+            return new Uint8Array(0);
+          }
+          var paddingLength = this._getPaddingLength(s);
+          var length = s.length - paddingLength;
+          var out = new Uint8Array(this.maxDecodedLength(length));
+          var op = 0;
+          var i = 0;
+          var haveBad = 0;
+          var v0 = 0, v1 = 0, v2 = 0, v3 = 0;
+          for (; i < length - 4; i += 4) {
+            v0 = this._decodeChar(s.charCodeAt(i + 0));
+            v1 = this._decodeChar(s.charCodeAt(i + 1));
+            v2 = this._decodeChar(s.charCodeAt(i + 2));
+            v3 = this._decodeChar(s.charCodeAt(i + 3));
+            out[op++] = v0 << 2 | v1 >>> 4;
+            out[op++] = v1 << 4 | v2 >>> 2;
+            out[op++] = v2 << 6 | v3;
+            haveBad |= v0 & INVALID_BYTE;
+            haveBad |= v1 & INVALID_BYTE;
+            haveBad |= v2 & INVALID_BYTE;
+            haveBad |= v3 & INVALID_BYTE;
+          }
+          if (i < length - 1) {
+            v0 = this._decodeChar(s.charCodeAt(i));
+            v1 = this._decodeChar(s.charCodeAt(i + 1));
+            out[op++] = v0 << 2 | v1 >>> 4;
+            haveBad |= v0 & INVALID_BYTE;
+            haveBad |= v1 & INVALID_BYTE;
+          }
+          if (i < length - 2) {
+            v2 = this._decodeChar(s.charCodeAt(i + 2));
+            out[op++] = v1 << 4 | v2 >>> 2;
+            haveBad |= v2 & INVALID_BYTE;
+          }
+          if (i < length - 3) {
+            v3 = this._decodeChar(s.charCodeAt(i + 3));
+            out[op++] = v2 << 6 | v3;
+            haveBad |= v3 & INVALID_BYTE;
+          }
+          if (haveBad !== 0) {
+            throw new Error("Base64Coder: incorrect characters for decoding");
+          }
+          return out;
+        };
+        Coder2.prototype._encodeByte = function(b) {
+          var result = b;
+          result += 65;
+          result += 25 - b >>> 8 & 0 - 65 - 26 + 97;
+          result += 51 - b >>> 8 & 26 - 97 - 52 + 48;
+          result += 61 - b >>> 8 & 52 - 48 - 62 + 43;
+          result += 62 - b >>> 8 & 62 - 43 - 63 + 47;
+          return String.fromCharCode(result);
+        };
+        Coder2.prototype._decodeChar = function(c) {
+          var result = INVALID_BYTE;
+          result += (42 - c & c - 44) >>> 8 & -INVALID_BYTE + c - 43 + 62;
+          result += (46 - c & c - 48) >>> 8 & -INVALID_BYTE + c - 47 + 63;
+          result += (47 - c & c - 58) >>> 8 & -INVALID_BYTE + c - 48 + 52;
+          result += (64 - c & c - 91) >>> 8 & -INVALID_BYTE + c - 65 + 0;
+          result += (96 - c & c - 123) >>> 8 & -INVALID_BYTE + c - 97 + 26;
+          return result;
+        };
+        Coder2.prototype._getPaddingLength = function(s) {
+          var paddingLength = 0;
+          if (this._paddingCharacter) {
+            for (var i = s.length - 1; i >= 0; i--) {
+              if (s[i] !== this._paddingCharacter) {
+                break;
+              }
+              paddingLength++;
+            }
+            if (s.length < 4 || paddingLength > 2) {
+              throw new Error("Base64Coder: incorrect padding");
+            }
+          }
+          return paddingLength;
+        };
+        return Coder2;
+      }()
+    );
+    exports.Coder = Coder;
+    var stdCoder = new Coder();
+    function encode2(data) {
+      return stdCoder.encode(data);
+    }
+    exports.encode = encode2;
+    function decode2(s) {
+      return stdCoder.decode(s);
+    }
+    exports.decode = decode2;
+    var URLSafeCoder = (
+      /** @class */
+      function(_super) {
+        __extends(URLSafeCoder2, _super);
+        function URLSafeCoder2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        URLSafeCoder2.prototype._encodeByte = function(b) {
+          var result = b;
+          result += 65;
+          result += 25 - b >>> 8 & 0 - 65 - 26 + 97;
+          result += 51 - b >>> 8 & 26 - 97 - 52 + 48;
+          result += 61 - b >>> 8 & 52 - 48 - 62 + 45;
+          result += 62 - b >>> 8 & 62 - 45 - 63 + 95;
+          return String.fromCharCode(result);
+        };
+        URLSafeCoder2.prototype._decodeChar = function(c) {
+          var result = INVALID_BYTE;
+          result += (44 - c & c - 46) >>> 8 & -INVALID_BYTE + c - 45 + 62;
+          result += (94 - c & c - 96) >>> 8 & -INVALID_BYTE + c - 95 + 63;
+          result += (47 - c & c - 58) >>> 8 & -INVALID_BYTE + c - 48 + 52;
+          result += (64 - c & c - 91) >>> 8 & -INVALID_BYTE + c - 65 + 0;
+          result += (96 - c & c - 123) >>> 8 & -INVALID_BYTE + c - 97 + 26;
+          return result;
+        };
+        return URLSafeCoder2;
+      }(Coder)
+    );
+    exports.URLSafeCoder = URLSafeCoder;
+    var urlSafeCoder = new URLSafeCoder();
+    function encodeURLSafe(data) {
+      return urlSafeCoder.encode(data);
+    }
+    exports.encodeURLSafe = encodeURLSafe;
+    function decodeURLSafe(s) {
+      return urlSafeCoder.decode(s);
+    }
+    exports.decodeURLSafe = decodeURLSafe;
+    exports.encodedLength = function(length) {
+      return stdCoder.encodedLength(length);
+    };
+    exports.maxDecodedLength = function(length) {
+      return stdCoder.maxDecodedLength(length);
+    };
+    exports.decodedLength = function(s) {
+      return stdCoder.decodedLength(s);
+    };
+  }
+});
+
+// ../../node_modules/fast-sha256/sha256.js
+var require_sha256 = __commonJS({
+  "../../node_modules/fast-sha256/sha256.js"(exports, module) {
+    (function(root, factory) {
+      var exports2 = {};
+      factory(exports2);
+      var sha2562 = exports2["default"];
+      for (var k in exports2) {
+        sha2562[k] = exports2[k];
+      }
+      if (typeof module === "object" && typeof module.exports === "object") {
+        module.exports = sha2562;
+      } else if (typeof define === "function" && define.amd) {
+        define(function() {
+          return sha2562;
+        });
+      } else {
+        root.sha256 = sha2562;
+      }
+    })(exports, function(exports2) {
+      exports2.__esModule = true;
+      exports2.digestLength = 32;
+      exports2.blockSize = 64;
+      var K = new Uint32Array([
+        1116352408,
+        1899447441,
+        3049323471,
+        3921009573,
+        961987163,
+        1508970993,
+        2453635748,
+        2870763221,
+        3624381080,
+        310598401,
+        607225278,
+        1426881987,
+        1925078388,
+        2162078206,
+        2614888103,
+        3248222580,
+        3835390401,
+        4022224774,
+        264347078,
+        604807628,
+        770255983,
+        1249150122,
+        1555081692,
+        1996064986,
+        2554220882,
+        2821834349,
+        2952996808,
+        3210313671,
+        3336571891,
+        3584528711,
+        113926993,
+        338241895,
+        666307205,
+        773529912,
+        1294757372,
+        1396182291,
+        1695183700,
+        1986661051,
+        2177026350,
+        2456956037,
+        2730485921,
+        2820302411,
+        3259730800,
+        3345764771,
+        3516065817,
+        3600352804,
+        4094571909,
+        275423344,
+        430227734,
+        506948616,
+        659060556,
+        883997877,
+        958139571,
+        1322822218,
+        1537002063,
+        1747873779,
+        1955562222,
+        2024104815,
+        2227730452,
+        2361852424,
+        2428436474,
+        2756734187,
+        3204031479,
+        3329325298
+      ]);
+      function hashBlocks(w, v, p, pos, len) {
+        var a, b, c, d, e, f, g, h, u, i, j, t1, t2;
+        while (len >= 64) {
+          a = v[0];
+          b = v[1];
+          c = v[2];
+          d = v[3];
+          e = v[4];
+          f = v[5];
+          g = v[6];
+          h = v[7];
+          for (i = 0; i < 16; i++) {
+            j = pos + i * 4;
+            w[i] = (p[j] & 255) << 24 | (p[j + 1] & 255) << 16 | (p[j + 2] & 255) << 8 | p[j + 3] & 255;
+          }
+          for (i = 16; i < 64; i++) {
+            u = w[i - 2];
+            t1 = (u >>> 17 | u << 32 - 17) ^ (u >>> 19 | u << 32 - 19) ^ u >>> 10;
+            u = w[i - 15];
+            t2 = (u >>> 7 | u << 32 - 7) ^ (u >>> 18 | u << 32 - 18) ^ u >>> 3;
+            w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);
+          }
+          for (i = 0; i < 64; i++) {
+            t1 = (((e >>> 6 | e << 32 - 6) ^ (e >>> 11 | e << 32 - 11) ^ (e >>> 25 | e << 32 - 25)) + (e & f ^ ~e & g) | 0) + (h + (K[i] + w[i] | 0) | 0) | 0;
+            t2 = ((a >>> 2 | a << 32 - 2) ^ (a >>> 13 | a << 32 - 13) ^ (a >>> 22 | a << 32 - 22)) + (a & b ^ a & c ^ b & c) | 0;
+            h = g;
+            g = f;
+            f = e;
+            e = d + t1 | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = t1 + t2 | 0;
+          }
+          v[0] += a;
+          v[1] += b;
+          v[2] += c;
+          v[3] += d;
+          v[4] += e;
+          v[5] += f;
+          v[6] += g;
+          v[7] += h;
+          pos += 64;
+          len -= 64;
+        }
+        return pos;
+      }
+      var Hash = (
+        /** @class */
+        function() {
+          function Hash2() {
+            this.digestLength = exports2.digestLength;
+            this.blockSize = exports2.blockSize;
+            this.state = new Int32Array(8);
+            this.temp = new Int32Array(64);
+            this.buffer = new Uint8Array(128);
+            this.bufferLength = 0;
+            this.bytesHashed = 0;
+            this.finished = false;
+            this.reset();
+          }
+          Hash2.prototype.reset = function() {
+            this.state[0] = 1779033703;
+            this.state[1] = 3144134277;
+            this.state[2] = 1013904242;
+            this.state[3] = 2773480762;
+            this.state[4] = 1359893119;
+            this.state[5] = 2600822924;
+            this.state[6] = 528734635;
+            this.state[7] = 1541459225;
+            this.bufferLength = 0;
+            this.bytesHashed = 0;
+            this.finished = false;
+            return this;
+          };
+          Hash2.prototype.clean = function() {
+            for (var i = 0; i < this.buffer.length; i++) {
+              this.buffer[i] = 0;
+            }
+            for (var i = 0; i < this.temp.length; i++) {
+              this.temp[i] = 0;
+            }
+            this.reset();
+          };
+          Hash2.prototype.update = function(data, dataLength) {
+            if (dataLength === void 0) {
+              dataLength = data.length;
+            }
+            if (this.finished) {
+              throw new Error("SHA256: can't update because hash was finished.");
+            }
+            var dataPos = 0;
+            this.bytesHashed += dataLength;
+            if (this.bufferLength > 0) {
+              while (this.bufferLength < 64 && dataLength > 0) {
+                this.buffer[this.bufferLength++] = data[dataPos++];
+                dataLength--;
+              }
+              if (this.bufferLength === 64) {
+                hashBlocks(this.temp, this.state, this.buffer, 0, 64);
+                this.bufferLength = 0;
+              }
+            }
+            if (dataLength >= 64) {
+              dataPos = hashBlocks(this.temp, this.state, data, dataPos, dataLength);
+              dataLength %= 64;
+            }
+            while (dataLength > 0) {
+              this.buffer[this.bufferLength++] = data[dataPos++];
+              dataLength--;
+            }
+            return this;
+          };
+          Hash2.prototype.finish = function(out) {
+            if (!this.finished) {
+              var bytesHashed = this.bytesHashed;
+              var left = this.bufferLength;
+              var bitLenHi = bytesHashed / 536870912 | 0;
+              var bitLenLo = bytesHashed << 3;
+              var padLength = bytesHashed % 64 < 56 ? 64 : 128;
+              this.buffer[left] = 128;
+              for (var i = left + 1; i < padLength - 8; i++) {
+                this.buffer[i] = 0;
+              }
+              this.buffer[padLength - 8] = bitLenHi >>> 24 & 255;
+              this.buffer[padLength - 7] = bitLenHi >>> 16 & 255;
+              this.buffer[padLength - 6] = bitLenHi >>> 8 & 255;
+              this.buffer[padLength - 5] = bitLenHi >>> 0 & 255;
+              this.buffer[padLength - 4] = bitLenLo >>> 24 & 255;
+              this.buffer[padLength - 3] = bitLenLo >>> 16 & 255;
+              this.buffer[padLength - 2] = bitLenLo >>> 8 & 255;
+              this.buffer[padLength - 1] = bitLenLo >>> 0 & 255;
+              hashBlocks(this.temp, this.state, this.buffer, 0, padLength);
+              this.finished = true;
+            }
+            for (var i = 0; i < 8; i++) {
+              out[i * 4 + 0] = this.state[i] >>> 24 & 255;
+              out[i * 4 + 1] = this.state[i] >>> 16 & 255;
+              out[i * 4 + 2] = this.state[i] >>> 8 & 255;
+              out[i * 4 + 3] = this.state[i] >>> 0 & 255;
+            }
+            return this;
+          };
+          Hash2.prototype.digest = function() {
+            var out = new Uint8Array(this.digestLength);
+            this.finish(out);
+            return out;
+          };
+          Hash2.prototype._saveState = function(out) {
+            for (var i = 0; i < this.state.length; i++) {
+              out[i] = this.state[i];
+            }
+          };
+          Hash2.prototype._restoreState = function(from, bytesHashed) {
+            for (var i = 0; i < this.state.length; i++) {
+              this.state[i] = from[i];
+            }
+            this.bytesHashed = bytesHashed;
+            this.finished = false;
+            this.bufferLength = 0;
+          };
+          return Hash2;
+        }()
+      );
+      exports2.Hash = Hash;
+      var HMAC = (
+        /** @class */
+        function() {
+          function HMAC2(key) {
+            this.inner = new Hash();
+            this.outer = new Hash();
+            this.blockSize = this.inner.blockSize;
+            this.digestLength = this.inner.digestLength;
+            var pad = new Uint8Array(this.blockSize);
+            if (key.length > this.blockSize) {
+              new Hash().update(key).finish(pad).clean();
+            } else {
+              for (var i = 0; i < key.length; i++) {
+                pad[i] = key[i];
+              }
+            }
+            for (var i = 0; i < pad.length; i++) {
+              pad[i] ^= 54;
+            }
+            this.inner.update(pad);
+            for (var i = 0; i < pad.length; i++) {
+              pad[i] ^= 54 ^ 92;
+            }
+            this.outer.update(pad);
+            this.istate = new Uint32Array(8);
+            this.ostate = new Uint32Array(8);
+            this.inner._saveState(this.istate);
+            this.outer._saveState(this.ostate);
+            for (var i = 0; i < pad.length; i++) {
+              pad[i] = 0;
+            }
+          }
+          HMAC2.prototype.reset = function() {
+            this.inner._restoreState(this.istate, this.inner.blockSize);
+            this.outer._restoreState(this.ostate, this.outer.blockSize);
+            return this;
+          };
+          HMAC2.prototype.clean = function() {
+            for (var i = 0; i < this.istate.length; i++) {
+              this.ostate[i] = this.istate[i] = 0;
+            }
+            this.inner.clean();
+            this.outer.clean();
+          };
+          HMAC2.prototype.update = function(data) {
+            this.inner.update(data);
+            return this;
+          };
+          HMAC2.prototype.finish = function(out) {
+            if (this.outer.finished) {
+              this.outer.finish(out);
+            } else {
+              this.inner.finish(out);
+              this.outer.update(out, this.digestLength).finish(out);
+            }
+            return this;
+          };
+          HMAC2.prototype.digest = function() {
+            var out = new Uint8Array(this.digestLength);
+            this.finish(out);
+            return out;
+          };
+          return HMAC2;
+        }()
+      );
+      exports2.HMAC = HMAC;
+      function hash(data) {
+        var h = new Hash().update(data);
+        var digest = h.digest();
+        h.clean();
+        return digest;
+      }
+      exports2.hash = hash;
+      exports2["default"] = hash;
+      function hmac2(key, data) {
+        var h = new HMAC(key).update(data);
+        var digest = h.digest();
+        h.clean();
+        return digest;
+      }
+      exports2.hmac = hmac2;
+      function fillBuffer(buffer, hmac3, info, counter) {
+        var num = counter[0];
+        if (num === 0) {
+          throw new Error("hkdf: cannot expand more");
+        }
+        hmac3.reset();
+        if (num > 1) {
+          hmac3.update(buffer);
+        }
+        if (info) {
+          hmac3.update(info);
+        }
+        hmac3.update(counter);
+        hmac3.finish(buffer);
+        counter[0]++;
+      }
+      var hkdfSalt = new Uint8Array(exports2.digestLength);
+      function hkdf(key, salt, info, length) {
+        if (salt === void 0) {
+          salt = hkdfSalt;
+        }
+        if (length === void 0) {
+          length = 32;
+        }
+        var counter = new Uint8Array([1]);
+        var okm = hmac2(salt, key);
+        var hmac_ = new HMAC(okm);
+        var buffer = new Uint8Array(hmac_.digestLength);
+        var bufpos = buffer.length;
+        var out = new Uint8Array(length);
+        for (var i = 0; i < length; i++) {
+          if (bufpos === buffer.length) {
+            fillBuffer(buffer, hmac_, info, counter);
+            bufpos = 0;
+          }
+          out[i] = buffer[bufpos++];
+        }
+        hmac_.clean();
+        buffer.fill(0);
+        counter.fill(0);
+        return out;
+      }
+      exports2.hkdf = hkdf;
+      function pbkdf2(password, salt, iterations, dkLen) {
+        var prf = new HMAC(password);
+        var len = prf.digestLength;
+        var ctr = new Uint8Array(4);
+        var t = new Uint8Array(len);
+        var u = new Uint8Array(len);
+        var dk = new Uint8Array(dkLen);
+        for (var i = 0; i * len < dkLen; i++) {
+          var c = i + 1;
+          ctr[0] = c >>> 24 & 255;
+          ctr[1] = c >>> 16 & 255;
+          ctr[2] = c >>> 8 & 255;
+          ctr[3] = c >>> 0 & 255;
+          prf.reset();
+          prf.update(salt);
+          prf.update(ctr);
+          prf.finish(u);
+          for (var j = 0; j < len; j++) {
+            t[j] = u[j];
+          }
+          for (var j = 2; j <= iterations; j++) {
+            prf.reset();
+            prf.update(u).finish(u);
+            for (var k = 0; k < len; k++) {
+              t[k] ^= u[k];
+            }
+          }
+          for (var j = 0; j < len && i * len + j < dkLen; j++) {
+            dk[i * len + j] = t[j];
+          }
+        }
+        for (var i = 0; i < len; i++) {
+          t[i] = u[i] = 0;
+        }
+        for (var i = 0; i < 4; i++) {
+          ctr[i] = 0;
+        }
+        prf.clean();
+        return dk;
+      }
+      exports2.pbkdf2 = pbkdf2;
+    });
+  }
+});
+
+// src/webhook/vendor/standardwebhook.ts
+__toESM(require_base64());
+__toESM(require_sha256());
+/**
+ * The MIT License
+ *
+ * Copyright (c) 2023 Svix (https://www.svix.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @fileoverview Server-only webhook verification implementation.
+ * @description Vendored from standardwebhooks package to avoid bundling issues.
+ * Uses Node.js crypto module - DO NOT import in client/browser code.
+ * @license MIT
+ * @internal
+ */
+
+// src/webhook/webhook.ts
 async function handleWebhookPayload(payload, config, context) {
   const callHandler = (handler, payload2) => {
     if (!handler) return;
@@ -8018,9 +9378,6 @@ async function handleWebhookPayload(payload, config, context) {
   if (payload.type === "subscription.renewed") {
     await callHandler(config.onSubscriptionRenewed, payload);
   }
-  if (payload.type === "subscription.paused") {
-    await callHandler(config.onSubscriptionPaused, payload);
-  }
   if (payload.type === "subscription.plan_changed") {
     await callHandler(config.onSubscriptionPlanChanged, payload);
   }
@@ -8039,6 +9396,30 @@ async function handleWebhookPayload(payload, config, context) {
   if (payload.type === "license_key.created") {
     await callHandler(config.onLicenseKeyCreated, payload);
   }
+  if (payload.type === "credit.added") {
+    await callHandler(config.onCreditAdded, payload);
+  }
+  if (payload.type === "credit.deducted") {
+    await callHandler(config.onCreditDeducted, payload);
+  }
+  if (payload.type === "credit.expired") {
+    await callHandler(config.onCreditExpired, payload);
+  }
+  if (payload.type === "credit.rolled_over") {
+    await callHandler(config.onCreditRolledOver, payload);
+  }
+  if (payload.type === "credit.rollover_forfeited") {
+    await callHandler(config.onCreditRolloverForfeited, payload);
+  }
+  if (payload.type === "credit.overage_charged") {
+    await callHandler(config.onCreditOverageCharged, payload);
+  }
+  if (payload.type === "credit.manual_adjustment") {
+    await callHandler(config.onCreditManualAdjustment, payload);
+  }
+  if (payload.type === "credit.balance_low") {
+    await callHandler(config.onCreditBalanceLow, payload);
+  }
 }
 
 const Webhooks = ({ webhookKey, ...eventHandlers }) => {