stripe 13.5.0.pre.beta.1 → 13.6.0.pre.beta.1

data/rbi/stripe/resources/payment_intent.rbi

@@ -1166,6 +1166,9 @@ 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(String) }
         attr_reader :setup_future_usage
+        # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+        sig { returns(String) }
+        attr_reader :target_date
         # Bank account verification method.
         sig { returns(String) }
         attr_reader :verification_method
@@ -1245,6 +1248,9 @@ 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(String) }
         attr_reader :setup_future_usage
+        # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+        sig { returns(String) }
+        attr_reader :target_date
       end
       class BacsDebit < Stripe::StripeObject
         class MandateOptions < Stripe::StripeObject
@@ -1264,6 +1270,9 @@ 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(String) }
         attr_reader :setup_future_usage
+        # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+        sig { returns(String) }
+        attr_reader :target_date
       end
       class Bancontact < Stripe::StripeObject
         # Preferred language of the Bancontact authorization page that the customer is redirected to.
@@ -1945,6 +1954,9 @@ 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(String) }
         attr_reader :setup_future_usage
+        # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+        sig { returns(String) }
+        attr_reader :target_date
       end
       class Shopeepay < Stripe::StripeObject
         # Indicates that you intend to make future payments with this PaymentIntent's payment method.
@@ -2050,6 +2062,9 @@ 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(String) }
         attr_reader :setup_future_usage
+        # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+        sig { returns(String) }
+        attr_reader :target_date
         # Bank account verification method.
         sig { returns(String) }
         attr_reader :verification_method
@@ -2301,12 +2316,12 @@ module Stripe
       attr_reader :tracking_number
     end
     class TransferData < Stripe::StripeObject
-      # Amount intended to be collected by this PaymentIntent. A positive integer representing how much to charge in the [smallest currency unit](https://stripe.com/docs/currencies#zero-decimal) (e.g., 100 cents to charge $1.00 or 100 to charge ¥100, a zero-decimal currency). The minimum amount is $0.50 US or [equivalent in charge currency](https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts). The amount value supports up to eight digits (e.g., a value of 99999999 for a USD charge of $999,999.99).
+      # The amount transferred to the destination account. This transfer will occur automatically after the payment succeeds. If no amount is specified, by default the entire payment amount is transferred to the destination account.
+      #  The amount must be less than or equal to the [amount](https://stripe.com/docs/api/payment_intents/object#payment_intent_object-amount), and must be a positive integer
+      #  representing how much to transfer in the smallest currency unit (e.g., 100 cents to charge $1.00).
       sig { returns(Integer) }
       attr_reader :amount
-      # The account (if any) that the payment is attributed to for tax
-      # reporting, and where funds from the payment are transferred to after
-      # payment success.
+      # The account (if any) that the payment is attributed to for tax reporting, and where funds from the payment are transferred to after payment success.
       sig { returns(T.any(String, Stripe::Account)) }
       attr_reader :destination
     end
@@ -3887,15 +3902,19 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           sig { returns(T.nilable(String)) }
           attr_accessor :setup_future_usage
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
           # Bank account verification method.
           sig { returns(String) }
           attr_accessor :verification_method
           sig {
-            params(mandate_options: ::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions::AcssDebit::MandateOptions, setup_future_usage: T.nilable(String), verification_method: String).void
+            params(mandate_options: ::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions::AcssDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String, verification_method: String).void
            }
           def initialize(
             mandate_options: nil,
             setup_future_usage: nil,
+            target_date: nil,
             verification_method: nil
           ); end
         end
@@ -4014,8 +4033,11 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           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
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
+          sig { params(setup_future_usage: T.nilable(String), target_date: String).void }
+          def initialize(setup_future_usage: nil, target_date: nil); end
         end
         class BacsDebit < Stripe::RequestParams
           class MandateOptions < Stripe::RequestParams
