@dodopayments/remix 0.2.5 → 0.2.6

package/dist/index.cjs

@@ -4180,7 +4180,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.
 /**
@@ -4390,6 +4390,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,
@@ -4483,6 +4502,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;
         }
@@ -4903,6 +4927,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) {
@@ -4933,66 +4967,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 });
+    preview(body, options) {
+        return this._client.post('/checkouts/preview', { body, ...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);
+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');
@@ -5062,6 +5185,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 {
     /**
@@ -5101,6 +5531,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.
@@ -5299,6 +5737,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 });
     }
@@ -5334,11 +5775,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 });
@@ -5376,6 +5835,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 {
@@ -5395,6 +5855,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 });
     }
@@ -5420,6 +5883,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
@@ -5467,6 +5939,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.
@@ -6588,6 +7066,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' }).");
         }
@@ -6652,18 +7132,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}`;
@@ -6827,7 +7296,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);
@@ -6835,9 +7306,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 = {
@@ -6902,9 +7374,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);
         }
@@ -6966,6 +7438,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 };
@@ -6994,6 +7471,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 });
         }
@@ -7038,6 +7522,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({
@@ -7629,23 +8115,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(),
@@ -7656,27 +8152,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(),
@@ -7689,21 +8183,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(),
@@ -7716,10 +8223,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()
@@ -7731,15 +8238,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(),
@@ -7747,7 +8311,6 @@ var SubscriptionSchema = objectType({
     "pending",
     "active",
     "on_hold",
-    "paused",
     "cancelled",
     "expired",
     "failed"
@@ -7755,20 +8318,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"),
@@ -7776,27 +8348,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(),
@@ -7806,7 +8382,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({
@@ -7905,12 +8481,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"),
@@ -7947,6 +8517,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,
@@ -7964,13 +8622,20 @@ 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
@@ -8698,9 +9363,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);
   }
@@ -8719,6 +9381,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 }) => {
@@ -8768,12 +9454,11 @@ const CustomerPortal = ({ bearerToken, environment, }) => {
     return async function (request) {
         const { searchParams } = new URL(request.url);
         const customerId = searchParams.get("customer_id");
-        const params = {
-            send_email: false,
-        };
-        const sendEmail = Boolean(searchParams.get("send_email"));
-        if (sendEmail) {
-            params.send_email = sendEmail;
+        const sendEmailParam = searchParams.get("send_email");
+        const params = {};
+        if (sendEmailParam !== null) {
+            // searchParams.get() already returns a single string or null
+            params.send_email = sendEmailParam === "true";
         }
         if (!customerId) {
             return new Response("Missing customerId in query parameters", {