stripe 13.3.0 → 13.4.0.pre.beta.1

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,23 @@
+# 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,69 @@
+# 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,100 @@
+# 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,69 @@
+# 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,137 @@
+# 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,137 @@
+# 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