@@ -4041,10 +4063,13 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           sig { returns(T.nilable(String)) }
           attr_accessor :setup_future_usage
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
           sig {
-            params(mandate_options: ::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions::BacsDebit::MandateOptions, setup_future_usage: T.nilable(String)).void
+            params(mandate_options: ::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions::BacsDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String).void
            }
-          def initialize(mandate_options: nil, setup_future_usage: nil); end
+          def initialize(mandate_options: nil, setup_future_usage: nil, target_date: nil); end
         end
         class Bancontact < Stripe::RequestParams
           # Preferred language of the Bancontact authorization page that the customer is redirected to.
@@ -5152,10 +5177,13 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           sig { returns(T.nilable(String)) }
           attr_accessor :setup_future_usage
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
           sig {
-            params(mandate_options: ::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions::SepaDebit::MandateOptions, setup_future_usage: T.nilable(String)).void
+            params(mandate_options: ::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions::SepaDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String).void
            }
-          def initialize(mandate_options: nil, setup_future_usage: nil); end
+          def initialize(mandate_options: nil, setup_future_usage: nil, target_date: nil); end
         end
         class Shopeepay < Stripe::RequestParams
           # Indicates that you intend to make future payments with this PaymentIntent's payment method.
@@ -5317,11 +5345,14 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           sig { returns(T.nilable(String)) }
           attr_accessor :setup_future_usage
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
           # Bank account verification method.
           sig { returns(String) }
           attr_accessor :verification_method
           sig {
-            params(financial_connections: ::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions::UsBankAccount::FinancialConnections, mandate_options: ::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions::UsBankAccount::MandateOptions, networks: ::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions::UsBankAccount::Networks, preferred_settlement_speed: T.nilable(String), setup_future_usage: T.nilable(String), verification_method: String).void
+            params(financial_connections: ::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions::UsBankAccount::FinancialConnections, mandate_options: ::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions::UsBankAccount::MandateOptions, networks: ::Stripe::PaymentIntent::CreateParams::PaymentMethodOptions::UsBankAccount::Networks, preferred_settlement_speed: T.nilable(String), setup_future_usage: T.nilable(String), target_date: String, verification_method: String).void
            }
           def initialize(
             financial_connections: nil,
@@ -5329,6 +5360,7 @@ module Stripe
             networks: nil,
             preferred_settlement_speed: nil,
             setup_future_usage: nil,
+            target_date: nil,
             verification_method: nil
           ); end
         end
@@ -7295,15 +7327,19 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           sig { returns(T.nilable(String)) }
           attr_accessor :setup_future_usage
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
           # Bank account verification method.
           sig { returns(String) }
           attr_accessor :verification_method
           sig {
-            params(mandate_options: ::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions::AcssDebit::MandateOptions, setup_future_usage: T.nilable(String), verification_method: String).void
+            params(mandate_options: ::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions::AcssDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String, verification_method: String).void
            }
           def initialize(
             mandate_options: nil,
             setup_future_usage: nil,
+            target_date: nil,
             verification_method: nil
           ); end
         end
@@ -7422,8 +7458,11 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           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
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
+          sig { params(setup_future_usage: T.nilable(String), target_date: String).void }
+          def initialize(setup_future_usage: nil, target_date: nil); end
         end
         class BacsDebit < Stripe::RequestParams
           class MandateOptions < Stripe::RequestParams
@@ -7449,10 +7488,13 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           sig { returns(T.nilable(String)) }
           attr_accessor :setup_future_usage
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
           sig {
-            params(mandate_options: ::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions::BacsDebit::MandateOptions, setup_future_usage: T.nilable(String)).void
+            params(mandate_options: ::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions::BacsDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String).void
            }
-          def initialize(mandate_options: nil, setup_future_usage: nil); end
+          def initialize(mandate_options: nil, setup_future_usage: nil, target_date: nil); end
         end
         class Bancontact < Stripe::RequestParams
           # Preferred language of the Bancontact authorization page that the customer is redirected to.
