stripe 15.4.0.pre.beta.1 → 15.4.0.pre.beta.2

data/rbi/stripe.rbi

@@ -107499,6 +107499,214 @@ module Stripe
             sig { returns(T.nilable(DefaultOutboundDestination)) }
             attr_reader :default_outbound_destination
           end
+          class Storer < Stripe::StripeObject
+            class Capabilities < Stripe::StripeObject
+              class FinancialAddresses < Stripe::StripeObject
+                class BankAccounts < Stripe::StripeObject
+                  class StatusDetail < Stripe::StripeObject
+                    # Machine-readable code explaining the reason for the Capability to be in its current status.
+                    sig { returns(String) }
+                    attr_reader :code
+                    # Machine-readable code explaining how to make the Capability active.
+                    sig { returns(String) }
+                    attr_reader :resolution
+                  end
+                  # Whether the Capability has been requested.
+                  sig { returns(T::Boolean) }
+                  attr_reader :requested
+                  # The status of the Capability.
+                  sig { returns(String) }
+                  attr_reader :status
+                  # Additional details regarding the status of the Capability. `status_details` will be empty if the Capability's status is `active`.
+                  sig { returns(T::Array[StatusDetail]) }
+                  attr_reader :status_details
+                end
+                # Can provision a bank-account like financial address (VBAN) to credit/debit a FinancialAccount.
+                sig { returns(T.nilable(BankAccounts)) }
+                attr_reader :bank_accounts
+              end
+              class HoldsCurrencies < Stripe::StripeObject
+                class Gbp < Stripe::StripeObject
+                  class StatusDetail < Stripe::StripeObject
+                    # Machine-readable code explaining the reason for the Capability to be in its current status.
+                    sig { returns(String) }
+                    attr_reader :code
+                    # Machine-readable code explaining how to make the Capability active.
+                    sig { returns(String) }
+                    attr_reader :resolution
+                  end
+                  # Whether the Capability has been requested.
+                  sig { returns(T::Boolean) }
+                  attr_reader :requested
+                  # The status of the Capability.
+                  sig { returns(String) }
+                  attr_reader :status
+                  # Additional details regarding the status of the Capability. `status_details` will be empty if the Capability's status is `active`.
+                  sig { returns(T::Array[StatusDetail]) }
+                  attr_reader :status_details
+                end
+                # Can hold storage-type funds on Stripe in GBP.
+                sig { returns(T.nilable(Gbp)) }
+                attr_reader :gbp
+              end
+              class InboundTransfers < Stripe::StripeObject
+                class BankAccounts < Stripe::StripeObject
+                  class StatusDetail < Stripe::StripeObject
+                    # Machine-readable code explaining the reason for the Capability to be in its current status.
+                    sig { returns(String) }
+                    attr_reader :code
+                    # Machine-readable code explaining how to make the Capability active.
+                    sig { returns(String) }
+                    attr_reader :resolution
+                  end
+                  # Whether the Capability has been requested.
+                  sig { returns(T::Boolean) }
+                  attr_reader :requested
+                  # The status of the Capability.
+                  sig { returns(String) }
+                  attr_reader :status
+                  # Additional details regarding the status of the Capability. `status_details` will be empty if the Capability's status is `active`.
+                  sig { returns(T::Array[StatusDetail]) }
+                  attr_reader :status_details
+                end
+                # Can pull funds from an external bank account, owned by yourself, to a FinancialAccount.
+                sig { returns(T.nilable(BankAccounts)) }
+                attr_reader :bank_accounts
+              end
+              class OutboundPayments < Stripe::StripeObject
+                class BankAccounts < Stripe::StripeObject
+                  class StatusDetail < Stripe::StripeObject
+                    # Machine-readable code explaining the reason for the Capability to be in its current status.
+                    sig { returns(String) }
+                    attr_reader :code
+                    # Machine-readable code explaining how to make the Capability active.
+                    sig { returns(String) }
+                    attr_reader :resolution
+                  end
+                  # Whether the Capability has been requested.
+                  sig { returns(T::Boolean) }
+                  attr_reader :requested
+                  # The status of the Capability.
+                  sig { returns(String) }
+                  attr_reader :status
+                  # Additional details regarding the status of the Capability. `status_details` will be empty if the Capability's status is `active`.
+                  sig { returns(T::Array[StatusDetail]) }
+                  attr_reader :status_details
+                end
+                class Cards < Stripe::StripeObject
+                  class StatusDetail < Stripe::StripeObject
+                    # Machine-readable code explaining the reason for the Capability to be in its current status.
+                    sig { returns(String) }
+                    attr_reader :code
+                    # Machine-readable code explaining how to make the Capability active.
+                    sig { returns(String) }
+                    attr_reader :resolution
+                  end
+                  # Whether the Capability has been requested.
+                  sig { returns(T::Boolean) }
+                  attr_reader :requested
+                  # The status of the Capability.
+                  sig { returns(String) }
+                  attr_reader :status
+                  # Additional details regarding the status of the Capability. `status_details` will be empty if the Capability's status is `active`.
+                  sig { returns(T::Array[StatusDetail]) }
+                  attr_reader :status_details
+                end
+                class FinancialAccounts < Stripe::StripeObject
+                  class StatusDetail < Stripe::StripeObject
+                    # Machine-readable code explaining the reason for the Capability to be in its current status.
+                    sig { returns(String) }
+                    attr_reader :code
+                    # Machine-readable code explaining how to make the Capability active.
+                    sig { returns(String) }
+                    attr_reader :resolution
+                  end
+                  # Whether the Capability has been requested.
+                  sig { returns(T::Boolean) }
+                  attr_reader :requested
+                  # The status of the Capability.
+                  sig { returns(String) }
+                  attr_reader :status
+                  # Additional details regarding the status of the Capability. `status_details` will be empty if the Capability's status is `active`.
+                  sig { returns(T::Array[StatusDetail]) }
+                  attr_reader :status_details
+                end
+                # Can send funds from a FinancialAccount to a bank account, owned by someone else.
+                sig { returns(T.nilable(BankAccounts)) }
+                attr_reader :bank_accounts
+                # Can send funds from a FinancialAccount to a debit card, owned by someone else.
+                sig { returns(T.nilable(Cards)) }
+                attr_reader :cards
+                # Can send funds from a FinancialAccount to another FinancialAccount, owned by someone else.
+                sig { returns(T.nilable(FinancialAccounts)) }
+                attr_reader :financial_accounts
+              end
+              class OutboundTransfers < Stripe::StripeObject
+                class BankAccounts < Stripe::StripeObject
+                  class StatusDetail < Stripe::StripeObject
+                    # Machine-readable code explaining the reason for the Capability to be in its current status.
+                    sig { returns(String) }
+                    attr_reader :code
+                    # Machine-readable code explaining how to make the Capability active.
+                    sig { returns(String) }
+                    attr_reader :resolution
+                  end
+                  # Whether the Capability has been requested.
+                  sig { returns(T::Boolean) }
+                  attr_reader :requested
+                  # The status of the Capability.
+                  sig { returns(String) }
+                  attr_reader :status
+                  # Additional details regarding the status of the Capability. `status_details` will be empty if the Capability's status is `active`.
+                  sig { returns(T::Array[StatusDetail]) }
+                  attr_reader :status_details
+                end
+                class FinancialAccounts < Stripe::StripeObject
+                  class StatusDetail < Stripe::StripeObject
+                    # Machine-readable code explaining the reason for the Capability to be in its current status.
+                    sig { returns(String) }
+                    attr_reader :code
+                    # Machine-readable code explaining how to make the Capability active.
+                    sig { returns(String) }
+                    attr_reader :resolution
+                  end
+                  # Whether the Capability has been requested.
+                  sig { returns(T::Boolean) }
+                  attr_reader :requested
+                  # The status of the Capability.
+                  sig { returns(String) }
+                  attr_reader :status
+                  # Additional details regarding the status of the Capability. `status_details` will be empty if the Capability's status is `active`.
+                  sig { returns(T::Array[StatusDetail]) }
+                  attr_reader :status_details
+                end
+                # Can send funds from a FinancialAccount, to a bank account, owned by yourself.
+                sig { returns(T.nilable(BankAccounts)) }
+                attr_reader :bank_accounts
+                # Can send funds from a FinancialAccount to another FinancialAccount, owned by yourself.
+                sig { returns(T.nilable(FinancialAccounts)) }
+                attr_reader :financial_accounts
+              end
+              # Can provision a financial address to credit/debit a FinancialAccount.
+              sig { returns(T.nilable(FinancialAddresses)) }
+              attr_reader :financial_addresses
+              # Can hold storage-type funds on Stripe.
+              sig { returns(T.nilable(HoldsCurrencies)) }
+              attr_reader :holds_currencies
+              # Can pull funds from an external source, owned by yourself, to a FinancialAccount.
+              sig { returns(T.nilable(InboundTransfers)) }
+              attr_reader :inbound_transfers
+              # Can send funds from a FinancialAccount to a destination owned by someone else.
+              sig { returns(T.nilable(OutboundPayments)) }
+              attr_reader :outbound_payments
+              # Can send funds from a FinancialAccount to a destination owned by yourself.
+              sig { returns(T.nilable(OutboundTransfers)) }
+              attr_reader :outbound_transfers
+            end
+            # Capabilities that have been requested on the Storer Configuration.
+            sig { returns(T.nilable(Capabilities)) }
+            attr_reader :capabilities
+          end
           # The Customer Configuration allows the Account to be used in inbound payment flows.
           sig { returns(T.nilable(Customer)) }
           attr_reader :customer
