Update generated code for v1763

OPENAPI_VERSION

@@ -1 +1 @@
-v1762
+v1763

lib/stripe/resources/subscription.rb

@@ -1855,6 +1855,18 @@ module Stripe
       end
     end
 
+    class MigrateParams < Stripe::RequestParams
+      # Controls how prorations and invoices for subscriptions are calculated and orchestrated.
+      attr_accessor :billing_mode
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(billing_mode: nil, expand: nil)
+        @billing_mode = billing_mode
+        @expand = expand
+      end
+    end
+
     class ResumeParams < Stripe::RequestParams
       # The billing cycle anchor that applies when the subscription is resumed. Either `now` or `unchanged`. The default is `now`. For more information, see the billing cycle [documentation](https://stripe.com/docs/billing/subscriptions/billing-cycle).
       attr_accessor :billing_cycle_anchor
@@ -2044,6 +2056,26 @@ module Stripe
       request_stripe_object(method: :get, path: "/v1/subscriptions", params: params, opts: opts)
     end
 
+    # This endpoint allows merchants to upgrade the billing_mode on their existing subscriptions.
+    def migrate(params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/subscriptions/%<subscription>s/migrate", { subscription: CGI.escape(self["id"]) }),
+        params: params,
+        opts: opts
+      )
+    end
+
+    # This endpoint allows merchants to upgrade the billing_mode on their existing subscriptions.
+    def self.migrate(subscription, params = {}, opts = {})
+      request_stripe_object(
+        method: :post,
+        path: format("/v1/subscriptions/%<subscription>s/migrate", { subscription: CGI.escape(subscription) }),
+        params: params,
+        opts: opts
+      )
+    end
+
     # Initiates resumption of a paused subscription, optionally resetting the billing cycle anchor and creating prorations. If a resumption invoice is generated, it must be paid or marked uncollectible before the subscription will be unpaused. If payment succeeds the subscription will become active, and if payment fails the subscription will be past_due. The resumption invoice will void automatically if not paid by the expiration date.
     def resume(params = {}, opts = {})
       request_stripe_object(

lib/stripe/services/subscription_service.rb

@@ -1629,6 +1629,18 @@ module Stripe
       end
     end
 
+    class MigrateParams < Stripe::RequestParams
+      # Controls how prorations and invoices for subscriptions are calculated and orchestrated.
+      attr_accessor :billing_mode
+      # Specifies which fields in the response should be expanded.
+      attr_accessor :expand
+
+      def initialize(billing_mode: nil, expand: nil)
+        @billing_mode = billing_mode
+        @expand = expand
+      end
+    end
+
     class ResumeParams < Stripe::RequestParams
       # The billing cycle anchor that applies when the subscription is resumed. Either `now` or `unchanged`. The default is `now`. For more information, see the billing cycle [documentation](https://stripe.com/docs/billing/subscriptions/billing-cycle).
       attr_accessor :billing_cycle_anchor
@@ -1706,6 +1718,17 @@ module Stripe
       )
     end
 
+    # This endpoint allows merchants to upgrade the billing_mode on their existing subscriptions.
+    def migrate(subscription, params = {}, opts = {})
+      request(
+        method: :post,
+        path: format("/v1/subscriptions/%<subscription>s/migrate", { subscription: CGI.escape(subscription) }),
+        params: params,
+        opts: opts,
+        base_address: :api
+      )
+    end
+
     # Initiates resumption of a paused subscription, optionally resetting the billing cycle anchor and creating prorations. If a resumption invoice is generated, it must be paid or marked uncollectible before the subscription will be unpaused. If payment succeeds the subscription will become active, and if payment fails the subscription will be past_due. The resumption invoice will void automatically if not paid by the expiration date.
     def resume(subscription, params = {}, opts = {})
       request(

rbi/stripe.rbi

@@ -92738,6 +92738,16 @@ module Stripe
        }
       def initialize(expand: nil, limit: nil, page: nil, query: nil); end
     end
+    class MigrateParams < Stripe::RequestParams
+      # Controls how prorations and invoices for subscriptions are calculated and orchestrated.
+      sig { returns(String) }
+      attr_accessor :billing_mode
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :expand
+      sig { params(billing_mode: String, expand: T.nilable(T::Array[String])).void }
+      def initialize(billing_mode: nil, expand: nil); end
+    end
     class ResumeParams < Stripe::RequestParams
       # The billing cycle anchor that applies when the subscription is resumed. Either `now` or `unchanged`. The default is `now`. For more information, see the billing cycle [documentation](https://stripe.com/docs/billing/subscriptions/billing-cycle).
       sig { returns(T.nilable(String)) }
@@ -92811,6 +92821,18 @@ module Stripe
      }
     def self.list(params = {}, opts = {}); end
 