@@ -8560,10 +8602,13 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           sig { returns(T.nilable(String)) }
           attr_accessor :setup_future_usage
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
           sig {
-            params(mandate_options: ::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions::SepaDebit::MandateOptions, setup_future_usage: T.nilable(String)).void
+            params(mandate_options: ::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions::SepaDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String).void
            }
-          def initialize(mandate_options: nil, setup_future_usage: nil); end
+          def initialize(mandate_options: nil, setup_future_usage: nil, target_date: nil); end
         end
         class Shopeepay < Stripe::RequestParams
           # Indicates that you intend to make future payments with this PaymentIntent's payment method.
@@ -8725,11 +8770,14 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           sig { returns(T.nilable(String)) }
           attr_accessor :setup_future_usage
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
           # Bank account verification method.
           sig { returns(String) }
           attr_accessor :verification_method
           sig {
-            params(financial_connections: ::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions::UsBankAccount::FinancialConnections, mandate_options: ::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions::UsBankAccount::MandateOptions, networks: ::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions::UsBankAccount::Networks, preferred_settlement_speed: T.nilable(String), setup_future_usage: T.nilable(String), verification_method: String).void
+            params(financial_connections: ::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions::UsBankAccount::FinancialConnections, mandate_options: ::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions::UsBankAccount::MandateOptions, networks: ::Stripe::PaymentIntent::UpdateParams::PaymentMethodOptions::UsBankAccount::Networks, preferred_settlement_speed: T.nilable(String), setup_future_usage: T.nilable(String), target_date: String, verification_method: String).void
            }
           def initialize(
             financial_connections: nil,
@@ -8737,6 +8785,7 @@ module Stripe
             networks: nil,
             preferred_settlement_speed: nil,
             setup_future_usage: nil,
+            target_date: nil,
             verification_method: nil
           ); end
         end
@@ -11442,15 +11491,19 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           sig { returns(T.nilable(String)) }
           attr_accessor :setup_future_usage
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
           # Bank account verification method.
           sig { returns(String) }
           attr_accessor :verification_method
           sig {
-            params(mandate_options: ::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions::AcssDebit::MandateOptions, setup_future_usage: T.nilable(String), verification_method: String).void
+            params(mandate_options: ::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions::AcssDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String, verification_method: String).void
            }
           def initialize(
             mandate_options: nil,
             setup_future_usage: nil,
+            target_date: nil,
             verification_method: nil
           ); end
         end
@@ -11569,8 +11622,11 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           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
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
+          sig { params(setup_future_usage: T.nilable(String), target_date: String).void }
+          def initialize(setup_future_usage: nil, target_date: nil); end
         end
         class BacsDebit < Stripe::RequestParams
           class MandateOptions < Stripe::RequestParams
@@ -11596,10 +11652,13 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           sig { returns(T.nilable(String)) }
           attr_accessor :setup_future_usage
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
           sig {
-            params(mandate_options: ::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions::BacsDebit::MandateOptions, setup_future_usage: T.nilable(String)).void
+            params(mandate_options: ::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions::BacsDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String).void
            }
-          def initialize(mandate_options: nil, setup_future_usage: nil); end
+          def initialize(mandate_options: nil, setup_future_usage: nil, target_date: nil); end
         end
         class Bancontact < Stripe::RequestParams
           # Preferred language of the Bancontact authorization page that the customer is redirected to.
@@ -12707,10 +12766,13 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           sig { returns(T.nilable(String)) }
           attr_accessor :setup_future_usage
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
           sig {
-            params(mandate_options: ::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions::SepaDebit::MandateOptions, setup_future_usage: T.nilable(String)).void
+            params(mandate_options: ::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions::SepaDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String).void
            }
-          def initialize(mandate_options: nil, setup_future_usage: nil); end
+          def initialize(mandate_options: nil, setup_future_usage: nil, target_date: nil); end
         end
         class Shopeepay < Stripe::RequestParams
           # Indicates that you intend to make future payments with this PaymentIntent's payment method.
