stripe 18.5.0-beta.2 → 18.6.0-alpha.1

package/cjs/stripe.core.js

@@ -36,7 +36,7 @@ const ALLOWED_CONFIG_PROPERTIES = [
 ];
 const defaultRequestSenderFactory = (stripe) => new RequestSender_js_1.RequestSender(stripe, StripeResource_js_1.StripeResource.MAX_BUFFERED_REQUEST_METRICS);
 function createStripe(platformFunctions, requestSender = defaultRequestSenderFactory) {
-    Stripe.PACKAGE_VERSION = '18.5.0-beta.2';
+    Stripe.PACKAGE_VERSION = '18.6.0-alpha.1';
     Stripe.API_VERSION = apiVersion_js_1.ApiVersion;
     Stripe.USER_AGENT = Object.assign({ bindings_version: Stripe.PACKAGE_VERSION, lang: 'node', publisher: 'stripe', uname: null, typescript: false }, (0, utils_js_1.determineProcessUserAgentProperties)());
     Stripe.StripeResource = StripeResource_js_1.StripeResource;
@@ -358,6 +358,32 @@ function createStripe(platformFunctions, requestSender = defaultRequestSenderFac
             // parses and validates the event payload all in one go
             return this.webhooks.constructEvent(payload, header, secret, tolerance, cryptoProvider, receivedAt);
         },
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        parseThinEvent__experimental(payload, header, secret, tolerance, cryptoProvider, receivedAt
+        // this return type is ignored?? picks up types from `types/index.d.ts` instead
+        ) {
+            // parses and validates the event payload all in one go
+            // ideally would call the method above, but it's inaceessible
+            const thinEvent = this.webhooks.constructEvent(payload, header, secret, tolerance, cryptoProvider, receivedAt);
+            thinEvent.pull = () => {
+                // all the resources, like v2, get added later, but TS doesn't know about them yet
+                // hence the use of `any`
+                return this._requestSender._rawRequest('GET', '/v2/core/events/' + thinEvent.id, undefined, {
+                    stripeAccount: thinEvent.context,
+                }, ['pull_event']);
+            };
+            if (thinEvent.related_object) {
+                thinEvent.fetchRelatedObject = () => {
+                    return this._requestSender._rawRequest('GET', 
+                    // rawRequest takes a path, but events give a full URL
+                    // this assumes that the event's URL matches client's base URL
+                    new URL(thinEvent.related_object.url).pathname, undefined, {
+                        stripeAccount: thinEvent.context,
+                    }, ['pushed_event_fetch_related_object']);
+                };
+            }
+            return thinEvent;
+        },
     };
     return Stripe;
 }

package/esm/Error.js