@@ -107508,6 +107716,9 @@ module Stripe
           # The Recipient Configuration allows the Account to receive funds.
           sig { returns(T.nilable(Recipient)) }
           attr_reader :recipient
+          # The Storer Configuration allows the Account to store and move funds using stored-value FinancialAccounts.
+          sig { returns(T.nilable(Storer)) }
+          attr_reader :storer
         end
         class Defaults < Stripe::StripeObject
           class Responsibilities < Stripe::StripeObject
@@ -108974,6 +109185,27 @@ module Stripe
           sig { returns(String) }
           attr_reader :type
         end
+        class StatusDetails < Stripe::StripeObject
+          class Closed < Stripe::StripeObject
+            class ForwardingSettings < Stripe::StripeObject
+              # The address to send forwarded payments to.
+              sig { returns(T.nilable(String)) }
+              attr_reader :payment_method
+              # The address to send forwarded payouts to.
+              sig { returns(T.nilable(String)) }
+              attr_reader :payout_method
+            end
+            # Attribute for field forwarding_settings
+            sig { returns(T.nilable(ForwardingSettings)) }
+            attr_reader :forwarding_settings
+            # Attribute for field reason
+            sig { returns(String) }
+            attr_reader :reason
+          end
+          # Attribute for field closed
+          sig { returns(T.nilable(Closed)) }
+          attr_reader :closed
+        end
         class Storage < Stripe::StripeObject
           # The currencies that this FinancialAccount can hold.
           sig { returns(T::Array[String]) }