@@ -12872,11 +12934,14 @@ module Stripe
           # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
           sig { returns(T.nilable(String)) }
           attr_accessor :setup_future_usage
+          # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+          sig { returns(String) }
+          attr_accessor :target_date
           # Bank account verification method.
           sig { returns(String) }
           attr_accessor :verification_method
           sig {
-            params(financial_connections: ::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions::UsBankAccount::FinancialConnections, mandate_options: ::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions::UsBankAccount::MandateOptions, networks: ::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions::UsBankAccount::Networks, preferred_settlement_speed: T.nilable(String), setup_future_usage: T.nilable(String), verification_method: String).void
+            params(financial_connections: ::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions::UsBankAccount::FinancialConnections, mandate_options: ::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions::UsBankAccount::MandateOptions, networks: ::Stripe::PaymentIntent::ConfirmParams::PaymentMethodOptions::UsBankAccount::Networks, preferred_settlement_speed: T.nilable(String), setup_future_usage: T.nilable(String), target_date: String, verification_method: String).void
            }
           def initialize(
             financial_connections: nil,
@@ -12884,6 +12949,7 @@ module Stripe
             networks: nil,
             preferred_settlement_speed: nil,
             setup_future_usage: nil,
+            target_date: nil,
             verification_method: nil
           ); end
         end

data/rbi/stripe/resources/product.rbi

@@ -397,6 +397,9 @@ module Stripe
         # When set, provides configuration for the amount to be adjusted by the customer during Checkout Sessions and Payment Links.
         sig { returns(::Stripe::Product::CreateParams::DefaultPriceData::CustomUnitAmount) }
         attr_accessor :custom_unit_amount
+        # Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
+        sig { returns(T::Hash[String, String]) }
+        attr_accessor :metadata
         # The recurring components of a price such as `interval` and `interval_count`.
         sig { returns(::Stripe::Product::CreateParams::DefaultPriceData::Recurring) }
         attr_accessor :recurring
@@ -410,12 +413,13 @@ module Stripe
         sig { returns(String) }
         attr_accessor :unit_amount_decimal
         sig {
-          params(currency: String, currency_options: T::Hash[String, ::Stripe::Product::CreateParams::DefaultPriceData::CurrencyOptions], custom_unit_amount: ::Stripe::Product::CreateParams::DefaultPriceData::CustomUnitAmount, recurring: ::Stripe::Product::CreateParams::DefaultPriceData::Recurring, tax_behavior: String, unit_amount: Integer, unit_amount_decimal: String).void
+          params(currency: String, currency_options: T::Hash[String, ::Stripe::Product::CreateParams::DefaultPriceData::CurrencyOptions], custom_unit_amount: ::Stripe::Product::CreateParams::DefaultPriceData::CustomUnitAmount, metadata: T::Hash[String, String], recurring: ::Stripe::Product::CreateParams::DefaultPriceData::Recurring, tax_behavior: String, unit_amount: Integer, unit_amount_decimal: String).void
          }
         def initialize(
           currency: nil,
           currency_options: nil,
           custom_unit_amount: nil,
+          metadata: nil,
           recurring: nil,
           tax_behavior: nil,
           unit_amount: nil,

data/rbi/stripe/resources/tax/calculation.rbi

@@ -162,7 +162,7 @@ module Stripe
           # The tax rate percentage as a string. For example, 8.5% is represented as `"8.5"`.
           sig { returns(String) }
           attr_reader :percentage_decimal
-          # Indicates the type of tax rate applied to the taxable amount. This value can be `null` when no tax applies to the location.
+          # Indicates the type of tax rate applied to the taxable amount. This value can be `null` when no tax applies to the location. This field is only present for TaxRates created by Stripe Tax.
           sig { returns(T.nilable(String)) }
           attr_reader :rate_type
           # State, county, province, or region.

data/rbi/stripe/resources/tax_rate.rbi

@@ -62,7 +62,7 @@ module Stripe
     # Tax rate percentage out of 100. For tax calculations with automatic_tax[enabled]=true, this percentage includes the statutory tax rate of non-taxable jurisdictions.
     sig { returns(Float) }
     attr_reader :percentage
-    # Indicates the type of tax rate applied to the taxable amount. This value can be `null` when no tax applies to the location.
+    # Indicates the type of tax rate applied to the taxable amount. This value can be `null` when no tax applies to the location. This field is only present for TaxRates created by Stripe Tax.
     sig { returns(T.nilable(String)) }
     attr_reader :rate_type
     # [ISO 3166-2 subdivision code](https://en.wikipedia.org/wiki/ISO_3166-2), without country prefix. For example, "NY" for New York, United States.

data/rbi/stripe/resources/terminal/reader.rbi

@@ -810,6 +810,23 @@ module Stripe
           type: nil
         ); end
       end
