stripe 15.2.1 → 15.3.0

data/rbi/stripe/services/checkout/session_service.rbi

@@ -1181,6 +1181,45 @@ module Stripe
             def initialize(capture_method: nil, setup_future_usage: nil); end
           end
           class Klarna < Stripe::RequestParams
+            class Subscription < Stripe::RequestParams
+              class NextBilling < Stripe::RequestParams
+                # The amount of the next charge for the subscription.
+                sig { returns(Integer) }
+                attr_accessor :amount
+                # The date of the next charge for the subscription in YYYY-MM-DD format.
+                sig { returns(String) }
+                attr_accessor :date
+                sig { params(amount: Integer, date: String).void }
+                def initialize(amount: nil, date: nil); end
+              end
+              # Unit of time between subscription charges.
+              sig { returns(String) }
+              attr_accessor :interval
+              # The number of intervals (specified in the `interval` attribute) between subscription charges. For example, `interval=month` and `interval_count=3` charges every 3 months.
+              sig { returns(T.nilable(Integer)) }
+              attr_accessor :interval_count
+              # Name for subscription.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :name
+              # Describes the upcoming charge for this subscription.
+              sig {
+                returns(::Stripe::Checkout::SessionService::CreateParams::PaymentMethodOptions::Klarna::Subscription::NextBilling)
+               }
+              attr_accessor :next_billing
+              # A non-customer-facing reference to correlate subscription charges in the Klarna app. Use a value that persists across subscription charges.
+              sig { returns(String) }
+              attr_accessor :reference
+              sig {
+                params(interval: String, interval_count: T.nilable(Integer), name: T.nilable(String), next_billing: ::Stripe::Checkout::SessionService::CreateParams::PaymentMethodOptions::Klarna::Subscription::NextBilling, reference: String).void
+               }
+              def initialize(
+                interval: nil,
+                interval_count: nil,
+                name: nil,
+                next_billing: nil,
+                reference: nil
+              ); end
+            end
             # Indicates that you intend to make future payments with this PaymentIntent's payment method.
             #
             # If you provide a Customer with the PaymentIntent, you can use this parameter to [attach the payment method](/payments/save-during-payment) to the Customer after the PaymentIntent is confirmed and the customer completes any required actions. If you don't provide a Customer, you can still [attach](/api/payment_methods/attach) the payment method to a Customer after the transaction completes.
@@ -1190,8 +1229,15 @@ module Stripe
             # When processing card payments, Stripe uses `setup_future_usage` to help you comply with regional legislation and network rules, such as [SCA](/strong-customer-authentication).
             sig { returns(T.nilable(String)) }
             attr_accessor :setup_future_usage
-            sig { params(setup_future_usage: T.nilable(String)).void }
-            def initialize(setup_future_usage: nil); end
+            # Subscription details if the Checkout Session sets up a future subscription.
+            sig {
+              returns(T.nilable(T.nilable(T.any(String, T::Array[::Stripe::Checkout::SessionService::CreateParams::PaymentMethodOptions::Klarna::Subscription]))))
+             }
+            attr_accessor :subscriptions
+            sig {
+              params(setup_future_usage: T.nilable(String), subscriptions: T.nilable(T.nilable(T.any(String, T::Array[::Stripe::Checkout::SessionService::CreateParams::PaymentMethodOptions::Klarna::Subscription])))).void
+             }
+            def initialize(setup_future_usage: nil, subscriptions: nil); end
           end
           class Konbini < Stripe::RequestParams
             # The number of calendar days (between 1 and 60) after which Konbini payment instructions will expire. For example, if a PaymentIntent is confirmed with Konbini and `expires_after_days` set to 2 on Monday JST, the instructions will expire on Wednesday 23:59:59 JST. Defaults to 3 days.
@@ -1938,6 +1984,13 @@ module Stripe
           def initialize(shipping_rate: nil, shipping_rate_data: nil); end
         end
         class SubscriptionData < Stripe::RequestParams