@@ -109003,6 +109235,9 @@ module Stripe
         # Closed Enum. An enum representing the status of the FinancialAccount. This indicates whether or not the FinancialAccount can be used for any money movement flows.
         sig { returns(String) }
         attr_reader :status
+        # Attribute for field status_details
+        sig { returns(T.nilable(StatusDetails)) }
+        attr_reader :status_details
         # If this is a `storage` FinancialAccount, this hash includes details specific to `storage` FinancialAccounts.
         sig { returns(T.nilable(Storage)) }
         attr_reader :storage
@@ -187628,6 +187863,180 @@ module Stripe
                }
               def initialize(capabilities: nil); end
             end
+            class Storer < Stripe::RequestParams
+              class Capabilities < Stripe::RequestParams
+                class FinancialAddresses < Stripe::RequestParams
+                  class BankAccounts < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T::Boolean) }
+                    attr_accessor :requested
+                    sig { params(requested: T::Boolean).void }
+                    def initialize(requested: nil); end
+                  end
+                  # Can provision a bank-account-like financial address (VBAN) to credit/debit a FinancialAccount.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::FinancialAddresses::BankAccounts))
+                   }
+                  attr_accessor :bank_accounts
+                  sig {
+                    params(bank_accounts: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::FinancialAddresses::BankAccounts)).void
+                   }
+                  def initialize(bank_accounts: nil); end
+                end
+                class HoldsCurrencies < Stripe::RequestParams
+                  class Gbp < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T::Boolean) }
+                    attr_accessor :requested
+                    sig { params(requested: T::Boolean).void }
+                    def initialize(requested: nil); end
+                  end
+                  # Can hold storage-type funds on Stripe in GBP.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::HoldsCurrencies::Gbp))
+                   }
+                  attr_accessor :gbp
+                  sig {
+                    params(gbp: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::HoldsCurrencies::Gbp)).void
+                   }
+                  def initialize(gbp: nil); end
+                end
+                class InboundTransfers < Stripe::RequestParams
+                  class BankAccounts < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T::Boolean) }
+                    attr_accessor :requested
+                    sig { params(requested: T::Boolean).void }
+                    def initialize(requested: nil); end
+                  end
+                  # Can pull funds from an external bank account owned by yourself to a FinancialAccount.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::InboundTransfers::BankAccounts))
+                   }
+                  attr_accessor :bank_accounts
+                  sig {
+                    params(bank_accounts: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::InboundTransfers::BankAccounts)).void
+                   }
+                  def initialize(bank_accounts: nil); end
+                end
+                class OutboundPayments < Stripe::RequestParams
+                  class BankAccounts < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T::Boolean) }
+                    attr_accessor :requested
+                    sig { params(requested: T::Boolean).void }
+                    def initialize(requested: nil); end
+                  end
+                  class Cards < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T::Boolean) }
+                    attr_accessor :requested
+                    sig { params(requested: T::Boolean).void }
+                    def initialize(requested: nil); end
+                  end
+                  class FinancialAccounts < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T::Boolean) }
+                    attr_accessor :requested
+                    sig { params(requested: T::Boolean).void }
+                    def initialize(requested: nil); end
+                  end
+                  # Can send funds from a FinancialAccount to a bank account owned by someone else.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundPayments::BankAccounts))
+                   }
+                  attr_accessor :bank_accounts
+                  # Can send funds from a FinancialAccount to a debit card owned by someone else.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundPayments::Cards))
+                   }
+                  attr_accessor :cards
+                  # Can send funds from a FinancialAccount to another FinancialAccount owned by someone else.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundPayments::FinancialAccounts))
+                   }
+                  attr_accessor :financial_accounts
+                  sig {
+                    params(bank_accounts: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundPayments::BankAccounts), cards: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundPayments::Cards), financial_accounts: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundPayments::FinancialAccounts)).void
+                   }
+                  def initialize(bank_accounts: nil, cards: nil, financial_accounts: nil); end
+                end
+                class OutboundTransfers < Stripe::RequestParams
+                  class BankAccounts < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T::Boolean) }
+                    attr_accessor :requested
+                    sig { params(requested: T::Boolean).void }
+                    def initialize(requested: nil); end
+                  end
+                  class FinancialAccounts < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T::Boolean) }
+                    attr_accessor :requested
+                    sig { params(requested: T::Boolean).void }
+                    def initialize(requested: nil); end
+                  end
+                  # Can send funds from a FinancialAccount to a bank account owned by yourself.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundTransfers::BankAccounts))
+                   }
+                  attr_accessor :bank_accounts
+                  # Can send funds from a FinancialAccount to another FinancialAccount owned by yourself.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundTransfers::FinancialAccounts))
+                   }
+                  attr_accessor :financial_accounts
+                  sig {
+                    params(bank_accounts: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundTransfers::BankAccounts), financial_accounts: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundTransfers::FinancialAccounts)).void
+                   }
+                  def initialize(bank_accounts: nil, financial_accounts: nil); end
+                end
+                # Can provision a financial address to credit/debit a FinancialAccount.
+                sig {
+                  returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::FinancialAddresses))
+                 }
+                attr_accessor :financial_addresses
+                # Can hold storage-type funds on Stripe.
+                sig {
+                  returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::HoldsCurrencies))
+                 }
+                attr_accessor :holds_currencies
+                # Can pull funds from an external source, owned by yourself, to a FinancialAccount.
+                sig {
+                  returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::InboundTransfers))
+                 }
+                attr_accessor :inbound_transfers
+                # Can send funds from a FinancialAccount to a destination owned by someone else.
+                sig {
+                  returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundPayments))
+                 }
+                attr_accessor :outbound_payments
+                # Can send funds from a FinancialAccount to a destination owned by yourself.
+                sig {
+                  returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundTransfers))
+                 }
+                attr_accessor :outbound_transfers
+                sig {
+                  params(financial_addresses: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::FinancialAddresses), holds_currencies: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::HoldsCurrencies), inbound_transfers: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::InboundTransfers), outbound_payments: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundPayments), outbound_transfers: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities::OutboundTransfers)).void
+                 }
+                def initialize(
+                  financial_addresses: nil,
+                  holds_currencies: nil,
+                  inbound_transfers: nil,
+                  outbound_payments: nil,
+                  outbound_transfers: nil
+                ); end
+              end
+              # Capabilities to request on the Storer Configuration.
+              sig {
+                returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities))
+               }
+              attr_accessor :capabilities
+              sig {
+                params(capabilities: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer::Capabilities)).void
+               }
+              def initialize(capabilities: nil); end
+            end
             # The Customer Configuration allows the Account to be used in inbound payment flows.
             sig {
               returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Customer))