+      class SucceedInputCollectionParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # Skip behavior for input collection.
+        sig { returns(String) }
+        attr_accessor :skip_non_required_inputs
+        sig { params(expand: T::Array[String], skip_non_required_inputs: String).void }
+        def initialize(expand: nil, skip_non_required_inputs: nil); end
+      end
+      class TimeoutInputCollectionParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        sig { params(expand: T::Array[String]).void }
+        def initialize(expand: nil); end
+      end
       # Cancels the current reader action.
       sig {
         params(params: T.any(::Stripe::Terminal::Reader::CancelActionParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Terminal::Reader)

data/rbi/stripe/services/billing/credit_grant_service.rbi

@@ -90,7 +90,7 @@ module Stripe
         # Amount of this credit grant.
         sig { returns(::Stripe::Billing::CreditGrantService::CreateParams::Amount) }
         attr_accessor :amount
-        # Configuration specifying what this credit grant applies to.
+        # Configuration specifying what this credit grant applies to. We currently only support `metered` prices that have a [Billing Meter](https://docs.stripe.com/api/billing/meter) attached to them.
         sig { returns(::Stripe::Billing::CreditGrantService::CreateParams::ApplicabilityConfig) }
         attr_accessor :applicability_config
         # The category of this credit grant.
@@ -114,8 +114,11 @@ module Stripe
         # A descriptive name shown in the Dashboard.
         sig { returns(String) }
         attr_accessor :name
+        # The desired priority for applying this credit grant. If not specified, it will be set to the default value of 50. The highest priority is 0 and the lowest is 100.
+        sig { returns(Integer) }
+        attr_accessor :priority
         sig {
-          params(amount: ::Stripe::Billing::CreditGrantService::CreateParams::Amount, applicability_config: ::Stripe::Billing::CreditGrantService::CreateParams::ApplicabilityConfig, category: String, customer: String, effective_at: Integer, expand: T::Array[String], expires_at: Integer, metadata: T::Hash[String, String], name: String).void
+          params(amount: ::Stripe::Billing::CreditGrantService::CreateParams::Amount, applicability_config: ::Stripe::Billing::CreditGrantService::CreateParams::ApplicabilityConfig, category: String, customer: String, effective_at: Integer, expand: T::Array[String], expires_at: Integer, metadata: T::Hash[String, String], name: String, priority: Integer).void
          }
         def initialize(
           amount: nil,
@@ -126,7 +129,8 @@ module Stripe
           expand: nil,
           expires_at: nil,
           metadata: nil,
-          name: nil
+          name: nil,
+          priority: nil
         ); end
       end
       class RetrieveParams < Stripe::RequestParams

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

@@ -769,16 +769,20 @@ 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(String) }
             attr_accessor :setup_future_usage
+            # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+            sig { returns(String) }
+            attr_accessor :target_date
             # Verification method for the intent
             sig { returns(String) }
             attr_accessor :verification_method
             sig {
-              params(currency: String, mandate_options: ::Stripe::Checkout::SessionService::CreateParams::PaymentMethodOptions::AcssDebit::MandateOptions, setup_future_usage: String, verification_method: String).void
+              params(currency: String, mandate_options: ::Stripe::Checkout::SessionService::CreateParams::PaymentMethodOptions::AcssDebit::MandateOptions, setup_future_usage: String, target_date: String, verification_method: String).void
              }
             def initialize(
               currency: nil,
               mandate_options: nil,
               setup_future_usage: nil,
+              target_date: nil,
               verification_method: nil
             ); end
           end
@@ -844,8 +848,11 @@ 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(String) }
             attr_accessor :setup_future_usage
