Merge upstream and update generated code for 2d2c88d14fb41f422c7b827e23c76009a47fbfb9 and 2025-08-27.basil

Author: stripe-openapi[bot]

OPENAPI_VERSION

@@ -1 +1 @@
-f4b80890ea17e89a543a77a389f29ca9be6fe615
+2d2c88d14fb41f422c7b827e23c76009a47fbfb9

rbi/stripe.rbi

@@ -10,50 +10,70 @@ module Stripe
   class AccountLink < APIResource
     # Time at which the object was created. Measured in seconds since the Unix epoch.
     sig { returns(Integer) }
-    attr_reader :created
+    def created; end
     # The timestamp at which this account link will expire.
     sig { returns(Integer) }
-    attr_reader :expires_at
+    def expires_at; end
     # String representing the object's type. Objects of the same type share the same value.
     sig { returns(String) }
-    attr_reader :object
+    def object; end
     # The URL for the account link.
     sig { returns(String) }
-    attr_reader :url
+    def url; end
     class CreateParams < Stripe::RequestParams
       class CollectionOptions < Stripe::RequestParams
         # Specifies whether the platform collects only currently_due requirements (`currently_due`) or both currently_due and eventually_due requirements (`eventually_due`). If you don't specify `collection_options`, the default value is `currently_due`.
         sig { returns(T.nilable(String)) }
-        attr_accessor :fields
+        def fields; end
+        sig { params(_fields: T.nilable(String)).returns(T.nilable(String)) }
+        def fields=(_fields); end
         # Specifies whether the platform collects future_requirements in addition to requirements in Connect Onboarding. The default value is `omit`.
         sig { returns(T.nilable(String)) }
-        attr_accessor :future_requirements
+        def future_requirements; end
+        sig { params(_future_requirements: T.nilable(String)).returns(T.nilable(String)) }
+        def future_requirements=(_future_requirements); end
         sig { params(fields: T.nilable(String), future_requirements: T.nilable(String)).void }
         def initialize(fields: nil, future_requirements: nil); end
       end
       # The identifier of the account to create an account link for.
       sig { returns(String) }
-      attr_accessor :account
+      def account; end
+      sig { params(_account: String).returns(String) }
+      def account=(_account); end
       # The collect parameter is deprecated. Use `collection_options` instead.
       sig { returns(T.nilable(String)) }
-      attr_accessor :collect
+      def collect; end
+      sig { params(_collect: T.nilable(String)).returns(T.nilable(String)) }
+      def collect=(_collect); end
       # Specifies the requirements that Stripe collects from connected accounts in the Connect Onboarding flow.
       sig { returns(T.nilable(::Stripe::AccountLink::CreateParams::CollectionOptions)) }
-      attr_accessor :collection_options
+      def collection_options; end
+      sig {
+        params(_collection_options: T.nilable(::Stripe::AccountLink::CreateParams::CollectionOptions)).returns(T.nilable(::Stripe::AccountLink::CreateParams::CollectionOptions))
+       }
+      def collection_options=(_collection_options); end
       # Specifies which fields in the response should be expanded.
       sig { returns(T.nilable(T::Array[String])) }
-      attr_accessor :expand
+      def expand; end
+      sig { params(_expand: T.nilable(T::Array[String])).returns(T.nilable(T::Array[String])) }
+      def expand=(_expand); end
       # The URL the user will be redirected to if the account link is expired, has been previously-visited, or is otherwise invalid. The URL you specify should attempt to generate a new account link with the same parameters used to create the original account link, then redirect the user to the new account link's URL so they can continue with Connect Onboarding. If a new account link cannot be generated or the redirect fails you should display a useful error to the user.
       sig { returns(T.nilable(String)) }
-      attr_accessor :refresh_url
+      def refresh_url; end
+      sig { params(_refresh_url: T.nilable(String)).returns(T.nilable(String)) }
+      def refresh_url=(_refresh_url); end
       # The URL that the user will be redirected to upon leaving or completing the linked flow.
       sig { returns(T.nilable(String)) }
-      attr_accessor :return_url
+      def return_url; end
+      sig { params(_return_url: T.nilable(String)).returns(T.nilable(String)) }
+      def return_url=(_return_url); end
       # The type of account link the user is requesting.
       #
       # You can create Account Links of type `account_update` only for connected accounts where your platform is responsible for collecting requirements, including Custom accounts. You can't create them for accounts that have access to a Stripe-hosted Dashboard. If you use [Connect embedded components](/connect/get-started-connect-embedded-components), you can include components that allow your connected accounts to update their own information. For an account without Stripe-hosted Dashboard access where Stripe is liable for negative balances, you must use embedded components.
       sig { returns(String) }
-      attr_accessor :type
+      def type; end
+      sig { params(_type: String).returns(String) }
+      def type=(_type); end
       sig {
         params(account: String, collect: T.nilable(String), collection_options: T.nilable(::Stripe::AccountLink::CreateParams::CollectionOptions), expand: T.nilable(T::Array[String]), refresh_url: T.nilable(String), return_url: T.nilable(String), type: String).void
        }

rbi/stripe/resources/account.rbi

@@ -10,71 +10,81 @@ module Stripe
     class Email < Stripe::StripeObject
       # Content of the email in plain text. The copy must match exactly the language that Stripe Compliance has approved for use.
       sig { returns(String) }
-      attr_reader :plain_text
+      def plain_text; end
       # Email address of the recipient.
       sig { returns(String) }
-      attr_reader :recipient
+      def recipient; end
       # Subject of the email.
       sig { returns(String) }