@@ -187643,10 +188052,15 @@ module Stripe
               returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Recipient))
              }
             attr_accessor :recipient
+            # The Storer Configuration allows the Account to store and move funds using stored-value FinancialAccounts.
+            sig {
+              returns(T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer))
+             }
+            attr_accessor :storer
             sig {
-              params(customer: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Customer), merchant: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Merchant), recipient: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Recipient)).void
+              params(customer: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Customer), merchant: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Merchant), recipient: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Recipient), storer: T.nilable(::Stripe::V2::Core::AccountService::CreateParams::Configuration::Storer)).void
              }
-            def initialize(customer: nil, merchant: nil, recipient: nil); end
+            def initialize(customer: nil, merchant: nil, recipient: nil, storer: nil); end
           end
           class Defaults < Stripe::RequestParams
             class Responsibilities < Stripe::RequestParams
@@ -189798,6 +190212,180 @@ module Stripe
                }
               def initialize(capabilities: nil, default_outbound_destination: nil); end
             end
+            class Storer < Stripe::RequestParams
+              class Capabilities < Stripe::RequestParams
+                class FinancialAddresses < Stripe::RequestParams
+                  class BankAccounts < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T.nilable(T::Boolean)) }
+                    attr_accessor :requested
+                    sig { params(requested: T.nilable(T::Boolean)).void }
+                    def initialize(requested: nil); end
+                  end
+                  # Can provision a bank-account-like financial address (VBAN) to credit/debit a FinancialAccount.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::FinancialAddresses::BankAccounts))
+                   }
+                  attr_accessor :bank_accounts
+                  sig {
+                    params(bank_accounts: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::FinancialAddresses::BankAccounts)).void
+                   }
+                  def initialize(bank_accounts: nil); end
+                end
+                class HoldsCurrencies < Stripe::RequestParams
+                  class Gbp < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T.nilable(T::Boolean)) }
+                    attr_accessor :requested
+                    sig { params(requested: T.nilable(T::Boolean)).void }
+                    def initialize(requested: nil); end
+                  end
+                  # Can hold storage-type funds on Stripe in GBP.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::HoldsCurrencies::Gbp))
+                   }
+                  attr_accessor :gbp
+                  sig {
+                    params(gbp: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::HoldsCurrencies::Gbp)).void
+                   }
+                  def initialize(gbp: nil); end
+                end
+                class InboundTransfers < Stripe::RequestParams
+                  class BankAccounts < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T.nilable(T::Boolean)) }
+                    attr_accessor :requested
+                    sig { params(requested: T.nilable(T::Boolean)).void }
+                    def initialize(requested: nil); end
+                  end
+                  # Can pull funds from an external bank account owned by yourself to a FinancialAccount.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::InboundTransfers::BankAccounts))
+                   }
+                  attr_accessor :bank_accounts
+                  sig {
+                    params(bank_accounts: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::InboundTransfers::BankAccounts)).void
+                   }
+                  def initialize(bank_accounts: nil); end
+                end
+                class OutboundPayments < Stripe::RequestParams
+                  class BankAccounts < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T.nilable(T::Boolean)) }
+                    attr_accessor :requested
+                    sig { params(requested: T.nilable(T::Boolean)).void }
+                    def initialize(requested: nil); end
+                  end
+                  class Cards < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T.nilable(T::Boolean)) }
+                    attr_accessor :requested
+                    sig { params(requested: T.nilable(T::Boolean)).void }
+                    def initialize(requested: nil); end
+                  end
+                  class FinancialAccounts < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T.nilable(T::Boolean)) }
+                    attr_accessor :requested
+                    sig { params(requested: T.nilable(T::Boolean)).void }
+                    def initialize(requested: nil); end
+                  end
+                  # Can send funds from a FinancialAccount to a bank account owned by someone else.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundPayments::BankAccounts))
+                   }
+                  attr_accessor :bank_accounts
+                  # Can send funds from a FinancialAccount to a debit card owned by someone else.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundPayments::Cards))
+                   }
+                  attr_accessor :cards
+                  # Can send funds from a FinancialAccount to another FinancialAccount owned by someone else.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundPayments::FinancialAccounts))
+                   }
+                  attr_accessor :financial_accounts
+                  sig {
+                    params(bank_accounts: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundPayments::BankAccounts), cards: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundPayments::Cards), financial_accounts: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundPayments::FinancialAccounts)).void
+                   }
+                  def initialize(bank_accounts: nil, cards: nil, financial_accounts: nil); end
+                end
+                class OutboundTransfers < Stripe::RequestParams
+                  class BankAccounts < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T.nilable(T::Boolean)) }
+                    attr_accessor :requested
+                    sig { params(requested: T.nilable(T::Boolean)).void }
+                    def initialize(requested: nil); end
+                  end
+                  class FinancialAccounts < Stripe::RequestParams
+                    # To request a new Capability for an account, pass true. There can be a delay before the requested Capability becomes active.
+                    sig { returns(T.nilable(T::Boolean)) }
+                    attr_accessor :requested
+                    sig { params(requested: T.nilable(T::Boolean)).void }
+                    def initialize(requested: nil); end
+                  end
+                  # Can send funds from a FinancialAccount to a bank account owned by yourself.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundTransfers::BankAccounts))
+                   }
+                  attr_accessor :bank_accounts
+                  # Can send funds from a FinancialAccount to another FinancialAccount owned by yourself.
+                  sig {
+                    returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundTransfers::FinancialAccounts))
+                   }
+                  attr_accessor :financial_accounts
+                  sig {
+                    params(bank_accounts: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundTransfers::BankAccounts), financial_accounts: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundTransfers::FinancialAccounts)).void
+                   }
+                  def initialize(bank_accounts: nil, financial_accounts: nil); end
+                end
+                # Can provision a financial address to credit/debit a FinancialAccount.
+                sig {
+                  returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::FinancialAddresses))
+                 }
+                attr_accessor :financial_addresses
+                # Can hold storage-type funds on Stripe.
+                sig {
+                  returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::HoldsCurrencies))
+                 }
+                attr_accessor :holds_currencies
+                # Can pull funds from an external source, owned by yourself, to a FinancialAccount.
+                sig {
+                  returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::InboundTransfers))
+                 }
+                attr_accessor :inbound_transfers
+                # Can send funds from a FinancialAccount to a destination owned by someone else.
+                sig {
+                  returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundPayments))
+                 }
+                attr_accessor :outbound_payments
+                # Can send funds from a FinancialAccount to a destination owned by yourself.
+                sig {
+                  returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundTransfers))
+                 }
+                attr_accessor :outbound_transfers
+                sig {
+                  params(financial_addresses: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::FinancialAddresses), holds_currencies: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::HoldsCurrencies), inbound_transfers: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::InboundTransfers), outbound_payments: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundPayments), outbound_transfers: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities::OutboundTransfers)).void
+                 }
+                def initialize(
+                  financial_addresses: nil,
+                  holds_currencies: nil,
+                  inbound_transfers: nil,
+                  outbound_payments: nil,
+                  outbound_transfers: nil
+                ); end
+              end
+              # Capabilities to request on the Storer Configuration.
+              sig {
+                returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities))
+               }
+              attr_accessor :capabilities
+              sig {
+                params(capabilities: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer::Capabilities)).void
+               }
+              def initialize(capabilities: nil); end
+            end
             # The Customer Configuration allows the Account to be charged.
             sig {
               returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Customer))