-            sig { params(setup_future_usage: String).void }
-            def initialize(setup_future_usage: nil); end
+            # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+            sig { returns(String) }
+            attr_accessor :target_date
+            sig { params(setup_future_usage: String, target_date: String).void }
+            def initialize(setup_future_usage: nil, target_date: nil); end
           end
           class BacsDebit < Stripe::RequestParams
             class MandateOptions < Stripe::RequestParams
@@ -869,10 +876,13 @@ 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(String) }
             attr_accessor :setup_future_usage
+            # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+            sig { returns(String) }
+            attr_accessor :target_date
             sig {
-              params(mandate_options: ::Stripe::Checkout::SessionService::CreateParams::PaymentMethodOptions::BacsDebit::MandateOptions, setup_future_usage: String).void
+              params(mandate_options: ::Stripe::Checkout::SessionService::CreateParams::PaymentMethodOptions::BacsDebit::MandateOptions, setup_future_usage: String, target_date: String).void
              }
-            def initialize(mandate_options: nil, setup_future_usage: nil); end
+            def initialize(mandate_options: nil, setup_future_usage: nil, target_date: nil); end
           end
           class Bancontact < Stripe::RequestParams
             # Indicates that you intend to make future payments with this PaymentIntent's payment method.
@@ -1424,10 +1434,13 @@ 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(String) }
             attr_accessor :setup_future_usage
+            # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+            sig { returns(String) }
+            attr_accessor :target_date
             sig {
-              params(mandate_options: ::Stripe::Checkout::SessionService::CreateParams::PaymentMethodOptions::SepaDebit::MandateOptions, setup_future_usage: String).void
+              params(mandate_options: ::Stripe::Checkout::SessionService::CreateParams::PaymentMethodOptions::SepaDebit::MandateOptions, setup_future_usage: String, target_date: String).void
              }
-            def initialize(mandate_options: nil, setup_future_usage: nil); end
+            def initialize(mandate_options: nil, setup_future_usage: nil, target_date: nil); end
           end
           class Sofort < Stripe::RequestParams
             # Indicates that you intend to make future payments with this PaymentIntent's payment method.
@@ -1474,15 +1487,19 @@ 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(String) }
             attr_accessor :setup_future_usage
+            # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+            sig { returns(String) }
+            attr_accessor :target_date
             # Verification method for the intent
             sig { returns(String) }
             attr_accessor :verification_method
             sig {
-              params(financial_connections: ::Stripe::Checkout::SessionService::CreateParams::PaymentMethodOptions::UsBankAccount::FinancialConnections, setup_future_usage: String, verification_method: String).void
+              params(financial_connections: ::Stripe::Checkout::SessionService::CreateParams::PaymentMethodOptions::UsBankAccount::FinancialConnections, setup_future_usage: String, target_date: String, verification_method: String).void
              }
             def initialize(
               financial_connections: nil,
               setup_future_usage: nil,
+              target_date: nil,
               verification_method: nil
             ); end
           end

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

@@ -124,7 +124,7 @@ module Stripe
           returns(::Stripe::Identity::VerificationSessionService::CreateParams::ProvidedDetails)
          }
         attr_accessor :provided_details