-      attr_reader :subject
+      def subject; end
     end
     class LinkedObjects < Stripe::StripeObject
       # Associated [Capability](https://stripe.com/docs/api/capabilities)
       sig { returns(T.nilable(String)) }
-      attr_reader :capability
+      def capability; end
       # Associated [Credit Underwriting Record](https://stripe.com/docs/api/issuing/credit_underwriting_record)
       sig { returns(T.nilable(String)) }
-      attr_reader :issuing_credit_underwriting_record
+      def issuing_credit_underwriting_record; end
       # Associated [Issuing Dispute](https://stripe.com/docs/api/issuing/disputes)
       sig { returns(T.nilable(String)) }
-      attr_reader :issuing_dispute
+      def issuing_dispute; end
     end
     # Time at which the object was created. Measured in seconds since the Unix epoch.
     sig { returns(Integer) }
-    attr_reader :created
+    def created; end
     # When present, the deadline for sending the notice to meet the relevant regulations.
     sig { returns(T.nilable(Integer)) }
-    attr_reader :deadline
+    def deadline; end
     # Information about the email when sent.
     sig { returns(T.nilable(Email)) }
-    attr_reader :email
+    def email; end
     # Unique identifier for the object.
     sig { returns(String) }
-    attr_reader :id
+    def id; end
     # Information about objects related to the notice.
     sig { returns(T.nilable(LinkedObjects)) }
-    attr_reader :linked_objects
+    def linked_objects; end
     # 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
+    def livemode; end
     # 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
+    def metadata; end
     # String representing the object's type. Objects of the same type share the same value.
     sig { returns(String) }
-    attr_reader :object
+    def object; end
     # Reason the notice is being sent. The reason determines what copy the notice must contain. See the [regulated customer notices](https://stripe.com/docs/issuing/compliance-us/issuing-regulated-customer-notices) guide. All reasons might not apply to your integration, and Stripe might add new reasons in the future, so we recommend an internal warning when you receive an unknown reason.
     sig { returns(String) }
-    attr_reader :reason
+    def reason; end
     # Date when the notice was sent. When absent, you must send the notice, update the content of the email and date when it was sent.
     sig { returns(T.nilable(Integer)) }
-    attr_reader :sent_at
+    def sent_at; 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(T.nilable(String)) }
-      attr_accessor :ending_before
+      def ending_before; end
+      sig { params(_ending_before: T.nilable(String)).returns(T.nilable(String)) }
+      def ending_before=(_ending_before); end
       # Specifies which fields in the response should be expanded.
       sig { returns(T.nilable(T::Array[String])) }
-      attr_accessor :expand
+      def expand; end
+      sig { params(_expand: T.nilable(T::Array[String])).returns(T.nilable(T::Array[String])) }
+      def expand=(_expand); end
       # 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
+      def limit; end
+      sig { params(_limit: T.nilable(Integer)).returns(T.nilable(Integer)) }
+      def limit=(_limit); end
       # Set to false to only return unsent AccountNotices.
       sig { returns(T.nilable(T::Boolean)) }
-      attr_accessor :sent
+      def sent; end
+      sig { params(_sent: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+      def sent=(_sent); end
       # 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
+      def starting_after; end
+      sig { params(_starting_after: T.nilable(String)).returns(T.nilable(String)) }
+      def starting_after=(_starting_after); end
       sig {
         params(ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), sent: T.nilable(T::Boolean), starting_after: T.nilable(String)).void
        }
@@ -90,28 +100,46 @@ module Stripe
       class Email < Stripe::RequestParams
         # Content of the email in plain text. The copy must match exactly the language that Stripe Compliance has approved for use.
         sig { returns(String) }
-        attr_accessor :plain_text
+        def plain_text; end
+        sig { params(_plain_text: String).returns(String) }
+        def plain_text=(_plain_text); end
         # Email address of the recipient.
         sig { returns(String) }
-        attr_accessor :recipient
+        def recipient; end
+        sig { params(_recipient: String).returns(String) }
+        def recipient=(_recipient); end
         # Subject of the email.
         sig { returns(String) }
-        attr_accessor :subject
+        def subject; end
+        sig { params(_subject: String).returns(String) }
+        def subject=(_subject); end
         sig { params(plain_text: String, recipient: String, subject: String).void }
         def initialize(plain_text: nil, recipient: nil, subject: nil); end
       end
       # Information about the email you sent.
       sig { returns(::Stripe::AccountNotice::UpdateParams::Email) }
-      attr_accessor :email
+      def email; end
+      sig {
+        params(_email: ::Stripe::AccountNotice::UpdateParams::Email).returns(::Stripe::AccountNotice::UpdateParams::Email)
+       }
+      def email=(_email); end
       # Specifies which fields in the response should be expanded.
       sig { returns(T.nilable(T::Array[String])) }
-      attr_accessor :expand
+      def expand; end
+      sig { params(_expand: T.nilable(T::Array[String])).returns(T.nilable(T::Array[String])) }
+      def expand=(_expand); end
       # 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::Hash[String, String])) }
-      attr_accessor :metadata
+      def metadata; end
+      sig {
+        params(_metadata: T.nilable(T::Hash[String, String])).returns(T.nilable(T::Hash[String, String]))
+       }
+      def metadata=(_metadata); end
       # Date when you sent the notice.
       sig { returns(Integer) }
-      attr_accessor :sent_at
+      def sent_at; end
+      sig { params(_sent_at: Integer).returns(Integer) }
+      def sent_at=(_sent_at); end
       sig {
         params(email: ::Stripe::AccountNotice::UpdateParams::Email, expand: T.nilable(T::Array[String]), metadata: T.nilable(T::Hash[String, String]), sent_at: Integer).void
        }