@@ -24,34 +24,36 @@ export const generateV1Error = (rawStripeError) => {
 export const generateV2Error = (rawStripeError) => {
     switch (rawStripeError.type) {
         // switchCases: The beginning of the section generated from our OpenAPI spec
-        case 'temporary_session_expired':
-            return new TemporarySessionExpiredError(rawStripeError);
-        case 'non_zero_balance':
-            return new NonZeroBalanceError(rawStripeError);
+        case 'already_canceled':
+            return new AlreadyCanceledError(rawStripeError);
         case 'already_exists':
             return new AlreadyExistsError(rawStripeError);
+        case 'blocked_by_stripe':
+            return new BlockedByStripeError(rawStripeError);
+        case 'controlled_by_dashboard':
+            return new ControlledByDashboardError(rawStripeError);
         case 'feature_not_enabled':
             return new FeatureNotEnabledError(rawStripeError);
         case 'financial_account_not_open':
             return new FinancialAccountNotOpenError(rawStripeError);
-        case 'blocked_by_stripe':
-            return new BlockedByStripeError(rawStripeError);
-        case 'already_canceled':
-            return new AlreadyCanceledError(rawStripeError);
-        case 'not_cancelable':
-            return new NotCancelableError(rawStripeError);
         case 'insufficient_funds':
             return new InsufficientFundsError(rawStripeError);
+        case 'invalid_payment_method':
+            return new InvalidPaymentMethodError(rawStripeError);
+        case 'invalid_payout_method':
+            return new InvalidPayoutMethodError(rawStripeError);
+        case 'non_zero_balance':
+            return new NonZeroBalanceError(rawStripeError);
+        case 'not_cancelable':
+            return new NotCancelableError(rawStripeError);
         case 'quota_exceeded':
             return new QuotaExceededError(rawStripeError);
+        case 'rate_limit':
+            return new RateLimitError(rawStripeError);
         case 'recipient_not_notifiable':
             return new RecipientNotNotifiableError(rawStripeError);
-        case 'invalid_payout_method':
-            return new InvalidPayoutMethodError(rawStripeError);
-        case 'controlled_by_dashboard':
-            return new ControlledByDashboardError(rawStripeError);
-        case 'invalid_payment_method':
-            return new InvalidPaymentMethodError(rawStripeError);
+        case 'temporary_session_expired':
+            return new TemporarySessionExpiredError(rawStripeError);
         // switchCases: The end of the section generated from our OpenAPI spec
     }
     // Special handling for requests with missing required fields in V2 APIs.
@@ -203,19 +205,24 @@ export class StripeUnknownError extends StripeError {
     }
 }
 // classDefinitions: The beginning of the section generated from our OpenAPI spec
-export class TemporarySessionExpiredError extends StripeError {
+export class AlreadyCanceledError extends StripeError {
     constructor(rawStripeError = {}) {
-        super(rawStripeError, 'TemporarySessionExpiredError');
+        super(rawStripeError, 'AlreadyCanceledError');
     }
 }
-export class NonZeroBalanceError extends StripeError {
+export class AlreadyExistsError extends StripeError {
     constructor(rawStripeError = {}) {
-        super(rawStripeError, 'NonZeroBalanceError');
+        super(rawStripeError, 'AlreadyExistsError');
     }
 }
-export class AlreadyExistsError extends StripeError {
+export class BlockedByStripeError extends StripeError {
     constructor(rawStripeError = {}) {
-        super(rawStripeError, 'AlreadyExistsError');
+        super(rawStripeError, 'BlockedByStripeError');
+    }
+}
+export class ControlledByDashboardError extends StripeError {
+    constructor(rawStripeError = {}) {
+        super(rawStripeError, 'ControlledByDashboardError');
     }
 }
 export class FeatureNotEnabledError extends StripeError {
@@ -228,24 +235,31 @@ export class FinancialAccountNotOpenError extends StripeError {
         super(rawStripeError, 'FinancialAccountNotOpenError');
     }
 }
-export class BlockedByStripeError extends StripeError {
+export class InsufficientFundsError extends StripeError {
     constructor(rawStripeError = {}) {
-        super(rawStripeError, 'BlockedByStripeError');
+        super(rawStripeError, 'InsufficientFundsError');
     }
 }
-export class AlreadyCanceledError extends StripeError {
+export class InvalidPaymentMethodError extends StripeError {
+    constructor(rawStripeError) {
+        super(rawStripeError, 'InvalidPaymentMethodError');
+        // @ts-ignore
+        this.invalid_param = this.raw.invalid_param;
+    }
+}
+export class InvalidPayoutMethodError extends StripeError {
     constructor(rawStripeError = {}) {
-        super(rawStripeError, 'AlreadyCanceledError');
+        super(rawStripeError, 'InvalidPayoutMethodError');
     }
 }
-export class NotCancelableError extends StripeError {
+export class NonZeroBalanceError extends StripeError {
     constructor(rawStripeError = {}) {
-        super(rawStripeError, 'NotCancelableError');
+        super(rawStripeError, 'NonZeroBalanceError');
     }
 }
-export class InsufficientFundsError extends StripeError {
+export class NotCancelableError extends StripeError {
     constructor(rawStripeError = {}) {
-        super(rawStripeError, 'InsufficientFundsError');
+        super(rawStripeError, 'NotCancelableError');
     }
 }
 export class QuotaExceededError extends StripeError {
@@ -253,26 +267,19 @@ export class QuotaExceededError extends StripeError {
         super(rawStripeError, 'QuotaExceededError');
     }
 }
-export class RecipientNotNotifiableError extends StripeError {
+export class RateLimitError extends StripeError {
     constructor(rawStripeError = {}) {
-        super(rawStripeError, 'RecipientNotNotifiableError');
+        super(rawStripeError, 'RateLimitError');
     }
 }
-export class InvalidPayoutMethodError extends StripeError {
+export class RecipientNotNotifiableError extends StripeError {
     constructor(rawStripeError = {}) {
-        super(rawStripeError, 'InvalidPayoutMethodError');
+        super(rawStripeError, 'RecipientNotNotifiableError');
     }
 }
-export class ControlledByDashboardError extends StripeError {
+export class TemporarySessionExpiredError extends StripeError {
     constructor(rawStripeError = {}) {
-        super(rawStripeError, 'ControlledByDashboardError');
-    }
-}
-export class InvalidPaymentMethodError extends StripeError {
-    constructor(rawStripeError) {
-        super(rawStripeError, 'InvalidPaymentMethodError');
-        // @ts-ignore
-        this.invalid_param = this.raw.invalid_param;
+        super(rawStripeError, 'TemporarySessionExpiredError');
     }
 }
 // classDefinitions: The end of the section generated from our OpenAPI spec

package/esm/RequestSender.js

@@ -282,7 +282,7 @@ export class RequestSender {
             }
         }
     }
-    _rawRequest(method, path, params, options) {
+    _rawRequest(method, path, params, options, usage) {
         const requestPromise = new Promise((resolve, reject) => {
             let opts;
             try {
@@ -310,7 +310,8 @@ export class RequestSender {
                     host: calculatedOptions.host,
                     streaming: !!calculatedOptions.streaming,
                     settings: {},
-                    usage: ['raw_request'],
+                    // If used internally for a non raw_request, overwrite the usage
+                    usage: usage || ['raw_request'],
                 };
             }
             catch (err) {
@@ -414,6 +415,7 @@ export class RequestSender {
             }
             requestData = data;
             this._stripe.getClientUserAgent((clientUserAgent) => {
+                var _a, _b;
                 const apiVersion = this._stripe.getApiField('version');
                 const headers = this._makeHeaders({
                     contentType: apiMode == 'v2'
@@ -423,8 +425,9 @@ export class RequestSender {
                     apiVersion: apiVersion,
                     clientUserAgent,
                     method,
-                    userSuppliedHeaders: options.headers,
-                    userSuppliedSettings: options.settings,
+                    // other callers expect null, but .headers being optional means it's undefined if not supplied. So we normalize to null.
+                    userSuppliedHeaders: (_a = options.headers) !== null && _a !== void 0 ? _a : null,
+                    userSuppliedSettings: (_b = options.settings) !== null && _b !== void 0 ? _b : {},
                     stripeAccount: apiMode == 'v2' ? null : this._stripe.getApiField('stripeAccount'),
                     stripeContext: apiMode == 'v2' ? this._stripe.getApiField('stripeContext') : null,
                     apiMode: apiMode,

package/esm/apiVersion.js

@@ -1,2 +1,2 @@
 // File generated from our OpenAPI spec
-export const ApiVersion = '2025-07-30.preview';
+export const ApiVersion = '2025-08-27.preview';

package/esm/resources/Mandates.js

@@ -3,4 +3,9 @@ import { StripeResource } from '../StripeResource.js';
 const stripeMethod = StripeResource.method;
 export const Mandates = StripeResource.extend({
     retrieve: stripeMethod({ method: 'GET', fullPath: '/v1/mandates/{mandate}' }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v1/mandates',
+        methodType: 'list',
+    }),
 });

package/esm/resources/Subscriptions.js

@@ -16,6 +16,10 @@ export const Subscriptions = StripeResource.extend({
         fullPath: '/v1/subscriptions',
         methodType: 'list',
     }),
+    attachCadence: stripeMethod({
+        method: 'POST',
+        fullPath: '/v1/subscriptions/{subscription}/attach_cadence',
+    }),
     cancel: stripeMethod({
         method: 'DELETE',
         fullPath: '/v1/subscriptions/{subscription_exposed_id}',

package/esm/resources/V2/Billing/BillSettings/Versions.js

@@ -0,0 +1,14 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const Versions = StripeResource.extend({
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/bill_settings/{bill_setting_id}/versions/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/bill_settings/{bill_setting_id}/versions',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/BillSettings.js

@@ -0,0 +1,24 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../StripeResource.js';
+import { Versions } from './BillSettings/Versions.js';
+const stripeMethod = StripeResource.method;
+export const BillSettings = StripeResource.extend({
+    constructor: function (...args) {
+        StripeResource.apply(this, args);
+        this.versions = new Versions(...args);
+    },
+    create: stripeMethod({ method: 'POST', fullPath: '/v2/billing/bill_settings' }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/bill_settings/{id}',
+    }),
+    update: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/bill_settings/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/bill_settings',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/Cadences.js

@@ -0,0 +1,20 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const Cadences = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v2/billing/cadences' }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/cadences/{id}',
+    }),
+    update: stripeMethod({ method: 'POST', fullPath: '/v2/billing/cadences/{id}' }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/cadences',
+        methodType: 'list',
+    }),
+    cancel: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/cadences/{id}/cancel',
+    }),
+});

package/esm/resources/V2/Billing/CollectionSettings/Versions.js

@@ -0,0 +1,14 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const Versions = StripeResource.extend({
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/collection_settings/{collection_setting_id}/versions/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/collection_settings/{collection_setting_id}/versions',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/CollectionSettings.js

@@ -0,0 +1,27 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../StripeResource.js';
+import { Versions } from './CollectionSettings/Versions.js';
+const stripeMethod = StripeResource.method;
+export const CollectionSettings = StripeResource.extend({
+    constructor: function (...args) {
+        StripeResource.apply(this, args);
+        this.versions = new Versions(...args);
+    },
+    create: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/collection_settings',
+    }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/collection_settings/{id}',
+    }),
+    update: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/collection_settings/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/collection_settings',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/CustomPricingUnits.js

@@ -0,0 +1,22 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const CustomPricingUnits = StripeResource.extend({
+    create: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/custom_pricing_units',
+    }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/custom_pricing_units/{id}',
+    }),
+    update: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/custom_pricing_units/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/custom_pricing_units',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/Intents/Actions.js

@@ -0,0 +1,14 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const Actions = StripeResource.extend({
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/intents/{intent_id}/actions/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/intents/{intent_id}/actions',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/Intents.js

@@ -0,0 +1,33 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../StripeResource.js';
+import { Actions } from './Intents/Actions.js';
+const stripeMethod = StripeResource.method;
+export const Intents = StripeResource.extend({
+    constructor: function (...args) {
+        StripeResource.apply(this, args);
+        this.actions = new Actions(...args);
+    },
+    create: stripeMethod({ method: 'POST', fullPath: '/v2/billing/intents' }),
+    retrieve: stripeMethod({ method: 'GET', fullPath: '/v2/billing/intents/{id}' }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/intents',
+        methodType: 'list',
+    }),
+    cancel: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/intents/{id}/cancel',
+    }),
+    commit: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/intents/{id}/commit',
+    }),
+    releaseReservation: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/intents/{id}/release_reservation',
+    }),
+    reserve: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/intents/{id}/reserve',
+    }),
+});

package/esm/resources/V2/Billing/LicenseFeeSubscriptions.js

@@ -0,0 +1,9 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const LicenseFeeSubscriptions = StripeResource.extend({
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/license_fee_subscriptions/{id}',
+    }),
+});

package/esm/resources/V2/Billing/LicenseFees/Versions.js

@@ -0,0 +1,14 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const Versions = StripeResource.extend({
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/license_fees/{license_fee_id}/versions/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/license_fees/{license_fee_id}/versions',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/LicenseFees.js

@@ -0,0 +1,24 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../StripeResource.js';
+import { Versions } from './LicenseFees/Versions.js';
+const stripeMethod = StripeResource.method;
+export const LicenseFees = StripeResource.extend({
+    constructor: function (...args) {
+        StripeResource.apply(this, args);
+        this.versions = new Versions(...args);
+    },
+    create: stripeMethod({ method: 'POST', fullPath: '/v2/billing/license_fees' }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/license_fees/{id}',
+    }),
+    update: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/license_fees/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/license_fees',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/LicensedItems.js

@@ -0,0 +1,22 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const LicensedItems = StripeResource.extend({
+    create: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/licensed_items',
+    }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/licensed_items/{id}',
+    }),
+    update: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/licensed_items/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/licensed_items',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/MeteredItems.js

@@ -0,0 +1,19 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const MeteredItems = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v2/billing/metered_items' }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/metered_items/{id}',
+    }),
+    update: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/metered_items/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/metered_items',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/PricingPlanSubscriptions.js

@@ -0,0 +1,14 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const PricingPlanSubscriptions = StripeResource.extend({
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/pricing_plan_subscriptions/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/pricing_plan_subscriptions',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/PricingPlans/Components.js

@@ -0,0 +1,26 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const Components = StripeResource.extend({
+    create: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/pricing_plans/{pricing_plan_id}/components',
+    }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/pricing_plans/{pricing_plan_id}/components/{id}',
+    }),
+    update: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/pricing_plans/{pricing_plan_id}/components/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/pricing_plans/{pricing_plan_id}/components',
+        methodType: 'list',
+    }),
+    del: stripeMethod({
+        method: 'DELETE',
+        fullPath: '/v2/billing/pricing_plans/{pricing_plan_id}/components/{id}',
+    }),
+});

package/esm/resources/V2/Billing/PricingPlans/Versions.js

@@ -0,0 +1,14 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const Versions = StripeResource.extend({
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/pricing_plans/{pricing_plan_id}/versions/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/pricing_plans/{pricing_plan_id}/versions',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/PricingPlans.js

@@ -0,0 +1,26 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../StripeResource.js';
+import { Components } from './PricingPlans/Components.js';
+import { Versions } from './PricingPlans/Versions.js';
+const stripeMethod = StripeResource.method;
+export const PricingPlans = StripeResource.extend({
+    constructor: function (...args) {
+        StripeResource.apply(this, args);
+        this.components = new Components(...args);
+        this.versions = new Versions(...args);
+    },
+    create: stripeMethod({ method: 'POST', fullPath: '/v2/billing/pricing_plans' }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/pricing_plans/{id}',
+    }),
+    update: stripeMethod({
+        method: 'POST',
+        fullPath: '/v2/billing/pricing_plans/{id}',
+    }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/pricing_plans',
+        methodType: 'list',
+    }),
+});

package/esm/resources/V2/Billing/Profiles.js

@@ -0,0 +1,16 @@
+// File generated from our OpenAPI spec
+import { StripeResource } from '../../../StripeResource.js';
+const stripeMethod = StripeResource.method;
+export const Profiles = StripeResource.extend({
+    create: stripeMethod({ method: 'POST', fullPath: '/v2/billing/profiles' }),
+    retrieve: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/profiles/{id}',
+    }),
+    update: stripeMethod({ method: 'POST', fullPath: '/v2/billing/profiles/{id}' }),
+    list: stripeMethod({
+        method: 'GET',
+        fullPath: '/v2/billing/profiles',
+        methodType: 'list',
+    }),
+});