-        # Token referencing a Customer resource.
+        # Customer ID
         sig { returns(String) }
         attr_accessor :related_customer
         # The URL that the user will be redirected to upon completing the verification flow.

data/rbi/stripe/services/order_service.rbi

@@ -312,15 +312,19 @@ module Stripe
               # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
               sig { returns(T.nilable(String)) }
               attr_accessor :setup_future_usage
+              # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+              sig { returns(String) }
+              attr_accessor :target_date
               # Bank account verification method.
               sig { returns(String) }
               attr_accessor :verification_method
               sig {
-                params(mandate_options: ::Stripe::OrderService::CreateParams::Payment::Settings::PaymentMethodOptions::AcssDebit::MandateOptions, setup_future_usage: T.nilable(String), verification_method: String).void
+                params(mandate_options: ::Stripe::OrderService::CreateParams::Payment::Settings::PaymentMethodOptions::AcssDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String, verification_method: String).void
                }
               def initialize(
                 mandate_options: nil,
                 setup_future_usage: nil,
+                target_date: nil,
                 verification_method: nil
               ); end
             end
@@ -686,10 +690,13 @@ module Stripe
               # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
               sig { returns(T.nilable(String)) }
               attr_accessor :setup_future_usage
+              # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+              sig { returns(String) }
+              attr_accessor :target_date
               sig {
-                params(mandate_options: ::Stripe::OrderService::CreateParams::Payment::Settings::PaymentMethodOptions::SepaDebit::MandateOptions, setup_future_usage: T.nilable(String)).void
+                params(mandate_options: ::Stripe::OrderService::CreateParams::Payment::Settings::PaymentMethodOptions::SepaDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String).void
                }
-              def initialize(mandate_options: nil, setup_future_usage: nil); end
+              def initialize(mandate_options: nil, setup_future_usage: nil, target_date: nil); end
             end
             class Sofort < Stripe::RequestParams
               # Language shown to the payer on redirect.
@@ -1419,15 +1426,19 @@ module Stripe
               # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
               sig { returns(T.nilable(String)) }
               attr_accessor :setup_future_usage
+              # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+              sig { returns(String) }
+              attr_accessor :target_date
               # Bank account verification method.
               sig { returns(String) }
               attr_accessor :verification_method
               sig {
-                params(mandate_options: ::Stripe::OrderService::UpdateParams::Payment::Settings::PaymentMethodOptions::AcssDebit::MandateOptions, setup_future_usage: T.nilable(String), verification_method: String).void
+                params(mandate_options: ::Stripe::OrderService::UpdateParams::Payment::Settings::PaymentMethodOptions::AcssDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String, verification_method: String).void
                }
               def initialize(
                 mandate_options: nil,
                 setup_future_usage: nil,
+                target_date: nil,
                 verification_method: nil
               ); end
             end
@@ -1793,10 +1804,13 @@ module Stripe
               # If you've already set `setup_future_usage` and you're performing a request using a publishable key, you can only update the value from `on_session` to `off_session`.
               sig { returns(T.nilable(String)) }
               attr_accessor :setup_future_usage
+              # Controls when Stripe will attempt to debit the funds from the customer's account. The date must be a string in YYYY-MM-DD format. The date must be in the future and between 3 and 15 calendar days from now.
+              sig { returns(String) }
+              attr_accessor :target_date
               sig {
-                params(mandate_options: ::Stripe::OrderService::UpdateParams::Payment::Settings::PaymentMethodOptions::SepaDebit::MandateOptions, setup_future_usage: T.nilable(String)).void
+                params(mandate_options: ::Stripe::OrderService::UpdateParams::Payment::Settings::PaymentMethodOptions::SepaDebit::MandateOptions, setup_future_usage: T.nilable(String), target_date: String).void
                }
-              def initialize(mandate_options: nil, setup_future_usage: nil); end
+              def initialize(mandate_options: nil, setup_future_usage: nil, target_date: nil); end
             end
             class Sofort < Stripe::RequestParams
               # Language shown to the payer on redirect.