+          class BillingMode < Stripe::RequestParams
+            # Attribute for param field type
+            sig { returns(String) }
+            attr_accessor :type
+            sig { params(type: String).void }
+            def initialize(type: nil); end
+          end
           class InvoiceSettings < Stripe::RequestParams
             class Issuer < Stripe::RequestParams
               # The connected account being referenced when `type` is `account`.
@@ -1993,6 +2046,11 @@ module Stripe
           # A future timestamp to anchor the subscription's billing cycle for new subscriptions.
           sig { returns(T.nilable(Integer)) }
           attr_accessor :billing_cycle_anchor
+          # Controls how prorations and invoices for subscriptions are calculated and orchestrated.
+          sig {
+            returns(T.nilable(::Stripe::Checkout::SessionService::CreateParams::SubscriptionData::BillingMode))
+           }
+          attr_accessor :billing_mode
           # The tax rates that will apply to any subscription item that does not have
           # `tax_rates` set. Invoices created will have their `default_tax_rates` populated
           # from the subscription.
@@ -2022,13 +2080,10 @@ module Stripe
             returns(T.nilable(::Stripe::Checkout::SessionService::CreateParams::SubscriptionData::TransferData))
            }
           attr_accessor :transfer_data
-          # Unix timestamp representing the end of the trial period the customer
-          # will get before being charged for the first time. Has to be at least
-          # 48 hours in the future.
+          # Unix timestamp representing the end of the trial period the customer will get before being charged for the first time. Has to be at least 48 hours in the future.
           sig { returns(T.nilable(Integer)) }
           attr_accessor :trial_end
-          # Integer representing the number of trial period days before the
-          # customer is charged for the first time. Has to be at least 1.
+          # Integer representing the number of trial period days before the customer is charged for the first time. Has to be at least 1.
           sig { returns(T.nilable(Integer)) }
           attr_accessor :trial_period_days
           # Settings related to subscription trials.
@@ -2037,11 +2092,12 @@ module Stripe
            }
           attr_accessor :trial_settings
           sig {
-            params(application_fee_percent: T.nilable(Float), billing_cycle_anchor: T.nilable(Integer), default_tax_rates: T.nilable(T::Array[String]), description: T.nilable(String), invoice_settings: T.nilable(::Stripe::Checkout::SessionService::CreateParams::SubscriptionData::InvoiceSettings), metadata: T.nilable(T::Hash[String, String]), on_behalf_of: T.nilable(String), proration_behavior: T.nilable(String), transfer_data: T.nilable(::Stripe::Checkout::SessionService::CreateParams::SubscriptionData::TransferData), trial_end: T.nilable(Integer), trial_period_days: T.nilable(Integer), trial_settings: T.nilable(::Stripe::Checkout::SessionService::CreateParams::SubscriptionData::TrialSettings)).void
+            params(application_fee_percent: T.nilable(Float), billing_cycle_anchor: T.nilable(Integer), billing_mode: T.nilable(::Stripe::Checkout::SessionService::CreateParams::SubscriptionData::BillingMode), default_tax_rates: T.nilable(T::Array[String]), description: T.nilable(String), invoice_settings: T.nilable(::Stripe::Checkout::SessionService::CreateParams::SubscriptionData::InvoiceSettings), metadata: T.nilable(T::Hash[String, String]), on_behalf_of: T.nilable(String), proration_behavior: T.nilable(String), transfer_data: T.nilable(::Stripe::Checkout::SessionService::CreateParams::SubscriptionData::TransferData), trial_end: T.nilable(Integer), trial_period_days: T.nilable(Integer), trial_settings: T.nilable(::Stripe::Checkout::SessionService::CreateParams::SubscriptionData::TrialSettings)).void
            }
           def initialize(
             application_fee_percent: nil,
             billing_cycle_anchor: nil,
+            billing_mode: nil,
             default_tax_rates: nil,
             description: nil,
             invoice_settings: nil,
@@ -2175,7 +2231,7 @@ module Stripe
           returns(T.nilable(::Stripe::Checkout::SessionService::CreateParams::InvoiceCreation))
          }
         attr_accessor :invoice_creation