@@ -189813,10 +190401,15 @@ module Stripe
               returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Recipient))
              }
             attr_accessor :recipient
+            # The Storer Configuration allows the Account to store and move funds using stored-value FinancialAccounts.
+            sig {
+              returns(T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer))
+             }
+            attr_accessor :storer
             sig {
-              params(customer: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Customer), merchant: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Merchant), recipient: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Recipient)).void
+              params(customer: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Customer), merchant: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Merchant), recipient: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Recipient), storer: T.nilable(::Stripe::V2::Core::AccountService::UpdateParams::Configuration::Storer)).void
              }
-            def initialize(customer: nil, merchant: nil, recipient: nil); end
+            def initialize(customer: nil, merchant: nil, recipient: nil, storer: nil); end
           end
           class Defaults < Stripe::RequestParams
             class Responsibilities < Stripe::RequestParams
@@ -192584,10 +193177,75 @@ module Stripe
           # The page limit.
           sig { returns(T.nilable(Integer)) }
           attr_accessor :limit
-          sig { params(limit: T.nilable(Integer)).void }
-          def initialize(limit: nil); end
+          # The status of the FinancialAccount to filter by. By default, closed FinancialAccounts are not returned.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :status
+          sig { params(limit: T.nilable(Integer), status: T.nilable(String)).void }
+          def initialize(limit: nil, status: nil); end
+        end
+        class CreateParams < Stripe::RequestParams
+          class Storage < Stripe::RequestParams
+            # The currencies that this FinancialAccount can hold.
+            sig { returns(T::Array[String]) }
+            attr_accessor :holds_currencies
+            sig { params(holds_currencies: T::Array[String]).void }
+            def initialize(holds_currencies: nil); end
+          end
+          # Metadata associated with the FinancialAccount.
+          sig { returns(T.nilable(T::Hash[String, String])) }
+          attr_accessor :metadata
+          # Parameters specific to creating `storage` type FinancialAccounts.
+          sig {
+            returns(T.nilable(::Stripe::V2::MoneyManagement::FinancialAccountService::CreateParams::Storage))
+           }
+          attr_accessor :storage
+          # The type of FinancialAccount to create.
+          sig { returns(String) }
+          attr_accessor :type
+          sig {
+            params(metadata: T.nilable(T::Hash[String, String]), storage: T.nilable(::Stripe::V2::MoneyManagement::FinancialAccountService::CreateParams::Storage), type: String).void
+           }
+          def initialize(metadata: nil, storage: nil, type: nil); end
         end
         class RetrieveParams < Stripe::RequestParams; end
