stripe 14.1.0.pre.beta.1 → 15.0.0

data/rbi/stripe/resources/file_link.rbi

@@ -0,0 +1,141 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  # To share the contents of a `File` object with non-Stripe users, you can
+  # create a `FileLink`. `FileLink`s contain a URL that you can use to
+  # retrieve the contents of the file without authentication.
+  class FileLink < APIResource
+    # Time at which the object was created. Measured in seconds since the Unix epoch.
+    sig { returns(Integer) }
+    attr_reader :created
+    # Returns if the link is already expired.
+    sig { returns(T::Boolean) }
+    attr_reader :expired
+    # Time that the link expires.
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :expires_at
+    # The file object this link points to.
+    sig { returns(T.any(String, Stripe::File)) }
+    attr_reader :file
+    # 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::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 publicly accessible URL to download the file.
+    sig { returns(T.nilable(String)) }
+    attr_reader :url
+    class ListParams < Stripe::RequestParams
+      class Created < Stripe::RequestParams
+        # Minimum value to filter by (exclusive)
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :gt
+        # Minimum value to filter by (inclusive)
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :gte
+        # Maximum value to filter by (exclusive)
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :lt
+        # Maximum value to filter by (inclusive)
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :lte
+        sig {
+          params(gt: T.nilable(Integer), gte: T.nilable(Integer), lt: T.nilable(Integer), lte: T.nilable(Integer)).void
+         }
+        def initialize(gt: nil, gte: nil, lt: nil, lte: nil); end
+      end
+      # Only return links that were created during the given date interval.
+      sig { returns(T.nilable(T.any(::Stripe::FileLink::ListParams::Created, Integer))) }
+      attr_accessor :created
+      # 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(T.nilable(String)) }
+      attr_accessor :ending_before
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :expand
+      # Filter links by their expiration status. By default, Stripe returns all links.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :expired
+      # Only return links for the given file.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :file
+      # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+      sig { returns(T.nilable(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(T.nilable(String)) }
+      attr_accessor :starting_after
+      sig {
+        params(created: T.nilable(T.any(::Stripe::FileLink::ListParams::Created, Integer)), ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), expired: T.nilable(T::Boolean), file: T.nilable(String), limit: T.nilable(Integer), starting_after: T.nilable(String)).void
+       }
+      def initialize(
+        created: nil,
+        ending_before: nil,
+        expand: nil,
+        expired: nil,
+        file: nil,
+        limit: nil,
+        starting_after: nil
+      ); end
+    end
+    class CreateParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :expand
+      # The link isn't usable after this future timestamp.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :expires_at
+      # The ID of the file. The file's `purpose` must be one of the following: `business_icon`, `business_logo`, `customer_signature`, `dispute_evidence`, `finance_report_run`, `financial_account_statement`, `identity_document_downloadable`, `issuing_regulatory_reporting`, `pci_document`, `selfie`, `sigma_scheduled_query`, `tax_document_user_upload`, or `terminal_reader_splashscreen`.
+      sig { returns(String) }
+      attr_accessor :file
+      # 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.nilable(T.nilable(T.any(String, T::Hash[String, String])))) }
+      attr_accessor :metadata
+      sig {
+        params(expand: T.nilable(T::Array[String]), expires_at: T.nilable(Integer), file: String, metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String])))).void
+       }
+      def initialize(expand: nil, expires_at: nil, file: nil, metadata: nil); end
+    end
+    class UpdateParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :expand
+      # A future timestamp after which the link will no longer be usable, or `now` to expire the link immediately.
+      sig { returns(T.nilable(T.nilable(T.any(String, T.any(String, Integer))))) }
+      attr_accessor :expires_at
+      # 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.nilable(T.nilable(T.any(String, T::Hash[String, String])))) }
+      attr_accessor :metadata
+      sig {
+        params(expand: T.nilable(T::Array[String]), expires_at: T.nilable(T.nilable(T.any(String, T.any(String, Integer)))), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String])))).void
+       }
+      def initialize(expand: nil, expires_at: nil, metadata: nil); end
+    end
+    # Creates a new file link object.
+    sig {
+      params(params: T.any(::Stripe::FileLink::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::FileLink)
+     }
+    def self.create(params = {}, opts = {}); end
+
+    # Returns a list of file links.
+    sig {
+      params(params: T.any(::Stripe::FileLink::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+     }
+    def self.list(params = {}, opts = {}); end
+
+    # Updates an existing file link object. Expired links can no longer be updated.
+    sig {
+      params(link: String, params: T.any(::Stripe::FileLink::UpdateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::FileLink)
+     }
+    def self.update(link, params = {}, opts = {}); end
+  end
+end

data/rbi/stripe/resources/financial_connections/account.rbi

@@ -0,0 +1,339 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module FinancialConnections
+    # A Financial Connections Account represents an account that exists outside of Stripe, to which you have been granted some degree of access.
+    class Account < 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 Balance < Stripe::StripeObject
+        class Cash < Stripe::StripeObject
+          # The funds available to the account holder. Typically this is the current balance after subtracting any outbound pending transactions and adding any inbound pending transactions.
+          #
+          # Each key is a three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase.
+          #
+          # Each value is a integer amount. A positive amount indicates money owed to the account holder. A negative amount indicates money owed by the account holder.
+          sig { returns(T.nilable(T::Hash[String, Integer])) }
+          attr_reader :available
+        end
+        class Credit < Stripe::StripeObject
+          # The credit that has been used by the account holder.
+          #
+          # Each key is a three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase.
+          #
+          # Each value is a integer amount. A positive amount indicates money owed to the account holder. A negative amount indicates money owed by the account holder.
+          sig { returns(T.nilable(T::Hash[String, Integer])) }
+          attr_reader :used
+        end
+        # The time that the external institution calculated this balance. Measured in seconds since the Unix epoch.
+        sig { returns(Integer) }
+        attr_reader :as_of
+        # Attribute for field cash
+        sig { returns(Cash) }
+        attr_reader :cash
+        # Attribute for field credit
+        sig { returns(Credit) }
+        attr_reader :credit
+        # The balances owed to (or by) the account holder, before subtracting any outbound pending transactions or adding any inbound pending transactions.
+        #
+        # Each key is a three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase.
+        #
+        # Each value is a integer amount. A positive amount indicates money owed to the account holder. A negative amount indicates money owed by the account holder.
+        sig { returns(T::Hash[String, Integer]) }
+        attr_reader :current
+        # The `type` of the balance. An additional hash is included on the balance with a name matching this value.
+        sig { returns(String) }
+        attr_reader :type
+      end
+      class BalanceRefresh < Stripe::StripeObject
+        # The time at which the last refresh attempt was initiated. Measured in seconds since the Unix epoch.
+        sig { returns(Integer) }
+        attr_reader :last_attempted_at
+        # Time at which the next balance refresh can be initiated. This value will be `null` when `status` is `pending`. Measured in seconds since the Unix epoch.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :next_refresh_available_at
+        # The status of the last refresh attempt.
+        sig { returns(String) }
+        attr_reader :status
+      end
+      class OwnershipRefresh < Stripe::StripeObject
+        # The time at which the last refresh attempt was initiated. Measured in seconds since the Unix epoch.
+        sig { returns(Integer) }
+        attr_reader :last_attempted_at
+        # Time at which the next ownership refresh can be initiated. This value will be `null` when `status` is `pending`. Measured in seconds since the Unix epoch.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :next_refresh_available_at
+        # The status of the last refresh attempt.
+        sig { returns(String) }
+        attr_reader :status
+      end
+      class TransactionRefresh < Stripe::StripeObject
+        # Unique identifier for the object.
+        sig { returns(String) }
+        attr_reader :id
+        # The time at which the last refresh attempt was initiated. Measured in seconds since the Unix epoch.
+        sig { returns(Integer) }
+        attr_reader :last_attempted_at
+        # Time at which the next transaction refresh can be initiated. This value will be `null` when `status` is `pending`. Measured in seconds since the Unix epoch.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :next_refresh_available_at
+        # The status of the last refresh attempt.
+        sig { returns(String) }
+        attr_reader :status
+      end
+      # The account holder that this account belongs to.
+      sig { returns(T.nilable(AccountHolder)) }
+      attr_reader :account_holder
+      # The most recent information about the account's balance.
+      sig { returns(T.nilable(Balance)) }
+      attr_reader :balance
+      # The state of the most recent attempt to refresh the account balance.
+      sig { returns(T.nilable(BalanceRefresh)) }
+      attr_reader :balance_refresh
+      # The type of the account. Account category is further divided in `subcategory`.
+      sig { returns(String) }
+      attr_reader :category
+      # Time at which the object was created. Measured in seconds since the Unix epoch.
+      sig { returns(Integer) }
+      attr_reader :created
+      # A human-readable name that has been assigned to this account, either by the account holder or by the institution.
+      sig { returns(T.nilable(String)) }
+      attr_reader :display_name
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_reader :id
+      # The name of the institution that holds this account.
+      sig { returns(String) }
+      attr_reader :institution_name
+      # The last 4 digits of the account number. If present, this will be 4 numeric characters.
+      sig { returns(T.nilable(String)) }
+      attr_reader :last4
+      # 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 most recent information about the account's owners.
+      sig { returns(T.nilable(T.any(String, Stripe::FinancialConnections::AccountOwnership))) }
+      attr_reader :ownership
+      # The state of the most recent attempt to refresh the account owners.
+      sig { returns(T.nilable(OwnershipRefresh)) }
+      attr_reader :ownership_refresh
+      # The list of permissions granted by this account.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :permissions
+      # The status of the link to the account.
+      sig { returns(String) }
+      attr_reader :status
+      # If `category` is `cash`, one of:
+      #
+      #  - `checking`
+      #  - `savings`
+      #  - `other`
+      #
+      # If `category` is `credit`, one of:
+      #
+      #  - `mortgage`
+      #  - `line_of_credit`
+      #  - `credit_card`
+      #  - `other`
+      #
+      # If `category` is `investment` or `other`, this will be `other`.
+      sig { returns(String) }
+      attr_reader :subcategory
+      # The list of data refresh subscriptions requested on this account.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :subscriptions
+      # The [PaymentMethod type](https://stripe.com/docs/api/payment_methods/object#payment_method_object-type)(s) that can be created from this account.
+      sig { returns(T::Array[String]) }
+      attr_reader :supported_payment_method_types
+      # The state of the most recent attempt to refresh the account transactions.
+      sig { returns(T.nilable(TransactionRefresh)) }
+      attr_reader :transaction_refresh
+      class ListParams < Stripe::RequestParams
+        class AccountHolder < Stripe::RequestParams
+          # The ID of the Stripe account whose accounts will be retrieved.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :account
+          # The ID of the Stripe customer whose accounts will be retrieved.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :customer
+          sig { params(account: T.nilable(String), customer: T.nilable(String)).void }
+          def initialize(account: nil, customer: nil); end
+        end
+        # If present, only return accounts that belong to the specified account holder. `account_holder[customer]` and `account_holder[account]` are mutually exclusive.
+        sig {
+          returns(T.nilable(::Stripe::FinancialConnections::Account::ListParams::AccountHolder))
+         }
+        attr_accessor :account_holder
+        # 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(T.nilable(String)) }
+        attr_accessor :ending_before
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T.nilable(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(T.nilable(Integer)) }
+        attr_accessor :limit
+        # If present, only return accounts that were collected as part of the given session.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :session
+        # 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(T.nilable(String)) }
+        attr_accessor :starting_after
+        sig {
+          params(account_holder: T.nilable(::Stripe::FinancialConnections::Account::ListParams::AccountHolder), ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), session: T.nilable(String), starting_after: T.nilable(String)).void
+         }
+        def initialize(
+          account_holder: nil,
+          ending_before: nil,
+          expand: nil,
+          limit: nil,
+          session: nil,
+          starting_after: nil
+        ); end
+      end
+      class ListOwnersParams < 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(T.nilable(String)) }
+        attr_accessor :ending_before
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T.nilable(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(T.nilable(Integer)) }
+        attr_accessor :limit
+        # The ID of the ownership object to fetch owners from.
+        sig { returns(String) }
+        attr_accessor :ownership
+        # 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(T.nilable(String)) }
+        attr_accessor :starting_after
+        sig {
+          params(ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), ownership: String, starting_after: T.nilable(String)).void
+         }
+        def initialize(
+          ending_before: nil,
+          expand: nil,
+          limit: nil,
+          ownership: nil,
+          starting_after: nil
+        ); end
+      end
+      class DisconnectParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :expand
+        sig { params(expand: T.nilable(T::Array[String])).void }
+        def initialize(expand: nil); end
+      end
+      class RefreshAccountParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :expand
+        # The list of account features that you would like to refresh.
+        sig { returns(T::Array[String]) }
+        attr_accessor :features
+        sig { params(expand: T.nilable(T::Array[String]), features: T::Array[String]).void }
+        def initialize(expand: nil, features: nil); end
+      end
+      class SubscribeParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :expand
+        # The list of account features to which you would like to subscribe.
+        sig { returns(T::Array[String]) }
+        attr_accessor :features
+        sig { params(expand: T.nilable(T::Array[String]), features: T::Array[String]).void }
+        def initialize(expand: nil, features: nil); end
+      end
+      class UnsubscribeParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :expand
+        # The list of account features from which you would like to unsubscribe.
+        sig { returns(T::Array[String]) }
+        attr_accessor :features
+        sig { params(expand: T.nilable(T::Array[String]), features: T::Array[String]).void }
+        def initialize(expand: nil, features: nil); end
+      end
+      # Disables your access to a Financial Connections Account. You will no longer be able to access data associated with the account (e.g. balances, transactions).
+      sig {
+        params(params: T.any(::Stripe::FinancialConnections::Account::DisconnectParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::FinancialConnections::Account)
+       }
+      def disconnect(params = {}, opts = {}); end
+
+      # Disables your access to a Financial Connections Account. You will no longer be able to access data associated with the account (e.g. balances, transactions).
+      sig {
+        params(account: String, params: T.any(::Stripe::FinancialConnections::Account::DisconnectParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::FinancialConnections::Account)
+       }
+      def self.disconnect(account, params = {}, opts = {}); end
+
+      # Returns a list of Financial Connections Account objects.
+      sig {
+        params(params: T.any(::Stripe::FinancialConnections::Account::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def self.list(params = {}, opts = {}); end
+
+      # Lists all owners for a given Account
+      sig {
+        params(params: T.any(::Stripe::FinancialConnections::Account::ListOwnersParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def list_owners(params = {}, opts = {}); end
+
+      # Lists all owners for a given Account
+      sig {
+        params(account: String, params: T.any(::Stripe::FinancialConnections::Account::ListOwnersParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def self.list_owners(account, params = {}, opts = {}); end
+
+      # Refreshes the data associated with a Financial Connections Account.
+      sig {
+        params(params: T.any(::Stripe::FinancialConnections::Account::RefreshAccountParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::FinancialConnections::Account)
+       }
+      def refresh_account(params = {}, opts = {}); end
+
+      # Refreshes the data associated with a Financial Connections Account.
+      sig {
+        params(account: String, params: T.any(::Stripe::FinancialConnections::Account::RefreshAccountParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::FinancialConnections::Account)
+       }
+      def self.refresh_account(account, params = {}, opts = {}); end
+
+      # Subscribes to periodic refreshes of data associated with a Financial Connections Account.
+      sig {
+        params(params: T.any(::Stripe::FinancialConnections::Account::SubscribeParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::FinancialConnections::Account)
+       }
+      def subscribe(params = {}, opts = {}); end
+
+      # Subscribes to periodic refreshes of data associated with a Financial Connections Account.
+      sig {
+        params(account: String, params: T.any(::Stripe::FinancialConnections::Account::SubscribeParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::FinancialConnections::Account)
+       }
+      def self.subscribe(account, params = {}, opts = {}); end
+
+      # Unsubscribes from periodic refreshes of data associated with a Financial Connections Account.
+      sig {
+        params(params: T.any(::Stripe::FinancialConnections::Account::UnsubscribeParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::FinancialConnections::Account)
+       }
+      def unsubscribe(params = {}, opts = {}); end
+
+      # Unsubscribes from periodic refreshes of data associated with a Financial Connections Account.
+      sig {
+        params(account: String, params: T.any(::Stripe::FinancialConnections::Account::UnsubscribeParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::FinancialConnections::Account)
+       }
+      def self.unsubscribe(account, params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/resources/financial_connections/account_owner.rbi

@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module FinancialConnections
+    # Describes an owner of an account.
+    class AccountOwner < StripeObject
+      # The email address of the owner.
+      sig { returns(T.nilable(String)) }
+      attr_reader :email
+      # Unique identifier for the object.
+      sig { returns(String) }
+      attr_reader :id
+      # The full name of the owner.
+      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
+      # The ownership object that this owner belongs to.
+      sig { returns(String) }
+      attr_reader :ownership
+      # The raw phone number of the owner.
+      sig { returns(T.nilable(String)) }
+      attr_reader :phone
+      # The raw physical address of the owner.
+      sig { returns(T.nilable(String)) }
+      attr_reader :raw_address
+      # The timestamp of the refresh that updated this owner.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :refreshed_at
+    end
+  end
+end

data/rbi/stripe/resources/financial_connections/account_ownership.rbi

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module FinancialConnections
+    # Describes a snapshot of the owners of an account at a particular point in time.
+    class AccountOwnership < StripeObject
+      # 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
+      # String representing the object's type. Objects of the same type share the same value.
+      sig { returns(String) }
+      attr_reader :object
+      # A paginated list of owners for this account.
+      sig { returns(Stripe::ListObject) }
+      attr_reader :owners
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# 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
+      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
+      # 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
+      # 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
+      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(T.nilable(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(T.nilable(String)) }
+          attr_accessor :customer
+          # Type of account holder to collect accounts for.
+          sig { returns(String) }
+          attr_accessor :type
+          sig { params(account: T.nilable(String), customer: T.nilable(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.nilable(T::Array[String])) }
+          attr_accessor :account_subcategories
+          # List of countries from which to collect accounts.
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_accessor :countries
+          sig {
+            params(account_subcategories: T.nilable(T::Array[String]), countries: T.nilable(T::Array[String])).void
+           }
+          def initialize(account_subcategories: nil, countries: 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.nilable(T::Array[String])) }
+        attr_accessor :expand
+        # Filters to restrict the kinds of accounts to collect.
+        sig { returns(T.nilable(::Stripe::FinancialConnections::Session::CreateParams::Filters)) }
+        attr_accessor :filters
+        # 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.nilable(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(T.nilable(String)) }
+        attr_accessor :return_url
+        sig {
+          params(account_holder: ::Stripe::FinancialConnections::Session::CreateParams::AccountHolder, expand: T.nilable(T::Array[String]), filters: T.nilable(::Stripe::FinancialConnections::Session::CreateParams::Filters), permissions: T::Array[String], prefetch: T.nilable(T::Array[String]), return_url: T.nilable(String)).void
+         }
+        def initialize(
+          account_holder: nil,
+          expand: nil,
+          filters: 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