-        # A list of items the customer is purchasing. Use this parameter to pass one-time or recurring [Prices](https://stripe.com/docs/api/prices).
+        # A list of items the customer is purchasing. Use this parameter to pass one-time or recurring [Prices](https://stripe.com/docs/api/prices). The parameter is required for `payment` and `subscription` mode.
         #
         # For `payment` mode, there is a maximum of 100 line items, however it is recommended to consolidate line items if there are more than a few dozen.
         #

data/rbi/stripe/services/credit_note_preview_lines_service.rbi

@@ -80,7 +80,7 @@ module Stripe
         sig { params(shipping_rate: T.nilable(String)).void }
         def initialize(shipping_rate: nil); end
       end
-      # The integer amount in cents (or local equivalent) representing the total amount of the credit note.
+      # The integer amount in cents (or local equivalent) representing the total amount of the credit note. One of `amount`, `lines`, or `shipping_cost` must be provided.
       sig { returns(T.nilable(Integer)) }
       attr_accessor :amount
       # The integer amount in cents (or local equivalent) representing the amount to credit the customer's balance, which will be automatically applied to their next invoice.
@@ -104,7 +104,7 @@ module Stripe
       # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
       sig { returns(T.nilable(Integer)) }
       attr_accessor :limit
-      # Line items that make up the credit note.
+      # Line items that make up the credit note. One of `amount`, `lines`, or `shipping_cost` must be provided.
       sig {
         returns(T.nilable(T::Array[::Stripe::CreditNotePreviewLinesService::ListParams::Line]))
        }
@@ -129,7 +129,7 @@ module Stripe
         returns(T.nilable(T::Array[::Stripe::CreditNotePreviewLinesService::ListParams::Refund]))
        }
       attr_accessor :refunds
-      # When shipping_cost contains the shipping_rate from the invoice, the shipping_cost is included in the credit note.
+      # When shipping_cost contains the shipping_rate from the invoice, the shipping_cost is included in the credit note. One of `amount`, `lines`, or `shipping_cost` must be provided.
       sig { returns(T.nilable(::Stripe::CreditNotePreviewLinesService::ListParams::ShippingCost)) }
       attr_accessor :shipping_cost
       # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.

data/rbi/stripe/services/credit_note_service.rbi

@@ -135,7 +135,7 @@ module Stripe
         sig { params(shipping_rate: T.nilable(String)).void }
         def initialize(shipping_rate: nil); end
       end
-      # The integer amount in cents (or local equivalent) representing the total amount of the credit note.
+      # The integer amount in cents (or local equivalent) representing the total amount of the credit note. One of `amount`, `lines`, or `shipping_cost` must be provided.
       sig { returns(T.nilable(Integer)) }
       attr_accessor :amount
       # The integer amount in cents (or local equivalent) representing the amount to credit the customer's balance, which will be automatically applied to their next invoice.
@@ -153,7 +153,7 @@ module Stripe
       # ID of the invoice.
       sig { returns(String) }
       attr_accessor :invoice
-      # Line items that make up the credit note.
+      # Line items that make up the credit note. One of `amount`, `lines`, or `shipping_cost` must be provided.
       sig { returns(T.nilable(T::Array[::Stripe::CreditNoteService::CreateParams::Line])) }
       attr_accessor :lines
       # The credit note's memo appears on the credit note PDF.
@@ -174,7 +174,7 @@ module Stripe
       # Refunds to link to this credit note.
       sig { returns(T.nilable(T::Array[::Stripe::CreditNoteService::CreateParams::Refund])) }
       attr_accessor :refunds