+    # This endpoint allows merchants to upgrade the billing_mode on their existing subscriptions.
+    sig {
+      params(params: T.any(::Stripe::Subscription::MigrateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Subscription)
+     }
+    def migrate(params = {}, opts = {}); end
+
+    # This endpoint allows merchants to upgrade the billing_mode on their existing subscriptions.
+    sig {
+      params(subscription: String, params: T.any(::Stripe::Subscription::MigrateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Subscription)
+     }
+    def self.migrate(subscription, params = {}, opts = {}); end
+
     # Initiates resumption of a paused subscription, optionally resetting the billing cycle anchor and creating prorations. If a resumption invoice is generated, it must be paid or marked uncollectible before the subscription will be unpaused. If payment succeeds the subscription will become active, and if payment fails the subscription will be past_due. The resumption invoice will void automatically if not paid by the expiration date.
     sig {
       params(params: T.any(::Stripe::Subscription::ResumeParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Subscription)
@@ -172046,6 +172068,16 @@ module Stripe
        }
       def initialize(expand: nil, limit: nil, page: nil, query: nil); end
     end
+    class MigrateParams < Stripe::RequestParams
+      # Controls how prorations and invoices for subscriptions are calculated and orchestrated.
+      sig { returns(String) }
+      attr_accessor :billing_mode
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :expand
+      sig { params(billing_mode: String, expand: T.nilable(T::Array[String])).void }
+      def initialize(billing_mode: nil, expand: nil); end
+    end
     class ResumeParams < Stripe::RequestParams
       # The billing cycle anchor that applies when the subscription is resumed. Either `now` or `unchanged`. The default is `now`. For more information, see the billing cycle [documentation](https://stripe.com/docs/billing/subscriptions/billing-cycle).
       sig { returns(T.nilable(String)) }
@@ -172103,6 +172135,12 @@ module Stripe
      }
     def list(params = {}, opts = {}); end
 
+    # This endpoint allows merchants to upgrade the billing_mode on their existing subscriptions.
+    sig {
+      params(subscription: String, params: T.any(::Stripe::SubscriptionService::MigrateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Subscription)
+     }
+    def migrate(subscription, params = {}, opts = {}); end
+
     # Initiates resumption of a paused subscription, optionally resetting the billing cycle anchor and creating prorations. If a resumption invoice is generated, it must be paid or marked uncollectible before the subscription will be unpaused. If payment succeeds the subscription will become active, and if payment fails the subscription will be past_due. The resumption invoice will void automatically if not paid by the expiration date.
     sig {
       params(subscription: String, params: T.any(::Stripe::SubscriptionService::ResumeParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Subscription)

rbi/stripe/resources/subscription.rbi

@@ -2151,6 +2151,16 @@ module Stripe
        }
       def initialize(expand: nil, limit: nil, page: nil, query: nil); end
     end
+    class MigrateParams < Stripe::RequestParams
+      # Controls how prorations and invoices for subscriptions are calculated and orchestrated.
+      sig { returns(String) }
+      attr_accessor :billing_mode
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :expand
+      sig { params(billing_mode: String, expand: T.nilable(T::Array[String])).void }
+      def initialize(billing_mode: nil, expand: nil); end
+    end
     class ResumeParams < Stripe::RequestParams
       # The billing cycle anchor that applies when the subscription is resumed. Either `now` or `unchanged`. The default is `now`. For more information, see the billing cycle [documentation](https://stripe.com/docs/billing/subscriptions/billing-cycle).
       sig { returns(T.nilable(String)) }
@@ -2224,6 +2234,18 @@ module Stripe
      }
     def self.list(params = {}, opts = {}); end
 
+    # This endpoint allows merchants to upgrade the billing_mode on their existing subscriptions.
+    sig {
+      params(params: T.any(::Stripe::Subscription::MigrateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Subscription)
+     }
+    def migrate(params = {}, opts = {}); end
+
+    # This endpoint allows merchants to upgrade the billing_mode on their existing subscriptions.
+    sig {
+      params(subscription: String, params: T.any(::Stripe::Subscription::MigrateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Subscription)
+     }
+    def self.migrate(subscription, params = {}, opts = {}); end
+
     # Initiates resumption of a paused subscription, optionally resetting the billing cycle anchor and creating prorations. If a resumption invoice is generated, it must be paid or marked uncollectible before the subscription will be unpaused. If payment succeeds the subscription will become active, and if payment fails the subscription will be past_due. The resumption invoice will void automatically if not paid by the expiration date.
     sig {
       params(params: T.any(::Stripe::Subscription::ResumeParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Subscription)

rbi/stripe/services/subscription_service.rbi

@@ -1749,6 +1749,16 @@ module Stripe
        }
       def initialize(expand: nil, limit: nil, page: nil, query: nil); end
     end
+    class MigrateParams < Stripe::RequestParams
+      # Controls how prorations and invoices for subscriptions are calculated and orchestrated.
+      sig { returns(String) }
+      attr_accessor :billing_mode
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :expand
+      sig { params(billing_mode: String, expand: T.nilable(T::Array[String])).void }
+      def initialize(billing_mode: nil, expand: nil); end
+    end
     class ResumeParams < Stripe::RequestParams
       # The billing cycle anchor that applies when the subscription is resumed. Either `now` or `unchanged`. The default is `now`. For more information, see the billing cycle [documentation](https://stripe.com/docs/billing/subscriptions/billing-cycle).
       sig { returns(T.nilable(String)) }
@@ -1806,6 +1816,12 @@ module Stripe
      }
     def list(params = {}, opts = {}); end
 
+    # This endpoint allows merchants to upgrade the billing_mode on their existing subscriptions.
+    sig {
+      params(subscription: String, params: T.any(::Stripe::SubscriptionService::MigrateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Subscription)
+     }
+    def migrate(subscription, params = {}, opts = {}); end
+
     # Initiates resumption of a paused subscription, optionally resetting the billing cycle anchor and creating prorations. If a resumption invoice is generated, it must be paid or marked uncollectible before the subscription will be unpaused. If payment succeeds the subscription will become active, and if payment fails the subscription will be past_due. The resumption invoice will void automatically if not paid by the expiration date.
     sig {
       params(subscription: String, params: T.any(::Stripe::SubscriptionService::ResumeParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Subscription)