stripe 15.4.0 → 15.5.0.pre.beta.1

data/lib/stripe/services/v2/core/vault/gb_bank_account_service.rb

@@ -0,0 +1,130 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module V2
+    module Core
+      module Vault
+        class GbBankAccountService < StripeService
+          class CreateParams < Stripe::RequestParams
+            class ConfirmationOfPayee < Stripe::RequestParams
+              # The business type to be checked against. Legal entity information will be used if unspecified.
+              # Closed enum.
+              attr_accessor :business_type
+              # User specifies whether Confirmation of Payee is automatically initiated when creating the bank account.
+              attr_accessor :initiate
+              # The name to be checked against. Legal entity information will be used if unspecified.
+              attr_accessor :name
+
+              def initialize(business_type: nil, initiate: nil, name: nil)
+                @business_type = business_type
+                @initiate = initiate
+                @name = name
+              end
+            end
+            # The Account Number of the bank account.
+            attr_accessor :account_number
+            # Closed Enum. The type of the bank account (checking or savings).
+            attr_accessor :bank_account_type
+            # Whether or not to automatically perform Confirmation of Payee to verify the users information
+            # against what was provided by the bank. Doing so is required for all bank accounts not owned
+            # by you before making domestic UK OutboundPayments.
+            attr_accessor :confirmation_of_payee
+            # The Sort Code of the bank account.
+            attr_accessor :sort_code
+
+            def initialize(
+              account_number: nil,
+              bank_account_type: nil,
+              confirmation_of_payee: nil,
+              sort_code: nil
+            )
+              @account_number = account_number
+              @bank_account_type = bank_account_type
+              @confirmation_of_payee = confirmation_of_payee
+              @sort_code = sort_code
+            end
+          end
+
+          class RetrieveParams < Stripe::RequestParams; end
+          class AcknowledgeConfirmationOfPayeeParams < Stripe::RequestParams; end
+          class ArchiveParams < Stripe::RequestParams; end
+
+          class InitiateConfirmationOfPayeeParams < Stripe::RequestParams
+            # The business type to be checked against. Legal entity information will be used if unspecified.
+            attr_accessor :business_type
+            # The name of the user to be checked against. Legal entity information will be used if unspecified.
+            attr_accessor :name
+
+            def initialize(business_type: nil, name: nil)
+              @business_type = business_type
+              @name = name
+            end
+          end
+
+          # Confirm that you have received the result of the Confirmation of Payee request, and that you are okay with
+          # proceeding to pay out to this bank account despite the account not matching, partially matching, or the service
+          # being unavailable. Once you confirm this, you will be able to send OutboundPayments, but this may lead to
+          # funds being sent to the wrong account, which we might not be able to recover.
+          def acknowledge_confirmation_of_payee(id, params = {}, opts = {})
+            request(
+              method: :post,
+              path: format("/v2/core/vault/gb_bank_accounts/%<id>s/acknowledge_confirmation_of_payee", { id: CGI.escape(id) }),
+              params: params,
+              opts: opts,
+              base_address: :api
+            )
+          end
+
+          # Archive a GBBankAccount object. Archived GBBankAccount objects cannot be used as outbound destinations
+          # and will not appear in the outbound destination list.
+          def archive(id, params = {}, opts = {})
+            request(
+              method: :post,
+              path: format("/v2/core/vault/gb_bank_accounts/%<id>s/archive", { id: CGI.escape(id) }),
+              params: params,
+              opts: opts,
+              base_address: :api
+            )
+          end
+
+          # Create a GB bank account.
+          def create(params = {}, opts = {})
+            request(
+              method: :post,
+              path: "/v2/core/vault/gb_bank_accounts",
+              params: params,
+              opts: opts,
+              base_address: :api
+            )
+          end
+
+          # Initiate Confirmation of Payee (CoP) in order to verify that the owner of a UK bank account matches
+          # who you expect. This must be done on all UK bank accounts before sending domestic OutboundPayments. If
+          # the result is a partial match or a non match, explicit acknowledgement using AcknowledgeConfirmationOfPayee
+          # is required before sending funds.
+          def initiate_confirmation_of_payee(id, params = {}, opts = {})
+            request(
+              method: :post,
+              path: format("/v2/core/vault/gb_bank_accounts/%<id>s/initiate_confirmation_of_payee", { id: CGI.escape(id) }),
+              params: params,
+              opts: opts,
+              base_address: :api
+            )
+          end
+
+          # Retrieve a GB bank account.
+          def retrieve(id, params = {}, opts = {})
+            request(
+              method: :get,
+              path: format("/v2/core/vault/gb_bank_accounts/%<id>s", { id: CGI.escape(id) }),
+              params: params,
+              opts: opts,
+              base_address: :api
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stripe/services/v2/core/vault/us_bank_account_service.rb

@@ -0,0 +1,107 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module V2
+    module Core
+      module Vault
+        class UsBankAccountService < StripeService
+          class CreateParams < Stripe::RequestParams
+            # The account number of the bank account.
+            attr_accessor :account_number
+            # Closed Enum. The type of the bank account (checking or savings).
+            attr_accessor :bank_account_type
+            # The fedwire routing number of the bank account. Note that certain banks have the same ACH and wire routing number.
+            attr_accessor :fedwire_routing_number
+            # The ACH routing number of the bank account. Note that certain banks have the same ACH and wire routing number.
+            attr_accessor :routing_number
+
+            def initialize(
+              account_number: nil,
+              bank_account_type: nil,
+              fedwire_routing_number: nil,
+              routing_number: nil
+            )
+              @account_number = account_number
+              @bank_account_type = bank_account_type
+              @fedwire_routing_number = fedwire_routing_number
+              @routing_number = routing_number
+            end
+          end
+
+          class RetrieveParams < Stripe::RequestParams; end
+
+          class UpdateParams < Stripe::RequestParams
+            # The bank account's fedwire routing number can be provided for update it was were empty previously.
+            attr_accessor :fedwire_routing_number
+            # The bank account's ACH routing number can be provided for update if it was empty previously.
+            attr_accessor :routing_number
+
+            def initialize(fedwire_routing_number: nil, routing_number: nil)
+              @fedwire_routing_number = fedwire_routing_number
+              @routing_number = routing_number
+            end
+          end
+
+          class ArchiveParams < Stripe::RequestParams; end
+
+          # Archive a USBankAccount object. USBankAccount objects will not be automatically archived by Stripe.
+          # Archived USBankAccount objects cannot be used as outbound destinations
+          # and will not appear in the outbound destination list.
+          #
+          # ** raises ControlledByDashboardError
+          def archive(id, params = {}, opts = {})
+            request(
+              method: :post,
+              path: format("/v2/core/vault/us_bank_accounts/%<id>s/archive", { id: CGI.escape(id) }),
+              params: params,
+              opts: opts,
+              base_address: :api
+            )
+          end
+
+          # Create a USBankAccount object.
+          #
+          # ** raises BlockedByStripeError
+          # ** raises InvalidPaymentMethodError
+          # ** raises QuotaExceededError
+          def create(params = {}, opts = {})
+            request(
+              method: :post,
+              path: "/v2/core/vault/us_bank_accounts",
+              params: params,
+              opts: opts,
+              base_address: :api
+            )
+          end
+
+          # Retrieve a USBankAccount object.
+          def retrieve(id, params = {}, opts = {})
+            request(
+              method: :get,
+              path: format("/v2/core/vault/us_bank_accounts/%<id>s", { id: CGI.escape(id) }),
+              params: params,
+              opts: opts,
+              base_address: :api
+            )
+          end
+
+          # Update a USBankAccount object. This is limited to supplying a previously empty routing_number field.
+          #
+          # ** raises BlockedByStripeError
+          # ** raises InvalidPaymentMethodError
+          # ** raises QuotaExceededError
+          def update(id, params = {}, opts = {})
+            request(
+              method: :post,
+              path: format("/v2/core/vault/us_bank_accounts/%<id>s", { id: CGI.escape(id) }),
+              params: params,
+              opts: opts,
+              base_address: :api
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stripe/services/v2/core/vault_service.rb

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module V2
+    module Core
+      class VaultService < StripeService
+        attr_reader :gb_bank_accounts, :us_bank_accounts
+
+        def initialize(requestor)
+          super
+          @gb_bank_accounts = Stripe::V2::Core::Vault::GbBankAccountService.new(@requestor)
+          @us_bank_accounts = Stripe::V2::Core::Vault::UsBankAccountService.new(@requestor)
+        end
+      end
+    end
+  end
+end

data/lib/stripe/services/v2/core_service.rb

@@ -4,12 +4,15 @@
 module Stripe
   module V2
     class CoreService < StripeService
-      attr_reader :event_destinations, :events
+      attr_reader :account_links, :accounts, :event_destinations, :events, :vault
 
       def initialize(requestor)
         super
+        @account_links = Stripe::V2::Core::AccountLinkService.new(@requestor)
+        @accounts = Stripe::V2::Core::AccountService.new(@requestor)
         @event_destinations = Stripe::V2::Core::EventDestinationService.new(@requestor)
         @events = Stripe::V2::Core::EventService.new(@requestor)
+        @vault = Stripe::V2::Core::VaultService.new(@requestor)
       end
     end
   end

data/lib/stripe/services/v2/money_management/adjustment_service.rb

@@ -0,0 +1,74 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module V2
+    module MoneyManagement
+      class AdjustmentService < StripeService
+        class ListParams < Stripe::RequestParams
+          # Filter for Adjustments linked to a Flow.
+          attr_accessor :adjusted_flow
+          # Filter for objects created at the specified timestamp.
+          # Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+          attr_accessor :created
+          # Filter for objects created after the specified timestamp.
+          # Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+          attr_accessor :created_gt
+          # Filter for objects created on or after the specified timestamp.
+          # Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+          attr_accessor :created_gte
+          # Filter for objects created before the specified timestamp.
+          # Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+          attr_accessor :created_lt
+          # Filter for objects created on or before the specified timestamp.
+          # Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+          attr_accessor :created_lte
+          # The page limit.
+          attr_accessor :limit
+
+          def initialize(
+            adjusted_flow: nil,
+            created: nil,
+            created_gt: nil,
+            created_gte: nil,
+            created_lt: nil,
+            created_lte: nil,
+            limit: nil
+          )
+            @adjusted_flow = adjusted_flow
+            @created = created
+            @created_gt = created_gt
+            @created_gte = created_gte
+            @created_lt = created_lt
+            @created_lte = created_lte
+            @limit = limit
+          end
+        end
+
+        class RetrieveParams < Stripe::RequestParams; end
+
+        # Returns a list of Adjustments that match the provided filters.
+        def list(params = {}, opts = {})
+          request(
+            method: :get,
+            path: "/v2/money_management/adjustments",
+            params: params,
+            opts: opts,
+            base_address: :api
+          )
+        end
+
+        # Retrieves the details of an Adjustment by ID.
+        def retrieve(id, params = {}, opts = {})
+          request(
+            method: :get,
+            path: format("/v2/money_management/adjustments/%<id>s", { id: CGI.escape(id) }),
+            params: params,
+            opts: opts,
+            base_address: :api
+          )
+        end
+      end
+    end
+  end
+end

data/lib/stripe/services/v2/money_management/financial_account_service.rb

@@ -0,0 +1,116 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module V2
+    module MoneyManagement
+      class FinancialAccountService < StripeService
+        class ListParams < Stripe::RequestParams
+          # The page limit.
+          attr_accessor :limit
+          # The status of the FinancialAccount to filter by. By default, closed FinancialAccounts are not returned.
+          attr_accessor :status
+
+          def initialize(limit: nil, status: nil)
+            @limit = limit
+            @status = status
+          end
+        end
+
+        class CreateParams < Stripe::RequestParams
+          class Storage < Stripe::RequestParams
+            # The currencies that this FinancialAccount can hold.
+            attr_accessor :holds_currencies
+
+            def initialize(holds_currencies: nil)
+              @holds_currencies = holds_currencies
+            end
+          end
+          # Metadata associated with the FinancialAccount.
+          attr_accessor :metadata
+          # Parameters specific to creating `storage` type FinancialAccounts.
+          attr_accessor :storage
+          # The type of FinancialAccount to create.
+          attr_accessor :type
+
+          def initialize(metadata: nil, storage: nil, type: nil)
+            @metadata = metadata
+            @storage = storage
+            @type = type
+          end
+        end
+
+        class RetrieveParams < Stripe::RequestParams; end
+
+        class CloseParams < Stripe::RequestParams
+          class ForwardingSettings < Stripe::RequestParams
+            # The address to send forwarded payments to.
+            attr_accessor :payment_method
+            # The address to send forwarded payouts to.
+            attr_accessor :payout_method
+
+            def initialize(payment_method: nil, payout_method: nil)
+              @payment_method = payment_method
+              @payout_method = payout_method
+            end
+          end
+          # The addresses to forward any incoming transactions to.
+          attr_accessor :forwarding_settings
+
+          def initialize(forwarding_settings: nil)
+            @forwarding_settings = forwarding_settings
+          end
+        end
+
+        # Closes a FinancialAccount with or without forwarding settings.
+        #
+        # ** raises NonZeroBalanceError
+        def close(id, params = {}, opts = {})
+          request(
+            method: :post,
+            path: format("/v2/money_management/financial_accounts/%<id>s/close", { id: CGI.escape(id) }),
+            params: params,
+            opts: opts,
+            base_address: :api
+          )
+        end
+
+        # Creates a new FinancialAccount.
+        #
+        # ** raises AlreadyExistsError
+        # ** raises FeatureNotEnabledError
+        def create(params = {}, opts = {})
+          request(
+            method: :post,
+            path: "/v2/money_management/financial_accounts",
+            params: params,
+            opts: opts,
+            base_address: :api
+          )
+        end
+
+        # Lists FinancialAccounts in this compartment.
+        def list(params = {}, opts = {})
+          request(
+            method: :get,
+            path: "/v2/money_management/financial_accounts",
+            params: params,
+            opts: opts,
+            base_address: :api
+          )
+        end
+
+        # Retrieves the details of an existing FinancialAccount.
+        def retrieve(id, params = {}, opts = {})
+          request(
+            method: :get,
+            path: format("/v2/money_management/financial_accounts/%<id>s", { id: CGI.escape(id) }),
+            params: params,
+            opts: opts,
+            base_address: :api
+          )
+        end
+      end
+    end
+  end
+end

data/lib/stripe/services/v2/money_management/financial_address_service.rb

@@ -0,0 +1,82 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module V2
+    module MoneyManagement
+      class FinancialAddressService < StripeService
+        class ListParams < Stripe::RequestParams
+          # The ID of the FinancialAccount for which FinancialAddresses are to be returned.
+          attr_accessor :financial_account
+          # Open Enum. A list of fields to reveal in the FinancialAddresses returned.
+          attr_accessor :include
+          # The page limit.
+          attr_accessor :limit
+
+          def initialize(financial_account: nil, include: nil, limit: nil)
+            @financial_account = financial_account
+            @include = include
+            @limit = limit
+          end
+        end
+
+        class CreateParams < Stripe::RequestParams
+          # Open Enum. The currency the FinancialAddress should support. Currently, only the `usd` and `gbp` values are supported.
+          attr_accessor :currency
+          # The ID of the FinancialAccount the new FinancialAddress should be associated with.
+          attr_accessor :financial_account
+
+          def initialize(currency: nil, financial_account: nil)
+            @currency = currency
+            @financial_account = financial_account
+          end
+        end
+
+        class RetrieveParams < Stripe::RequestParams
+          # Open Enum. A list of fields to reveal in the FinancialAddresses returned.
+          attr_accessor :include
+
+          def initialize(include: nil)
+            @include = include
+          end
+        end
+
+        # Create a new FinancialAddress for a FinancialAccount.
+        #
+        # ** raises FinancialAccountNotOpenError
+        # ** raises FeatureNotEnabledError
+        def create(params = {}, opts = {})
+          request(
+            method: :post,
+            path: "/v2/money_management/financial_addresses",
+            params: params,
+            opts: opts,
+            base_address: :api
+          )
+        end
+
+        # List all FinancialAddresses for a FinancialAccount.
+        def list(params = {}, opts = {})
+          request(
+            method: :get,
+            path: "/v2/money_management/financial_addresses",
+            params: params,
+            opts: opts,
+            base_address: :api
+          )
+        end
+
+        # Retrieve a FinancialAddress. By default, the FinancialAddress will be returned in its unexpanded state, revealing only the last 4 digits of the account number.
+        def retrieve(id, params = {}, opts = {})
+          request(
+            method: :get,
+            path: format("/v2/money_management/financial_addresses/%<id>s", { id: CGI.escape(id) }),
+            params: params,
+            opts: opts,
+            base_address: :api
+          )
+        end
+      end
+    end
+  end
+end

data/lib/stripe/services/v2/money_management/inbound_transfer_service.rb

@@ -0,0 +1,125 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+module Stripe
+  module V2
+    module MoneyManagement
+      class InboundTransferService < StripeService
+        class ListParams < Stripe::RequestParams
+          # Filter for objects created at the specified timestamp.
+          # Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+          attr_accessor :created
+          # Filter for objects created after the specified timestamp.
+          # Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+          attr_accessor :created_gt
+          # Filter for objects created on or after the specified timestamp.
+          # Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+          attr_accessor :created_gte
+          # Filter for objects created before the specified timestamp.
+          # Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+          attr_accessor :created_lt
+          # Filter for objects created on or before the specified timestamp.
+          # Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
+          attr_accessor :created_lte
+          # The page limit.
+          attr_accessor :limit
+
+          def initialize(
+            created: nil,
+            created_gt: nil,
+            created_gte: nil,
+            created_lt: nil,
+            created_lte: nil,
+            limit: nil
+          )
+            @created = created
+            @created_gt = created_gt
+            @created_gte = created_gte
+            @created_lt = created_lt
+            @created_lte = created_lte
+            @limit = limit
+          end
+        end
+
+        class CreateParams < Stripe::RequestParams
+          class From < Stripe::RequestParams
+            # An optional currency field used to specify which currency is debited from the Payment Method.
+            # Since many Payment Methods support only one currency, this field is optional.
+            attr_accessor :currency
+            # ID of the Payment Method using which IBT will be made.
+            attr_accessor :payment_method
+
+            def initialize(currency: nil, payment_method: nil)
+              @currency = currency
+              @payment_method = payment_method
+            end
+          end
+
+          class To < Stripe::RequestParams
+            # The currency in which funds will land in.
+            attr_accessor :currency
+            # The FinancialAccount that funds will land in.
+            attr_accessor :financial_account
+
+            def initialize(currency: nil, financial_account: nil)
+              @currency = currency
+              @financial_account = financial_account
+            end
+          end
+          # The amount, in specified currency, by which the FinancialAccount balance will increase due to the InboundTransfer.
+          attr_accessor :amount
+          # An optional, freeform description field intended to store metadata.
+          attr_accessor :description
+          # Object containing details about where the funds will originate from.
+          attr_accessor :from
+          # Object containing details about where the funds will land.
+          attr_accessor :to
+
+          def initialize(amount: nil, description: nil, from: nil, to: nil)
+            @amount = amount
+            @description = description
+            @from = from
+            @to = to
+          end
+        end
+
+        class RetrieveParams < Stripe::RequestParams; end
+
+        # InboundTransfers APIs are used to create, retrieve or list InboundTransfers.
+        #
+        # ** raises BlockedByStripeError
+        def create(params = {}, opts = {})
+          request(
+            method: :post,
+            path: "/v2/money_management/inbound_transfers",
+            params: params,
+            opts: opts,
+            base_address: :api
+          )
+        end
+
+        # Retrieves a list of InboundTransfers.
+        def list(params = {}, opts = {})
+          request(
+            method: :get,
+            path: "/v2/money_management/inbound_transfers",
+            params: params,
+            opts: opts,
+            base_address: :api
+          )
+        end
+
+        # Retrieve an InboundTransfer by ID.
+        def retrieve(id, params = {}, opts = {})
+          request(
+            method: :get,
+            path: format("/v2/money_management/inbound_transfers/%<id>s", { id: CGI.escape(id) }),
+            params: params,
+            opts: opts,
+            base_address: :api
+          )
+        end
+      end
+    end
+  end
+end