stripe 13.3.0 → 13.4.0.pre.beta.2

data/rbi/stripe/services/test_helpers/issuing_service.rbi

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module TestHelpers
+    class IssuingService < StripeService
+      attr_reader :authorizations
+      attr_reader :cards
+      attr_reader :personalization_designs
+      attr_reader :transactions
+    end
+  end
+end

data/rbi/stripe/services/test_helpers/refund_service.rbi

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module TestHelpers
+    class RefundService < StripeService
+      class ExpireParams < 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
+      # Expire a refund with a status of requires_action.
+      sig {
+        params(refund: String, params: T.any(::Stripe::TestHelpers::RefundService::ExpireParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Refund)
+       }
+      def expire(refund, params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/services/test_helpers/terminal/reader_service.rbi

@@ -0,0 +1,62 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module TestHelpers
+    module Terminal
+      class ReaderService < StripeService
+        class PresentPaymentMethodParams < Stripe::RequestParams
+          class CardPresent < Stripe::RequestParams
+            # The card number, as a string without any separators.
+            sig { returns(String) }
+            attr_accessor :number
+            sig { params(number: String).void }
+            def initialize(number: nil); end
+          end
+          class InteracPresent < Stripe::RequestParams
+            # Card Number
+            sig { returns(String) }
+            attr_accessor :number
+            sig { params(number: String).void }
+            def initialize(number: nil); end
+          end
+          # Simulated on-reader tip amount.
+          sig { returns(Integer) }
+          attr_accessor :amount_tip
+          # Simulated data for the card_present payment method.
+          sig {
+            returns(::Stripe::TestHelpers::Terminal::ReaderService::PresentPaymentMethodParams::CardPresent)
+           }
+          attr_accessor :card_present
+          # Specifies which fields in the response should be expanded.
+          sig { returns(T::Array[String]) }
+          attr_accessor :expand
+          # Simulated data for the interac_present payment method.
+          sig {
+            returns(::Stripe::TestHelpers::Terminal::ReaderService::PresentPaymentMethodParams::InteracPresent)
+           }
+          attr_accessor :interac_present
+          # Simulated payment type.
+          sig { returns(String) }
+          attr_accessor :type
+          sig {
+            params(amount_tip: Integer, card_present: ::Stripe::TestHelpers::Terminal::ReaderService::PresentPaymentMethodParams::CardPresent, expand: T::Array[String], interac_present: ::Stripe::TestHelpers::Terminal::ReaderService::PresentPaymentMethodParams::InteracPresent, type: String).void
+           }
+          def initialize(
+            amount_tip: nil,
+            card_present: nil,
+            expand: nil,
+            interac_present: nil,
+            type: nil
+          ); end
+        end
+        # Presents a payment method on a simulated reader. Can be used to simulate accepting a payment, saving a card or refunding a transaction.
+        sig {
+          params(reader: String, params: T.any(::Stripe::TestHelpers::Terminal::ReaderService::PresentPaymentMethodParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Terminal::Reader)
+         }
+        def present_payment_method(reader, params = {}, opts = {}); end
+      end
+    end
+  end
+end

data/rbi/stripe/services/test_helpers/terminal_service.rbi

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module TestHelpers
+    class TerminalService < StripeService
+      attr_reader :readers
+    end
+  end
+end

data/rbi/stripe/services/test_helpers/test_clock_service.rbi

@@ -0,0 +1,90 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module TestHelpers
+    class TestClockService < StripeService
+      class DeleteParams < Stripe::RequestParams
+
+      end
+      class RetrieveParams < 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
+      class ListParams < Stripe::RequestParams
+        # A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
+        sig { returns(String) }
+        attr_accessor :ending_before
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+        sig { returns(Integer) }
+        attr_accessor :limit
+        # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
+        sig { returns(String) }
+        attr_accessor :starting_after
+        sig {
+          params(ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String).void
+         }
+        def initialize(ending_before: nil, expand: nil, limit: nil, starting_after: nil); end
+      end
+      class CreateParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # The initial frozen time for this test clock.
+        sig { returns(Integer) }
+        attr_accessor :frozen_time
+        # The name for this test clock.
+        sig { returns(String) }
+        attr_accessor :name
+        sig { params(expand: T::Array[String], frozen_time: Integer, name: String).void }
+        def initialize(expand: nil, frozen_time: nil, name: nil); end
+      end
+      class AdvanceParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # The time to advance the test clock. Must be after the test clock's current frozen time. Cannot be more than two intervals in the future from the shortest subscription in this test clock. If there are no subscriptions in this test clock, it cannot be more than two years in the future.
+        sig { returns(Integer) }
+        attr_accessor :frozen_time
+        sig { params(expand: T::Array[String], frozen_time: Integer).void }
+        def initialize(expand: nil, frozen_time: nil); end
+      end
+      # Starts advancing a test clock to a specified time in the future. Advancement is done when status changes to Ready.
+      sig {
+        params(test_clock: String, params: T.any(::Stripe::TestHelpers::TestClockService::AdvanceParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::TestHelpers::TestClock)
+       }
+      def advance(test_clock, params = {}, opts = {}); end
+
+      # Creates a new test clock that can be attached to new customers and quotes.
+      sig {
+        params(params: T.any(::Stripe::TestHelpers::TestClockService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::TestHelpers::TestClock)
+       }
+      def create(params = {}, opts = {}); end
+
+      # Deletes a test clock.
+      sig {
+        params(test_clock: String, params: T.any(::Stripe::TestHelpers::TestClockService::DeleteParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::TestHelpers::TestClock)
+       }
+      def delete(test_clock, params = {}, opts = {}); end
+
+      # Returns a list of your test clocks.
+      sig {
+        params(params: T.any(::Stripe::TestHelpers::TestClockService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def list(params = {}, opts = {}); end
+
+      # Retrieves a test clock.
+      sig {
+        params(test_clock: String, params: T.any(::Stripe::TestHelpers::TestClockService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::TestHelpers::TestClock)
+       }
+      def retrieve(test_clock, params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/services/test_helpers/treasury/inbound_transfer_service.rbi

@@ -0,0 +1,64 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module TestHelpers
+    module Treasury
+      class InboundTransferService < StripeService
+        class FailParams < Stripe::RequestParams
+          class FailureDetails < Stripe::RequestParams
+            # Reason for the failure.
+            sig { returns(String) }
+            attr_accessor :code
+            sig { params(code: String).void }
+            def initialize(code: nil); end
+          end
+          # Specifies which fields in the response should be expanded.
+          sig { returns(T::Array[String]) }
+          attr_accessor :expand
+          # Details about a failed InboundTransfer.
+          sig {
+            returns(::Stripe::TestHelpers::Treasury::InboundTransferService::FailParams::FailureDetails)
+           }
+          attr_accessor :failure_details
+          sig {
+            params(expand: T::Array[String], failure_details: ::Stripe::TestHelpers::Treasury::InboundTransferService::FailParams::FailureDetails).void
+           }
+          def initialize(expand: nil, failure_details: nil); end
+        end
+        class ReturnInboundTransferParams < 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
+        class SucceedParams < 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
+        # Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
+        sig {
+          params(id: String, params: T.any(::Stripe::TestHelpers::Treasury::InboundTransferService::FailParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::InboundTransfer)
+         }
+        def fail(id, params = {}, opts = {}); end
+
+        # Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
+        sig {
+          params(id: String, params: T.any(::Stripe::TestHelpers::Treasury::InboundTransferService::ReturnInboundTransferParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::InboundTransfer)
+         }
+        def return_inbound_transfer(id, params = {}, opts = {}); end
+
+        # Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
+        sig {
+          params(id: String, params: T.any(::Stripe::TestHelpers::Treasury::InboundTransferService::SucceedParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::InboundTransfer)
+         }
+        def succeed(id, params = {}, opts = {}); end
+      end
+    end
+  end
+end

data/rbi/stripe/services/test_helpers/treasury/outbound_payment_service.rbi

@@ -0,0 +1,123 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module TestHelpers
+    module Treasury
+      class OutboundPaymentService < StripeService
+        class UpdateParams < Stripe::RequestParams
+          class TrackingDetails < Stripe::RequestParams
+            class Ach < Stripe::RequestParams
+              # ACH trace ID for funds sent over the `ach` network.
+              sig { returns(String) }
+              attr_accessor :trace_id
+              sig { params(trace_id: String).void }
+              def initialize(trace_id: nil); end
+            end
+            class UsDomesticWire < Stripe::RequestParams
+              # CHIPS System Sequence Number (SSN) for funds sent over the `us_domestic_wire` network.
+              sig { returns(String) }
+              attr_accessor :chips
+              # IMAD for funds sent over the `us_domestic_wire` network.
+              sig { returns(String) }
+              attr_accessor :imad
+              # OMAD for funds sent over the `us_domestic_wire` network.
+              sig { returns(String) }
+              attr_accessor :omad
+              sig { params(chips: String, imad: String, omad: String).void }
+              def initialize(chips: nil, imad: nil, omad: nil); end
+            end
+            # ACH network tracking details.
+            sig {
+              returns(::Stripe::TestHelpers::Treasury::OutboundPaymentService::UpdateParams::TrackingDetails::Ach)
+             }
+            attr_accessor :ach
+            # The US bank account network used to send funds.
+            sig { returns(String) }
+            attr_accessor :type
+            # US domestic wire network tracking details.
+            sig {
+              returns(::Stripe::TestHelpers::Treasury::OutboundPaymentService::UpdateParams::TrackingDetails::UsDomesticWire)
+             }
+            attr_accessor :us_domestic_wire
+            sig {
+              params(ach: ::Stripe::TestHelpers::Treasury::OutboundPaymentService::UpdateParams::TrackingDetails::Ach, type: String, us_domestic_wire: ::Stripe::TestHelpers::Treasury::OutboundPaymentService::UpdateParams::TrackingDetails::UsDomesticWire).void
+             }
+            def initialize(ach: nil, type: nil, us_domestic_wire: nil); end
+          end
+          # Specifies which fields in the response should be expanded.
+          sig { returns(T::Array[String]) }
+          attr_accessor :expand
+          # Details about network-specific tracking information.
+          sig {
+            returns(::Stripe::TestHelpers::Treasury::OutboundPaymentService::UpdateParams::TrackingDetails)
+           }
+          attr_accessor :tracking_details
+          sig {
+            params(expand: T::Array[String], tracking_details: ::Stripe::TestHelpers::Treasury::OutboundPaymentService::UpdateParams::TrackingDetails).void
+           }
+          def initialize(expand: nil, tracking_details: nil); end
+        end
+        class FailParams < 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
+        class PostParams < 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
+        class ReturnOutboundPaymentParams < Stripe::RequestParams
+          class ReturnedDetails < Stripe::RequestParams
+            # The return code to be set on the OutboundPayment object.
+            sig { returns(String) }
+            attr_accessor :code
+            sig { params(code: String).void }
+            def initialize(code: nil); end
+          end
+          # Specifies which fields in the response should be expanded.
+          sig { returns(T::Array[String]) }
+          attr_accessor :expand
+          # Optional hash to set the return code.
+          sig {
+            returns(::Stripe::TestHelpers::Treasury::OutboundPaymentService::ReturnOutboundPaymentParams::ReturnedDetails)
+           }
+          attr_accessor :returned_details
+          sig {
+            params(expand: T::Array[String], returned_details: ::Stripe::TestHelpers::Treasury::OutboundPaymentService::ReturnOutboundPaymentParams::ReturnedDetails).void
+           }
+          def initialize(expand: nil, returned_details: nil); end
+        end
+        # Transitions a test mode created OutboundPayment to the failed status. The OutboundPayment must already be in the processing state.
+        sig {
+          params(id: String, params: T.any(::Stripe::TestHelpers::Treasury::OutboundPaymentService::FailParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::OutboundPayment)
+         }
+        def fail(id, params = {}, opts = {}); end
+
+        # Transitions a test mode created OutboundPayment to the posted status. The OutboundPayment must already be in the processing state.
+        sig {
+          params(id: String, params: T.any(::Stripe::TestHelpers::Treasury::OutboundPaymentService::PostParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::OutboundPayment)
+         }
+        def post(id, params = {}, opts = {}); end
+
+        # Transitions a test mode created OutboundPayment to the returned status. The OutboundPayment must already be in the processing state.
+        sig {
+          params(id: String, params: T.any(::Stripe::TestHelpers::Treasury::OutboundPaymentService::ReturnOutboundPaymentParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::OutboundPayment)
+         }
+        def return_outbound_payment(id, params = {}, opts = {}); end
+
+        # Updates a test mode created OutboundPayment with tracking details. The OutboundPayment must not be cancelable, and cannot be in the canceled or failed states.
+        sig {
+          params(id: String, params: T.any(::Stripe::TestHelpers::Treasury::OutboundPaymentService::UpdateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::OutboundPayment)
+         }
+        def update(id, params = {}, opts = {}); end
+      end
+    end
+  end
+end

data/rbi/stripe/services/test_helpers/treasury/outbound_transfer_service.rbi

@@ -0,0 +1,123 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module TestHelpers
+    module Treasury
+      class OutboundTransferService < StripeService
+        class UpdateParams < Stripe::RequestParams
+          class TrackingDetails < Stripe::RequestParams
+            class Ach < Stripe::RequestParams
+              # ACH trace ID for funds sent over the `ach` network.
+              sig { returns(String) }
+              attr_accessor :trace_id
+              sig { params(trace_id: String).void }
+              def initialize(trace_id: nil); end
+            end
+            class UsDomesticWire < Stripe::RequestParams
+              # CHIPS System Sequence Number (SSN) for funds sent over the `us_domestic_wire` network.
+              sig { returns(String) }
+              attr_accessor :chips
+              # IMAD for funds sent over the `us_domestic_wire` network.
+              sig { returns(String) }
+              attr_accessor :imad
+              # OMAD for funds sent over the `us_domestic_wire` network.
+              sig { returns(String) }
+              attr_accessor :omad
+              sig { params(chips: String, imad: String, omad: String).void }
+              def initialize(chips: nil, imad: nil, omad: nil); end
+            end
+            # ACH network tracking details.
+            sig {
+              returns(::Stripe::TestHelpers::Treasury::OutboundTransferService::UpdateParams::TrackingDetails::Ach)
+             }
+            attr_accessor :ach
+            # The US bank account network used to send funds.
+            sig { returns(String) }
+            attr_accessor :type
+            # US domestic wire network tracking details.
+            sig {
+              returns(::Stripe::TestHelpers::Treasury::OutboundTransferService::UpdateParams::TrackingDetails::UsDomesticWire)
+             }
+            attr_accessor :us_domestic_wire
+            sig {
+              params(ach: ::Stripe::TestHelpers::Treasury::OutboundTransferService::UpdateParams::TrackingDetails::Ach, type: String, us_domestic_wire: ::Stripe::TestHelpers::Treasury::OutboundTransferService::UpdateParams::TrackingDetails::UsDomesticWire).void
+             }
+            def initialize(ach: nil, type: nil, us_domestic_wire: nil); end
+          end
+          # Specifies which fields in the response should be expanded.
+          sig { returns(T::Array[String]) }
+          attr_accessor :expand
+          # Details about network-specific tracking information.
+          sig {
+            returns(::Stripe::TestHelpers::Treasury::OutboundTransferService::UpdateParams::TrackingDetails)
+           }
+          attr_accessor :tracking_details
+          sig {
+            params(expand: T::Array[String], tracking_details: ::Stripe::TestHelpers::Treasury::OutboundTransferService::UpdateParams::TrackingDetails).void
+           }
+          def initialize(expand: nil, tracking_details: nil); end
+        end
+        class FailParams < 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
+        class PostParams < 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
+        class ReturnOutboundTransferParams < Stripe::RequestParams
+          class ReturnedDetails < Stripe::RequestParams
+            # Reason for the return.
+            sig { returns(String) }
+            attr_accessor :code
+            sig { params(code: String).void }
+            def initialize(code: nil); end
+          end
+          # Specifies which fields in the response should be expanded.
+          sig { returns(T::Array[String]) }
+          attr_accessor :expand
+          # Details about a returned OutboundTransfer.
+          sig {
+            returns(::Stripe::TestHelpers::Treasury::OutboundTransferService::ReturnOutboundTransferParams::ReturnedDetails)
+           }
+          attr_accessor :returned_details
+          sig {
+            params(expand: T::Array[String], returned_details: ::Stripe::TestHelpers::Treasury::OutboundTransferService::ReturnOutboundTransferParams::ReturnedDetails).void
+           }
+          def initialize(expand: nil, returned_details: nil); end
+        end
+        # Transitions a test mode created OutboundTransfer to the failed status. The OutboundTransfer must already be in the processing state.
+        sig {
+          params(outbound_transfer: String, params: T.any(::Stripe::TestHelpers::Treasury::OutboundTransferService::FailParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::OutboundTransfer)
+         }
+        def fail(outbound_transfer, params = {}, opts = {}); end
+
+        # Transitions a test mode created OutboundTransfer to the posted status. The OutboundTransfer must already be in the processing state.
+        sig {
+          params(outbound_transfer: String, params: T.any(::Stripe::TestHelpers::Treasury::OutboundTransferService::PostParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::OutboundTransfer)
+         }
+        def post(outbound_transfer, params = {}, opts = {}); end
+
+        # Transitions a test mode created OutboundTransfer to the returned status. The OutboundTransfer must already be in the processing state.
+        sig {
+          params(outbound_transfer: String, params: T.any(::Stripe::TestHelpers::Treasury::OutboundTransferService::ReturnOutboundTransferParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::OutboundTransfer)
+         }
+        def return_outbound_transfer(outbound_transfer, params = {}, opts = {}); end
+
+        # Updates a test mode created OutboundTransfer with tracking details. The OutboundTransfer must not be cancelable, and cannot be in the canceled or failed states.
+        sig {
+          params(outbound_transfer: String, params: T.any(::Stripe::TestHelpers::Treasury::OutboundTransferService::UpdateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::OutboundTransfer)
+         }
+        def update(outbound_transfer, params = {}, opts = {}); end
+      end
+    end
+  end
+end

data/rbi/stripe/services/test_helpers/treasury/received_credit_service.rbi

@@ -0,0 +1,114 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module TestHelpers
+    module Treasury
+      class ReceivedCreditService < StripeService
+        class CreateParams < Stripe::RequestParams
+          class InitiatingPaymentMethodDetails < Stripe::RequestParams
+            class UsBankAccount < Stripe::RequestParams
+              # The bank account holder's name.
+              sig { returns(String) }
+              attr_accessor :account_holder_name
+              # The bank account number.
+              sig { returns(String) }
+              attr_accessor :account_number
+              # The bank account's routing number.
+              sig { returns(String) }
+              attr_accessor :routing_number
+              sig {
+                params(account_holder_name: String, account_number: String, routing_number: String).void
+               }
+              def initialize(
+                account_holder_name: nil,
+                account_number: nil,
+                routing_number: nil
+              ); end
+            end
+            # The source type.
+            sig { returns(String) }
+            attr_accessor :type
+            # Optional fields for `us_bank_account`.
+            sig {
+              returns(::Stripe::TestHelpers::Treasury::ReceivedCreditService::CreateParams::InitiatingPaymentMethodDetails::UsBankAccount)
+             }
+            attr_accessor :us_bank_account
+            sig {
+              params(type: String, us_bank_account: ::Stripe::TestHelpers::Treasury::ReceivedCreditService::CreateParams::InitiatingPaymentMethodDetails::UsBankAccount).void
+             }
+            def initialize(type: nil, us_bank_account: nil); end
+          end
+          class NetworkDetails < Stripe::RequestParams
+            class Ach < Stripe::RequestParams
+              # ACH Addenda record
+              sig { returns(String) }
+              attr_accessor :addenda
+              sig { params(addenda: String).void }
+              def initialize(addenda: nil); end
+            end
+            # Optional fields for `ach`.
+            sig {
+              returns(::Stripe::TestHelpers::Treasury::ReceivedCreditService::CreateParams::NetworkDetails::Ach)
+             }
+            attr_accessor :ach
+            # The type of flow that originated the ReceivedCredit.
+            sig { returns(String) }
+            attr_accessor :type
+            sig {
+              params(ach: ::Stripe::TestHelpers::Treasury::ReceivedCreditService::CreateParams::NetworkDetails::Ach, type: String).void
+             }
+            def initialize(ach: nil, type: nil); end
+          end
+          # Amount (in cents) to be transferred.
+          sig { returns(Integer) }
+          attr_accessor :amount
+          # Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase. Must be a [supported currency](https://stripe.com/docs/currencies).
+          sig { returns(String) }
+          attr_accessor :currency
+          # An arbitrary string attached to the object. Often useful for displaying to users.
+          sig { returns(String) }
+          attr_accessor :description
+          # Specifies which fields in the response should be expanded.
+          sig { returns(T::Array[String]) }
+          attr_accessor :expand
+          # The FinancialAccount to send funds to.
+          sig { returns(String) }
+          attr_accessor :financial_account
+          # Initiating payment method details for the object.
+          sig {
+            returns(::Stripe::TestHelpers::Treasury::ReceivedCreditService::CreateParams::InitiatingPaymentMethodDetails)
+           }
+          attr_accessor :initiating_payment_method_details
+          # Specifies the network rails to be used. If not set, will default to the PaymentMethod's preferred network. See the [docs](https://stripe.com/docs/treasury/money-movement/timelines) to learn more about money movement timelines for each network type.
+          sig { returns(String) }
+          attr_accessor :network
+          # Details about the network used for the ReceivedCredit.
+          sig {
+            returns(::Stripe::TestHelpers::Treasury::ReceivedCreditService::CreateParams::NetworkDetails)
+           }
+          attr_accessor :network_details
+          sig {
+            params(amount: Integer, currency: String, description: String, expand: T::Array[String], financial_account: String, initiating_payment_method_details: ::Stripe::TestHelpers::Treasury::ReceivedCreditService::CreateParams::InitiatingPaymentMethodDetails, network: String, network_details: ::Stripe::TestHelpers::Treasury::ReceivedCreditService::CreateParams::NetworkDetails).void
+           }
+          def initialize(
+            amount: nil,
+            currency: nil,
+            description: nil,
+            expand: nil,
+            financial_account: nil,
+            initiating_payment_method_details: nil,
+            network: nil,
+            network_details: nil
+          ); end
+        end
+        # Use this endpoint to simulate a test mode ReceivedCredit initiated by a third party. In live mode, you can't directly create ReceivedCredits initiated by third parties.
+        sig {
+          params(params: T.any(::Stripe::TestHelpers::Treasury::ReceivedCreditService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Treasury::ReceivedCredit)
+         }
+        def create(params = {}, opts = {}); end
+      end
+    end
+  end
+end