+        class CloseParams < Stripe::RequestParams
+          class ForwardingSettings < Stripe::RequestParams
+            # The address to send forwarded payments to.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :payment_method
+            # The address to send forwarded payouts to.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :payout_method
+            sig { params(payment_method: T.nilable(String), payout_method: T.nilable(String)).void }
+            def initialize(payment_method: nil, payout_method: nil); end
+          end
+          # The addresses to forward any incoming transactions to.
+          sig {
+            returns(T.nilable(::Stripe::V2::MoneyManagement::FinancialAccountService::CloseParams::ForwardingSettings))
+           }
+          attr_accessor :forwarding_settings
+          sig {
+            params(forwarding_settings: T.nilable(::Stripe::V2::MoneyManagement::FinancialAccountService::CloseParams::ForwardingSettings)).void
+           }
+          def initialize(forwarding_settings: nil); end
+        end
+        # Closes a FinancialAccount with or without forwarding settings.
+        #
+        # ** raises NonZeroBalanceError
+        sig {
+          params(id: String, params: T.any(::Stripe::V2::MoneyManagement::FinancialAccountService::CloseParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::MoneyManagement::FinancialAccount)
+         }
+        def close(id, params = {}, opts = {}); end
+
+        # Creates a new FinancialAccount.
+        #
+        # ** raises AlreadyExistsError
+        # ** raises FeatureNotEnabledError
+        sig {
+          params(params: T.any(::Stripe::V2::MoneyManagement::FinancialAccountService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::MoneyManagement::FinancialAccount)
+         }
+        def create(params = {}, opts = {}); end
+
         # Lists FinancialAccounts in this compartment.
         sig {
           params(params: T.any(::Stripe::V2::MoneyManagement::FinancialAccountService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::V2::ListObject)