stripe 13.3.0 → 13.4.0.pre.beta.2

data/rbi/stripe/resources/financial_connections/institution.rbi

@@ -0,0 +1,99 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module FinancialConnections
+    # An institution represents a financial institution to which an end user can connect using the Financial Connections authentication flow.
+    class Institution < APIResource
+      class Features < Stripe::StripeObject
+        class Balances < Stripe::StripeObject
+          # Whether the given feature is supported by this institution.
+          sig { returns(T::Boolean) }
+          attr_reader :supported
+        end
+        class Ownership < Stripe::StripeObject
+          # Whether the given feature is supported by this institution.
+          sig { returns(T::Boolean) }
+          attr_reader :supported
+        end
+        class PaymentMethod < Stripe::StripeObject
+          # Whether the given feature is supported by this institution.
+          sig { returns(T::Boolean) }
+          attr_reader :supported
+        end
+        class Transactions < Stripe::StripeObject
+          # Whether the given feature is supported by this institution.
+          sig { returns(T::Boolean) }
+          attr_reader :supported
+        end
+        # Attribute for field balances
+        sig { returns(Balances) }
+        attr_reader :balances
+        # Attribute for field ownership
+        sig { returns(Ownership) }
+        attr_reader :ownership
+        # Attribute for field payment_method
+        sig { returns(PaymentMethod) }
+        attr_reader :payment_method
+        # Attribute for field transactions
+        sig { returns(Transactions) }
+        attr_reader :transactions
+      end
+      # Attribute for field features
+      sig { returns(Features) }
+      attr_reader :features
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_reader :id
+      # Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
+      sig { returns(T::Boolean) }
+      attr_reader :livemode
+      # The name of this institution.
+      sig { returns(String) }
+      attr_reader :name
+      # String representing the object's type. Objects of the same type share the same value.
+      sig { returns(String) }
+      attr_reader :object
+      # A list of routing numbers which are known to correspond to this institution. Due to the many to many relationship between institutions and routing numbers, this list may not be comprehensive and routing numbers may also be shared between institutions.
+      sig { returns(T::Array[String]) }
+      attr_reader :routing_numbers
+      # The status of this institution in the Financial Connections authentication flow.
+      sig { returns(String) }
+      attr_reader :status
+      # A URL corresponding to this institution. This URL is also displayed in the authentication flow to help end users confirm that they are authenticating with the right institution.
+      sig { returns(T.nilable(String)) }
+      attr_reader :url
+      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 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
+      # Returns a list of Financial Connections Institution objects.
+      sig {
+        params(params: T.any(::Stripe::FinancialConnections::Institution::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def self.list(params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/resources/financial_connections/session.rbi

@@ -0,0 +1,186 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module FinancialConnections
+    # A Financial Connections Session is the secure way to programmatically launch the client-side Stripe.js modal that lets your users link their accounts.
+    class Session < APIResource
+      class AccountHolder < Stripe::StripeObject
+        # The ID of the Stripe account this account belongs to. Should only be present if `account_holder.type` is `account`.
+        sig { returns(T.any(String, Stripe::Account)) }
+        attr_reader :account
+        # ID of the Stripe customer this account belongs to. Present if and only if `account_holder.type` is `customer`.
+        sig { returns(T.any(String, Stripe::Customer)) }
+        attr_reader :customer
+        # Type of account holder that this account belongs to.
+        sig { returns(String) }
+        attr_reader :type
+      end
+      class Filters < Stripe::StripeObject
+        # Restricts the Session to subcategories of accounts that can be linked. Valid subcategories are: `checking`, `savings`, `mortgage`, `line_of_credit`, `credit_card`.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :account_subcategories
+        # List of countries from which to filter accounts.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :countries
+        # Stripe ID of the institution with which the customer should be directed to log in.
+        sig { returns(String) }
+        attr_reader :institution
+      end
+      class Limits < Stripe::StripeObject
+        # The number of accounts that can be linked in this Session.
+        sig { returns(Integer) }
+        attr_reader :accounts
+      end
+      class ManualEntry < Stripe::StripeObject; end
+      class StatusDetails < Stripe::StripeObject
+        class Cancelled < Stripe::StripeObject
+          # The reason for the Session being cancelled.
+          sig { returns(String) }
+          attr_reader :reason
+        end
+        # Attribute for field cancelled
+        sig { returns(Cancelled) }
+        attr_reader :cancelled
+      end
+      # The account holder for whom accounts are collected in this session.
+      sig { returns(T.nilable(AccountHolder)) }
+      attr_reader :account_holder
+      # The accounts that were collected as part of this Session.
+      sig { returns(Stripe::ListObject) }
+      attr_reader :accounts
+      # A value that will be passed to the client to launch the authentication flow.
+      sig { returns(String) }
+      attr_reader :client_secret
+      # Attribute for field filters
+      sig { returns(Filters) }
+      attr_reader :filters
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_reader :id
+      # Attribute for field limits
+      sig { returns(Limits) }
+      attr_reader :limits
+      # Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
+      sig { returns(T::Boolean) }
+      attr_reader :livemode
+      # Attribute for field manual_entry
+      sig { returns(ManualEntry) }
+      attr_reader :manual_entry
+      # String representing the object's type. Objects of the same type share the same value.
+      sig { returns(String) }
+      attr_reader :object
+      # Permissions requested for accounts collected during this session.
+      sig { returns(T::Array[String]) }
+      attr_reader :permissions
+      # Data features requested to be retrieved upon account creation.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :prefetch
+      # For webview integrations only. Upon completing OAuth login in the native browser, the user will be redirected to this URL to return to your app.
+      sig { returns(String) }
+      attr_reader :return_url
+      # The current state of the session.
+      sig { returns(String) }
+      attr_reader :status
+      # Attribute for field status_details
+      sig { returns(StatusDetails) }
+      attr_reader :status_details
+      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 CreateParams < Stripe::RequestParams
+        class AccountHolder < Stripe::RequestParams
+          # The ID of the Stripe account whose accounts will be retrieved. Should only be present if `type` is `account`.
+          sig { returns(String) }
+          attr_accessor :account
+          # The ID of the Stripe customer whose accounts will be retrieved. Should only be present if `type` is `customer`.
+          sig { returns(String) }
+          attr_accessor :customer
+          # Type of account holder to collect accounts for.
+          sig { returns(String) }
+          attr_accessor :type
+          sig { params(account: String, customer: String, type: String).void }
+          def initialize(account: nil, customer: nil, type: nil); end
+        end
+        class Filters < Stripe::RequestParams
+          # Restricts the Session to subcategories of accounts that can be linked. Valid subcategories are: `checking`, `savings`, `mortgage`, `line_of_credit`, `credit_card`.
+          sig { returns(T::Array[String]) }
+          attr_accessor :account_subcategories
+          # List of countries from which to collect accounts.
+          sig { returns(T::Array[String]) }
+          attr_accessor :countries
+          # Stripe ID of the institution with which the customer should be directed to log in.
+          sig { returns(String) }
+          attr_accessor :institution
+          sig {
+            params(account_subcategories: T::Array[String], countries: T::Array[String], institution: String).void
+           }
+          def initialize(account_subcategories: nil, countries: nil, institution: nil); end
+        end
+        class Limits < Stripe::RequestParams
+          # The number of accounts that can be linked in this Session.
+          sig { returns(Integer) }
+          attr_accessor :accounts
+          sig { params(accounts: Integer).void }
+          def initialize(accounts: nil); end
+        end
+        class ManualEntry < Stripe::RequestParams
+          # Whether manual entry will be handled by Stripe during the Session.
+          sig { returns(String) }
+          attr_accessor :mode
+          sig { params(mode: String).void }
+          def initialize(mode: nil); end
+        end
+        # The account holder to link accounts for.
+        sig { returns(::Stripe::FinancialConnections::Session::CreateParams::AccountHolder) }
+        attr_accessor :account_holder
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # Filters to restrict the kinds of accounts to collect.
+        sig { returns(::Stripe::FinancialConnections::Session::CreateParams::Filters) }
+        attr_accessor :filters
+        # Settings for configuring Session-specific limits.
+        sig { returns(::Stripe::FinancialConnections::Session::CreateParams::Limits) }
+        attr_accessor :limits
+        # Settings for configuring manual entry of account details for this Session.
+        sig { returns(::Stripe::FinancialConnections::Session::CreateParams::ManualEntry) }
+        attr_accessor :manual_entry
+        # List of data features that you would like to request access to.
+        #
+        # Possible values are `balances`, `transactions`, `ownership`, and `payment_method`.
+        sig { returns(T::Array[String]) }
+        attr_accessor :permissions
+        # List of data features that you would like to retrieve upon account creation.
+        sig { returns(T::Array[String]) }
+        attr_accessor :prefetch
+        # For webview integrations only. Upon completing OAuth login in the native browser, the user will be redirected to this URL to return to your app.
+        sig { returns(String) }
+        attr_accessor :return_url
+        sig {
+          params(account_holder: ::Stripe::FinancialConnections::Session::CreateParams::AccountHolder, expand: T::Array[String], filters: ::Stripe::FinancialConnections::Session::CreateParams::Filters, limits: ::Stripe::FinancialConnections::Session::CreateParams::Limits, manual_entry: ::Stripe::FinancialConnections::Session::CreateParams::ManualEntry, permissions: T::Array[String], prefetch: T::Array[String], return_url: String).void
+         }
+        def initialize(
+          account_holder: nil,
+          expand: nil,
+          filters: nil,
+          limits: nil,
+          manual_entry: nil,
+          permissions: nil,
+          prefetch: nil,
+          return_url: nil
+        ); end
+      end
+      # To launch the Financial Connections authorization flow, create a Session. The session's client_secret can be used to launch the flow using Stripe.js.
+      sig {
+        params(params: T.any(::Stripe::FinancialConnections::Session::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::FinancialConnections::Session)
+       }
+      def self.create(params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/resources/financial_connections/transaction.rbi

@@ -0,0 +1,127 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module FinancialConnections
+    # A Transaction represents a real transaction that affects a Financial Connections Account balance.
+    class Transaction < APIResource
+      class StatusTransitions < Stripe::StripeObject
+        # Time at which this transaction posted. Measured in seconds since the Unix epoch.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :posted_at
+        # Time at which this transaction was voided. Measured in seconds since the Unix epoch.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :void_at
+      end
+      # The ID of the Financial Connections Account this transaction belongs to.
+      sig { returns(String) }
+      attr_reader :account
+      # The amount of this transaction, in cents (or local equivalent).
+      sig { returns(Integer) }
+      attr_reader :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_reader :currency
+      # The description of this transaction.
+      sig { returns(String) }
+      attr_reader :description
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_reader :id
+      # Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
+      sig { returns(T::Boolean) }
+      attr_reader :livemode
+      # String representing the object's type. Objects of the same type share the same value.
+      sig { returns(String) }
+      attr_reader :object
+      # The status of the transaction.
+      sig { returns(String) }
+      attr_reader :status
+      # Attribute for field status_transitions
+      sig { returns(StatusTransitions) }
+      attr_reader :status_transitions
+      # Time at which the transaction was transacted. Measured in seconds since the Unix epoch.
+      sig { returns(Integer) }
+      attr_reader :transacted_at
+      # The token of the transaction refresh that last updated or created this transaction.
+      sig { returns(String) }
+      attr_reader :transaction_refresh
+      # Time at which the object was last updated. Measured in seconds since the Unix epoch.
+      sig { returns(Integer) }
+      attr_reader :updated
+      class ListParams < Stripe::RequestParams
+        class TransactedAt < Stripe::RequestParams
+          # Minimum value to filter by (exclusive)
+          sig { returns(Integer) }
+          attr_accessor :gt
+          # Minimum value to filter by (inclusive)
+          sig { returns(Integer) }
+          attr_accessor :gte
+          # Maximum value to filter by (exclusive)
+          sig { returns(Integer) }
+          attr_accessor :lt
+          # Maximum value to filter by (inclusive)
+          sig { returns(Integer) }
+          attr_accessor :lte
+          sig { params(gt: Integer, gte: Integer, lt: Integer, lte: Integer).void }
+          def initialize(gt: nil, gte: nil, lt: nil, lte: nil); end
+        end
+        class TransactionRefresh < Stripe::RequestParams
+          # Return results where the transactions were created or updated by a refresh that took place after this refresh (non-inclusive).
+          sig { returns(String) }
+          attr_accessor :after
+          sig { params(after: String).void }
+          def initialize(after: nil); end
+        end
+        # The ID of the Stripe account whose transactions will be retrieved.
+        sig { returns(String) }
+        attr_accessor :account
+        # 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
+        # A filter on the list based on the object `transacted_at` field. The value can be a string with an integer Unix timestamp, or it can be a dictionary with the following options:
+        sig {
+          returns(T.any(::Stripe::FinancialConnections::Transaction::ListParams::TransactedAt, Integer))
+         }
+        attr_accessor :transacted_at
+        # A filter on the list based on the object `transaction_refresh` field. The value can be a dictionary with the following options:
+        sig { returns(::Stripe::FinancialConnections::Transaction::ListParams::TransactionRefresh) }
+        attr_accessor :transaction_refresh
+        sig {
+          params(account: String, ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String, transacted_at: T.any(::Stripe::FinancialConnections::Transaction::ListParams::TransactedAt, Integer), transaction_refresh: ::Stripe::FinancialConnections::Transaction::ListParams::TransactionRefresh).void
+         }
+        def initialize(
+          account: nil,
+          ending_before: nil,
+          expand: nil,
+          limit: nil,
+          starting_after: nil,
+          transacted_at: nil,
+          transaction_refresh: nil
+        ); end
+      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
+      # Returns a list of Financial Connections Transaction objects.
+      sig {
+        params(params: T.any(::Stripe::FinancialConnections::Transaction::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def self.list(params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/resources/forwarding/request.rbi

@@ -0,0 +1,219 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Forwarding
+    # Instructs Stripe to make a request on your behalf using the destination URL. The destination URL
+    # is activated by Stripe at the time of onboarding. Stripe verifies requests with your credentials
+    # provided during onboarding, and injects card details from the payment_method into the request.
+    #
+    # Stripe redacts all sensitive fields and headers, including authentication credentials and card numbers,
+    # before storing the request and response data in the forwarding Request object, which are subject to a
+    # 30-day retention period.
+    #
+    # You can provide a Stripe idempotency key to make sure that requests with the same key result in only one
+    # outbound request. The Stripe idempotency key provided should be unique and different from any idempotency
+    # keys provided on the underlying third-party request.
+    #
+    # Forwarding Requests are synchronous requests that return a response or time out according to
+    # Stripe's limits.
+    #
+    # Related guide: [Forward card details to third-party API endpoints](https://docs.stripe.com/payments/forwarding).
+    class Request < APIResource
+      class RequestContext < Stripe::StripeObject
+        # The time it took in milliseconds for the destination endpoint to respond.
+        sig { returns(Integer) }
+        attr_reader :destination_duration
+        # The IP address of the destination.
+        sig { returns(String) }
+        attr_reader :destination_ip_address
+      end
+      class RequestDetails < Stripe::StripeObject
+        class Header < Stripe::StripeObject
+          # The header name.
+          sig { returns(String) }
+          attr_reader :name
+          # The header value.
+          sig { returns(String) }
+          attr_reader :value
+        end
+        # The body payload to send to the destination endpoint.
+        sig { returns(String) }
+        attr_reader :body
+        # The headers to include in the forwarded request. Can be omitted if no additional headers (excluding Stripe-generated ones such as the Content-Type header) should be included.
+        sig { returns(T::Array[Header]) }
+        attr_reader :headers
+        # The HTTP method used to call the destination endpoint.
+        sig { returns(String) }
+        attr_reader :http_method
+      end
+      class ResponseDetails < Stripe::StripeObject
+        class Header < Stripe::StripeObject
+          # The header name.
+          sig { returns(String) }
+          attr_reader :name
+          # The header value.
+          sig { returns(String) }
+          attr_reader :value
+        end
+        # The response body from the destination endpoint to Stripe.
+        sig { returns(String) }
+        attr_reader :body
+        # HTTP headers that the destination endpoint returned.
+        sig { returns(T::Array[Header]) }
+        attr_reader :headers
+        # The HTTP status code that the destination endpoint returned.
+        sig { returns(Integer) }
+        attr_reader :status
+      end
+      # Time at which the object was created. Measured in seconds since the Unix epoch.
+      sig { returns(Integer) }
+      attr_reader :created
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_reader :id
+      # Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
+      sig { returns(T::Boolean) }
+      attr_reader :livemode
+      # Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format.
+      sig { returns(T.nilable(T::Hash[String, String])) }
+      attr_reader :metadata
+      # String representing the object's type. Objects of the same type share the same value.
+      sig { returns(String) }
+      attr_reader :object
+      # The PaymentMethod to insert into the forwarded request. Forwarding previously consumed PaymentMethods is allowed.
+      sig { returns(String) }
+      attr_reader :payment_method
+      # The field kinds to be replaced in the forwarded request.
+      sig { returns(T::Array[String]) }
+      attr_reader :replacements
+      # Context about the request from Stripe's servers to the destination endpoint.
+      sig { returns(T.nilable(RequestContext)) }
+      attr_reader :request_context
+      # The request that was sent to the destination endpoint. We redact any sensitive fields.
+      sig { returns(T.nilable(RequestDetails)) }
+      attr_reader :request_details
+      # The response that the destination endpoint returned to us. We redact any sensitive fields.
+      sig { returns(T.nilable(ResponseDetails)) }
+      attr_reader :response_details
+      # The destination URL for the forwarded request. Must be supported by the config.
+      sig { returns(T.nilable(String)) }
+      attr_reader :url
+      class ListParams < Stripe::RequestParams
+        class Created < Stripe::RequestParams
+          # Return results where the `created` field is greater than this value.
+          sig { returns(Integer) }
+          attr_accessor :gt
+          # Return results where the `created` field is greater than or equal to this value.
+          sig { returns(Integer) }
+          attr_accessor :gte
+          # Return results where the `created` field is less than this value.
+          sig { returns(Integer) }
+          attr_accessor :lt
+          # Return results where the `created` field is less than or equal to this value.
+          sig { returns(Integer) }
+          attr_accessor :lte
+          sig { params(gt: Integer, gte: Integer, lt: Integer, lte: Integer).void }
+          def initialize(gt: nil, gte: nil, lt: nil, lte: nil); end
+        end
+        # Similar to other List endpoints, filters results based on created timestamp. You can pass gt, gte, lt, and lte timestamp values.
+        sig { returns(::Stripe::Forwarding::Request::ListParams::Created) }
+        attr_accessor :created
+        # A pagination cursor to fetch the previous page of the list. The value must be a ForwardingRequest ID.
+        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 pagination cursor to fetch the next page of the list. The value must be a ForwardingRequest ID.
+        sig { returns(String) }
+        attr_accessor :starting_after
+        sig {
+          params(created: ::Stripe::Forwarding::Request::ListParams::Created, ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String).void
+         }
+        def initialize(
+          created: nil,
+          ending_before: nil,
+          expand: nil,
+          limit: nil,
+          starting_after: nil
+        ); end
+      end
+      class CreateParams < Stripe::RequestParams
+        class Request < Stripe::RequestParams
+          class Header < Stripe::RequestParams
+            # The header name.
+            sig { returns(String) }
+            attr_accessor :name
+            # The header value.
+            sig { returns(String) }
+            attr_accessor :value
+            sig { params(name: String, value: String).void }
+            def initialize(name: nil, value: nil); end
+          end
+          # The body payload to send to the destination endpoint.
+          sig { returns(String) }
+          attr_accessor :body
+          # The headers to include in the forwarded request. Can be omitted if no additional headers (excluding Stripe-generated ones such as the Content-Type header) should be included.
+          sig { returns(T::Array[::Stripe::Forwarding::Request::CreateParams::Request::Header]) }
+          attr_accessor :headers
+          sig {
+            params(body: String, headers: T::Array[::Stripe::Forwarding::Request::CreateParams::Request::Header]).void
+           }
+          def initialize(body: nil, headers: nil); end
+        end
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
+        sig { returns(T::Hash[String, String]) }
+        attr_accessor :metadata
+        # The PaymentMethod to insert into the forwarded request. Forwarding previously consumed PaymentMethods is allowed.
+        sig { returns(String) }
+        attr_accessor :payment_method
+        # The field kinds to be replaced in the forwarded request.
+        sig { returns(T::Array[String]) }
+        attr_accessor :replacements
+        # The request body and headers to be sent to the destination endpoint.
+        sig { returns(::Stripe::Forwarding::Request::CreateParams::Request) }
+        attr_accessor :request
+        # The destination URL for the forwarded request. Must be supported by the config.
+        sig { returns(String) }
+        attr_accessor :url
+        sig {
+          params(expand: T::Array[String], metadata: T::Hash[String, String], payment_method: String, replacements: T::Array[String], request: ::Stripe::Forwarding::Request::CreateParams::Request, url: String).void
+         }
+        def initialize(
+          expand: nil,
+          metadata: nil,
+          payment_method: nil,
+          replacements: nil,
+          request: nil,
+          url: nil
+        ); end
+      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
+      # Creates a ForwardingRequest object.
+      sig {
+        params(params: T.any(::Stripe::Forwarding::Request::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Forwarding::Request)
+       }
+      def self.create(params = {}, opts = {}); end
+
+      # Lists all ForwardingRequest objects.
+      sig {
+        params(params: T.any(::Stripe::Forwarding::Request::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def self.list(params = {}, opts = {}); end
+    end
+  end
+end