-      # When shipping_cost contains the shipping_rate from the invoice, the shipping_cost is included in the credit note.
+      # When shipping_cost contains the shipping_rate from the invoice, the shipping_cost is included in the credit note. One of `amount`, `lines`, or `shipping_cost` must be provided.
       sig { returns(T.nilable(::Stripe::CreditNoteService::CreateParams::ShippingCost)) }
       attr_accessor :shipping_cost
       sig {
@@ -295,7 +295,7 @@ module Stripe
         sig { params(shipping_rate: T.nilable(String)).void }
         def initialize(shipping_rate: nil); end
       end
-      # The integer amount in cents (or local equivalent) representing the total amount of the credit note.
+      # The integer amount in cents (or local equivalent) representing the total amount of the credit note. One of `amount`, `lines`, or `shipping_cost` must be provided.
       sig { returns(T.nilable(Integer)) }
       attr_accessor :amount
       # The integer amount in cents (or local equivalent) representing the amount to credit the customer's balance, which will be automatically applied to their next invoice.
@@ -313,7 +313,7 @@ module Stripe
       # ID of the invoice.
       sig { returns(String) }
       attr_accessor :invoice
-      # Line items that make up the credit note.
+      # Line items that make up the credit note. One of `amount`, `lines`, or `shipping_cost` must be provided.
       sig { returns(T.nilable(T::Array[::Stripe::CreditNoteService::PreviewParams::Line])) }
       attr_accessor :lines
       # The credit note's memo appears on the credit note PDF.
@@ -334,7 +334,7 @@ module Stripe
       # Refunds to link to this credit note.
       sig { returns(T.nilable(T::Array[::Stripe::CreditNoteService::PreviewParams::Refund])) }
       attr_accessor :refunds
-      # When shipping_cost contains the shipping_rate from the invoice, the shipping_cost is included in the credit note.
+      # When shipping_cost contains the shipping_rate from the invoice, the shipping_cost is included in the credit note. One of `amount`, `lines`, or `shipping_cost` must be provided.
       sig { returns(T.nilable(::Stripe::CreditNoteService::PreviewParams::ShippingCost)) }
       attr_accessor :shipping_cost
       sig {

data/rbi/stripe/services/customer_session_service.rbi

@@ -23,7 +23,7 @@ module Stripe
             # Controls whether or not the Payment Element shows saved payment methods. This parameter defaults to `disabled`.
             sig { returns(T.nilable(String)) }
             attr_accessor :payment_method_redisplay
-            # Determines the max number of saved payment methods for the Payment Element to display. This parameter defaults to `3`.
+            # Determines the max number of saved payment methods for the Payment Element to display. This parameter defaults to `3`. The maximum redisplay limit is `10`.
             sig { returns(T.nilable(Integer)) }
             attr_accessor :payment_method_redisplay_limit
             # Controls whether the Payment Element displays the option to remove a saved payment method. This parameter defaults to `disabled`.

data/rbi/stripe/services/identity/verification_session_service.rbi

@@ -109,6 +109,16 @@ module Stripe
           sig { params(email: T.nilable(String), phone: T.nilable(String)).void }
           def initialize(email: nil, phone: nil); end
         end
+        class RelatedPerson < Stripe::RequestParams
+          # A token representing a connected account. If provided, the person parameter is also required and must be associated with the account.
+          sig { returns(String) }
+          attr_accessor :account
+          # A token referencing a Person resource that this verification is being used to verify.
+          sig { returns(String) }
+          attr_accessor :person
+          sig { params(account: String, person: String).void }
+          def initialize(account: nil, person: nil); end
+        end
         # A string to reference this user. This can be a customer ID, a session ID, or similar, and can be used to reconcile this verification with your internal systems.
         sig { returns(T.nilable(String)) }
         attr_accessor :client_reference_id
@@ -131,6 +141,11 @@ module Stripe
         # Customer ID
         sig { returns(T.nilable(String)) }
         attr_accessor :related_customer
+        # Tokens referencing a Person resource and it's associated account.
+        sig {
+          returns(T.nilable(::Stripe::Identity::VerificationSessionService::CreateParams::RelatedPerson))
+         }
+        attr_accessor :related_person
         # The URL that the user will be redirected to upon completing the verification flow.
         sig { returns(T.nilable(String)) }
         attr_accessor :return_url
@@ -141,7 +156,7 @@ module Stripe
         sig { returns(T.nilable(String)) }
         attr_accessor :verification_flow
         sig {
-          params(client_reference_id: T.nilable(String), expand: T.nilable(T::Array[String]), metadata: T.nilable(T::Hash[String, String]), options: T.nilable(::Stripe::Identity::VerificationSessionService::CreateParams::Options), provided_details: T.nilable(::Stripe::Identity::VerificationSessionService::CreateParams::ProvidedDetails), related_customer: T.nilable(String), return_url: T.nilable(String), type: T.nilable(String), verification_flow: T.nilable(String)).void
+          params(client_reference_id: T.nilable(String), expand: T.nilable(T::Array[String]), metadata: T.nilable(T::Hash[String, String]), options: T.nilable(::Stripe::Identity::VerificationSessionService::CreateParams::Options), provided_details: T.nilable(::Stripe::Identity::VerificationSessionService::CreateParams::ProvidedDetails), related_customer: T.nilable(String), related_person: T.nilable(::Stripe::Identity::VerificationSessionService::CreateParams::RelatedPerson), return_url: T.nilable(String), type: T.nilable(String), verification_flow: T.nilable(String)).void
          }
         def initialize(
           client_reference_id: nil,
@@ -150,6 +165,7 @@ module Stripe
           options: nil,
           provided_details: nil,
           related_customer: nil,
+          related_person: nil,
           return_url: nil,
           type: nil,
           verification_flow: nil

data/rbi/stripe/services/invoice_service.rbi

@@ -111,7 +111,7 @@ module Stripe
                 # One of `month`.
                 sig { returns(T.nilable(String)) }
                 attr_accessor :interval
-                # Type of installment plan, one of `fixed_count`.
+                # Type of installment plan, one of `fixed_count`, `bonus`, or `revolving`.
                 sig { returns(String) }
                 attr_accessor :type
                 sig {
@@ -805,7 +805,7 @@ module Stripe
                 # One of `month`.
                 sig { returns(T.nilable(String)) }
                 attr_accessor :interval
-                # Type of installment plan, one of `fixed_count`.
+                # Type of installment plan, one of `fixed_count`, `bonus`, or `revolving`.
                 sig { returns(String) }
                 attr_accessor :type
                 sig {
@@ -2216,6 +2216,13 @@ module Stripe
         def initialize(account: nil, type: nil); end
       end
       class ScheduleDetails < Stripe::RequestParams
+        class BillingMode < Stripe::RequestParams
+          # Attribute for param field type
+          sig { returns(String) }
+          attr_accessor :type
+          sig { params(type: String).void }
+          def initialize(type: nil); end
+        end
         class Phase < Stripe::RequestParams
           class AddInvoiceItem < Stripe::RequestParams
             class Discount < Stripe::RequestParams
@@ -2596,6 +2603,11 @@ module Stripe
             trial_end: nil
           ); end
         end
+        # Controls how prorations and invoices for subscriptions are calculated and orchestrated.
+        sig {
+          returns(T.nilable(::Stripe::InvoiceService::CreatePreviewParams::ScheduleDetails::BillingMode))
+         }
+        attr_accessor :billing_mode
         # Behavior of the subscription schedule and underlying subscription when it ends. Possible values are `release` or `cancel` with the default being `release`. `release` will end the subscription schedule and keep the underlying subscription running. `cancel` will end the subscription schedule and cancel the underlying subscription.
         sig { returns(T.nilable(String)) }
         attr_accessor :end_behavior
@@ -2608,11 +2620,23 @@ module Stripe
         sig { returns(T.nilable(String)) }
         attr_accessor :proration_behavior
         sig {
-          params(end_behavior: T.nilable(String), phases: T.nilable(T::Array[::Stripe::InvoiceService::CreatePreviewParams::ScheduleDetails::Phase]), proration_behavior: T.nilable(String)).void
+          params(billing_mode: T.nilable(::Stripe::InvoiceService::CreatePreviewParams::ScheduleDetails::BillingMode), end_behavior: T.nilable(String), phases: T.nilable(T::Array[::Stripe::InvoiceService::CreatePreviewParams::ScheduleDetails::Phase]), proration_behavior: T.nilable(String)).void
          }
-        def initialize(end_behavior: nil, phases: nil, proration_behavior: nil); end
+        def initialize(
+          billing_mode: nil,
+          end_behavior: nil,
+          phases: nil,
+          proration_behavior: nil
+        ); end
       end
       class SubscriptionDetails < Stripe::RequestParams
+        class BillingMode < Stripe::RequestParams
+          # Attribute for param field type
+          sig { returns(String) }
+          attr_accessor :type
+          sig { params(type: String).void }
+          def initialize(type: nil); end
+        end
         class Item < Stripe::RequestParams
           class BillingThresholds < Stripe::RequestParams
             # Number of units that meets the billing threshold to advance the subscription to a new billing period (e.g., it takes 10 $5 units to meet a $50 [monetary threshold](https://stripe.com/docs/api/subscriptions/update#update_subscription-billing_thresholds-amount_gte))
@@ -2738,10 +2762,15 @@ module Stripe
         # For new subscriptions, a future timestamp to anchor the subscription's [billing cycle](https://stripe.com/docs/subscriptions/billing-cycle). This is used to determine the date of the first full invoice, and, for plans with `month` or `year` intervals, the day of the month for subsequent invoices. For existing subscriptions, the value can only be set to `now` or `unchanged`.
         sig { returns(T.nilable(T.any(String, Integer))) }
         attr_accessor :billing_cycle_anchor
+        # Controls how prorations and invoices for subscriptions are calculated and orchestrated.
+        sig {
+          returns(T.nilable(::Stripe::InvoiceService::CreatePreviewParams::SubscriptionDetails::BillingMode))
+         }
+        attr_accessor :billing_mode
         # A timestamp at which the subscription should cancel. If set to a date before the current period ends, this will cause a proration if prorations have been enabled using `proration_behavior`. If set during a future period, this will always cause a proration for that period.
         sig { returns(T.nilable(T.nilable(T.any(String, Integer)))) }
         attr_accessor :cancel_at
-        # Indicate whether this subscription should cancel at the end of the current period (`current_period_end`). Defaults to `false`. This param will be removed in a future API version. Please use `cancel_at` instead.
+        # Indicate whether this subscription should cancel at the end of the current period (`current_period_end`). Defaults to `false`.
         sig { returns(T.nilable(T::Boolean)) }
         attr_accessor :cancel_at_period_end
         # This simulates the subscription being canceled or expired immediately.
@@ -2771,10 +2800,11 @@ module Stripe
         sig { returns(T.nilable(T.any(String, Integer))) }
         attr_accessor :trial_end
         sig {
-          params(billing_cycle_anchor: T.nilable(T.any(String, Integer)), cancel_at: T.nilable(T.nilable(T.any(String, Integer))), cancel_at_period_end: T.nilable(T::Boolean), cancel_now: T.nilable(T::Boolean), default_tax_rates: T.nilable(T.nilable(T.any(String, T::Array[String]))), items: T.nilable(T::Array[::Stripe::InvoiceService::CreatePreviewParams::SubscriptionDetails::Item]), proration_behavior: T.nilable(String), proration_date: T.nilable(Integer), resume_at: T.nilable(String), start_date: T.nilable(Integer), trial_end: T.nilable(T.any(String, Integer))).void
+          params(billing_cycle_anchor: T.nilable(T.any(String, Integer)), billing_mode: T.nilable(::Stripe::InvoiceService::CreatePreviewParams::SubscriptionDetails::BillingMode), cancel_at: T.nilable(T.nilable(T.any(String, Integer))), cancel_at_period_end: T.nilable(T::Boolean), cancel_now: T.nilable(T::Boolean), default_tax_rates: T.nilable(T.nilable(T.any(String, T::Array[String]))), items: T.nilable(T::Array[::Stripe::InvoiceService::CreatePreviewParams::SubscriptionDetails::Item]), proration_behavior: T.nilable(String), proration_date: T.nilable(Integer), resume_at: T.nilable(String), start_date: T.nilable(Integer), trial_end: T.nilable(T.any(String, Integer))).void
          }
         def initialize(
           billing_cycle_anchor: nil,
+          billing_mode: nil,
           cancel_at: nil,
           cancel_at_period_end: nil,
           cancel_now: nil,