stripe 13.6.0.pre.beta.1 → 14.0.0

data/rbi/stripe/resources/apple_pay_domain.rbi

@@ -25,32 +25,25 @@ module Stripe
     attr_reader :deleted
     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
       # Attribute for param field domain_name
-      sig { returns(String) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :domain_name
       # 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) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :ending_before
       # Specifies which fields in the response should be expanded.
-      sig { returns(T::Array[String]) }
+      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(Integer) }
+      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(String) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :starting_after
       sig {
-        params(domain_name: String, ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String).void
+        params(domain_name: T.nilable(String), ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), starting_after: T.nilable(String)).void
        }
       def initialize(
         domain_name: nil,
@@ -65,9 +58,9 @@ module Stripe
       sig { returns(String) }
       attr_accessor :domain_name
       # Specifies which fields in the response should be expanded.
-      sig { returns(T::Array[String]) }
+      sig { returns(T.nilable(T::Array[String])) }
       attr_accessor :expand
-      sig { params(domain_name: String, expand: T::Array[String]).void }
+      sig { params(domain_name: String, expand: T.nilable(T::Array[String])).void }
       def initialize(domain_name: nil, expand: nil); end
     end
     # Create an apple pay domain.

data/rbi/stripe/resources/application_fee.rbi

@@ -11,7 +11,7 @@ module Stripe
       # Payout ID that created this application fee.
       sig { returns(String) }
       attr_reader :payout
-      # Type of object that created the application fee, either `charge` or `payout`.
+      # Type of object that created the application fee.
       sig { returns(String) }
       attr_reader :type
     end
@@ -63,40 +63,42 @@ module Stripe
     class ListParams < Stripe::RequestParams
       class Created < Stripe::RequestParams
         # Minimum value to filter by (exclusive)
-        sig { returns(Integer) }
+        sig { returns(T.nilable(Integer)) }
         attr_accessor :gt
         # Minimum value to filter by (inclusive)
-        sig { returns(Integer) }
+        sig { returns(T.nilable(Integer)) }
         attr_accessor :gte
         # Maximum value to filter by (exclusive)
-        sig { returns(Integer) }
+        sig { returns(T.nilable(Integer)) }
         attr_accessor :lt
         # Maximum value to filter by (inclusive)
-        sig { returns(Integer) }
+        sig { returns(T.nilable(Integer)) }
         attr_accessor :lte
-        sig { params(gt: Integer, gte: Integer, lt: Integer, lte: Integer).void }
+        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 application fees for the charge specified by this charge ID.
-      sig { returns(String) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :charge
       # Only return applications fees that were created during the given date interval.
-      sig { returns(T.any(::Stripe::ApplicationFee::ListParams::Created, Integer)) }
+      sig { returns(T.nilable(T.any(::Stripe::ApplicationFee::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(String) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :ending_before
       # Specifies which fields in the response should be expanded.
-      sig { returns(T::Array[String]) }
+      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(Integer) }
+      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(String) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :starting_after
       sig {
-        params(charge: String, created: T.any(::Stripe::ApplicationFee::ListParams::Created, Integer), ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String).void
+        params(charge: T.nilable(String), created: T.nilable(T.any(::Stripe::ApplicationFee::ListParams::Created, Integer)), ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), starting_after: T.nilable(String)).void
        }
       def initialize(
         charge: nil,
@@ -107,13 +109,6 @@ module Stripe
         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 application fees you've previously collected. The application fees are returned in sorted order, with the most recent fees appearing first.
     sig {
       params(params: T.any(::Stripe::ApplicationFee::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)

data/rbi/stripe/resources/apps/secret.rbi

@@ -55,28 +55,28 @@ module Stripe
           sig { returns(String) }
           attr_accessor :type
           # The user ID. This field is required if `type` is set to `user`, and should not be provided if `type` is set to `account`.
-          sig { returns(String) }
+          sig { returns(T.nilable(String)) }
           attr_accessor :user
-          sig { params(type: String, user: String).void }
+          sig { params(type: String, user: T.nilable(String)).void }
           def initialize(type: nil, user: nil); end
         end
         # 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) }
+        sig { returns(T.nilable(String)) }
         attr_accessor :ending_before
         # Specifies which fields in the response should be expanded.
-        sig { returns(T::Array[String]) }
+        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(Integer) }
+        sig { returns(T.nilable(Integer)) }
         attr_accessor :limit
         # Specifies the scoping of the secret. Requests originating from UI extensions can only access account-scoped secrets or secrets scoped to their own user.
         sig { returns(::Stripe::Apps::Secret::ListParams::Scope) }
         attr_accessor :scope
         # 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) }
+        sig { returns(T.nilable(String)) }
         attr_accessor :starting_after
         sig {
-          params(ending_before: String, expand: T::Array[String], limit: Integer, scope: ::Stripe::Apps::Secret::ListParams::Scope, starting_after: String).void
+          params(ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), scope: ::Stripe::Apps::Secret::ListParams::Scope, starting_after: T.nilable(String)).void
          }
         def initialize(
           ending_before: nil,
@@ -92,16 +92,16 @@ module Stripe
           sig { returns(String) }
           attr_accessor :type
           # The user ID. This field is required if `type` is set to `user`, and should not be provided if `type` is set to `account`.
-          sig { returns(String) }
+          sig { returns(T.nilable(String)) }
           attr_accessor :user
-          sig { params(type: String, user: String).void }
+          sig { params(type: String, user: T.nilable(String)).void }
           def initialize(type: nil, user: nil); end
         end
         # Specifies which fields in the response should be expanded.
-        sig { returns(T::Array[String]) }
+        sig { returns(T.nilable(T::Array[String])) }
         attr_accessor :expand
         # The Unix timestamp for the expiry time of the secret, after which the secret deletes.
-        sig { returns(Integer) }
+        sig { returns(T.nilable(Integer)) }
         attr_accessor :expires_at
         # A name for the secret that's unique within the scope.
         sig { returns(String) }
@@ -113,7 +113,7 @@ module Stripe
         sig { returns(::Stripe::Apps::Secret::CreateParams::Scope) }
         attr_accessor :scope
         sig {
-          params(expand: T::Array[String], expires_at: Integer, name: String, payload: String, scope: ::Stripe::Apps::Secret::CreateParams::Scope).void
+          params(expand: T.nilable(T::Array[String]), expires_at: T.nilable(Integer), name: String, payload: String, scope: ::Stripe::Apps::Secret::CreateParams::Scope).void
          }
         def initialize(expand: nil, expires_at: nil, name: nil, payload: nil, scope: nil); end
       end
@@ -123,13 +123,13 @@ module Stripe
           sig { returns(String) }
           attr_accessor :type
           # The user ID. This field is required if `type` is set to `user`, and should not be provided if `type` is set to `account`.
-          sig { returns(String) }
+          sig { returns(T.nilable(String)) }
           attr_accessor :user
-          sig { params(type: String, user: String).void }
+          sig { params(type: String, user: T.nilable(String)).void }
           def initialize(type: nil, user: nil); end
         end
         # Specifies which fields in the response should be expanded.
-        sig { returns(T::Array[String]) }
+        sig { returns(T.nilable(T::Array[String])) }
         attr_accessor :expand
         # A name for the secret that's unique within the scope.
         sig { returns(String) }
@@ -138,7 +138,7 @@ module Stripe
         sig { returns(::Stripe::Apps::Secret::FindParams::Scope) }
         attr_accessor :scope
         sig {
-          params(expand: T::Array[String], name: String, scope: ::Stripe::Apps::Secret::FindParams::Scope).void
+          params(expand: T.nilable(T::Array[String]), name: String, scope: ::Stripe::Apps::Secret::FindParams::Scope).void
          }
         def initialize(expand: nil, name: nil, scope: nil); end
       end
@@ -148,13 +148,13 @@ module Stripe
           sig { returns(String) }
           attr_accessor :type
           # The user ID. This field is required if `type` is set to `user`, and should not be provided if `type` is set to `account`.
-          sig { returns(String) }
+          sig { returns(T.nilable(String)) }
           attr_accessor :user
-          sig { params(type: String, user: String).void }
+          sig { params(type: String, user: T.nilable(String)).void }
           def initialize(type: nil, user: nil); end
         end
         # Specifies which fields in the response should be expanded.
-        sig { returns(T::Array[String]) }
+        sig { returns(T.nilable(T::Array[String])) }
         attr_accessor :expand
         # A name for the secret that's unique within the scope.
         sig { returns(String) }
@@ -163,7 +163,7 @@ module Stripe
         sig { returns(::Stripe::Apps::Secret::DeleteWhereParams::Scope) }
         attr_accessor :scope
         sig {
-          params(expand: T::Array[String], name: String, scope: ::Stripe::Apps::Secret::DeleteWhereParams::Scope).void
+          params(expand: T.nilable(T::Array[String]), name: String, scope: ::Stripe::Apps::Secret::DeleteWhereParams::Scope).void
          }
         def initialize(expand: nil, name: nil, scope: nil); end
       end

data/rbi/stripe/resources/balance.rbi

@@ -176,12 +176,5 @@ module Stripe
     # Funds that aren't available in the balance yet. You can find the pending balance for each currency and each payment type in the `source_types` property.
     sig { returns(T::Array[Pending]) }
     attr_reader :pending
-    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
   end
 end

data/rbi/stripe/resources/balance_transaction.rbi

@@ -69,55 +69,57 @@ module Stripe
     # The transaction's net funds status in the Stripe balance, which are either `available` or `pending`.
     sig { returns(String) }
     attr_reader :status
-    # Transaction type: `adjustment`, `advance`, `advance_funding`, `anticipation_repayment`, `application_fee`, `application_fee_refund`, `charge`, `climate_order_purchase`, `climate_order_refund`, `connect_collection_transfer`, `contribution`, `issuing_authorization_hold`, `issuing_authorization_release`, `issuing_dispute`, `issuing_transaction`, `obligation_outbound`, `obligation_reversal_inbound`, `payment`, `payment_failure_refund`, `payment_network_reserve_hold`, `payment_network_reserve_release`, `payment_refund`, `payment_reversal`, `payment_unreconciled`, `payout`, `payout_cancel`, `payout_failure`, `payout_minimum_balance_hold`, `payout_minimum_balance_release`, `refund`, `refund_failure`, `reserve_transaction`, `reserved_funds`, `stripe_fee`, `stripe_fx_fee`, `tax_fee`, `topup`, `topup_reversal`, `transfer`, `transfer_cancel`, `transfer_failure`, or `transfer_refund`. Learn more about [balance transaction types and what they represent](https://stripe.com/docs/reports/balance-transaction-types). To classify transactions for accounting purposes, consider `reporting_category` instead.
+    # Transaction type: `adjustment`, `advance`, `advance_funding`, `anticipation_repayment`, `application_fee`, `application_fee_refund`, `charge`, `climate_order_purchase`, `climate_order_refund`, `connect_collection_transfer`, `contribution`, `issuing_authorization_hold`, `issuing_authorization_release`, `issuing_dispute`, `issuing_transaction`, `obligation_outbound`, `obligation_reversal_inbound`, `payment`, `payment_failure_refund`, `payment_network_reserve_hold`, `payment_network_reserve_release`, `payment_refund`, `payment_reversal`, `payment_unreconciled`, `payout`, `payout_cancel`, `payout_failure`, `payout_minimum_balance_hold`, `payout_minimum_balance_release`, `refund`, `refund_failure`, `reserve_transaction`, `reserved_funds`, `stripe_fee`, `stripe_fx_fee`, `stripe_balance_payment_debit`, `stripe_balance_payment_debit_reversal`, `tax_fee`, `topup`, `topup_reversal`, `transfer`, `transfer_cancel`, `transfer_failure`, or `transfer_refund`. Learn more about [balance transaction types and what they represent](https://stripe.com/docs/reports/balance-transaction-types). To classify transactions for accounting purposes, consider `reporting_category` instead.
     sig { returns(String) }
     attr_reader :type
     class ListParams < Stripe::RequestParams
       class Created < Stripe::RequestParams
         # Minimum value to filter by (exclusive)
-        sig { returns(Integer) }
+        sig { returns(T.nilable(Integer)) }
         attr_accessor :gt
         # Minimum value to filter by (inclusive)
-        sig { returns(Integer) }
+        sig { returns(T.nilable(Integer)) }
         attr_accessor :gte
         # Maximum value to filter by (exclusive)
-        sig { returns(Integer) }
+        sig { returns(T.nilable(Integer)) }
         attr_accessor :lt
         # Maximum value to filter by (inclusive)
-        sig { returns(Integer) }
+        sig { returns(T.nilable(Integer)) }
         attr_accessor :lte
-        sig { params(gt: Integer, gte: Integer, lt: Integer, lte: Integer).void }
+        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 transactions that were created during the given date interval.
-      sig { returns(T.any(::Stripe::BalanceTransaction::ListParams::Created, Integer)) }
+      sig { returns(T.nilable(T.any(::Stripe::BalanceTransaction::ListParams::Created, Integer))) }
       attr_accessor :created
       # Only return transactions in a certain currency. 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) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :currency
       # 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) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :ending_before
       # Specifies which fields in the response should be expanded.
-      sig { returns(T::Array[String]) }
+      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(Integer) }
+      sig { returns(T.nilable(Integer)) }
       attr_accessor :limit
       # For automatic Stripe payouts only, only returns transactions that were paid out on the specified payout ID.
-      sig { returns(String) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :payout
       # Only returns the original transaction.
-      sig { returns(String) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :source
       # 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) }
+      sig { returns(T.nilable(String)) }
       attr_accessor :starting_after
-      # Only returns transactions of the given type. One of: `adjustment`, `advance`, `advance_funding`, `anticipation_repayment`, `application_fee`, `application_fee_refund`, `charge`, `climate_order_purchase`, `climate_order_refund`, `connect_collection_transfer`, `contribution`, `issuing_authorization_hold`, `issuing_authorization_release`, `issuing_dispute`, `issuing_transaction`, `obligation_outbound`, `obligation_reversal_inbound`, `payment`, `payment_failure_refund`, `payment_network_reserve_hold`, `payment_network_reserve_release`, `payment_refund`, `payment_reversal`, `payment_unreconciled`, `payout`, `payout_cancel`, `payout_failure`, `payout_minimum_balance_hold`, `payout_minimum_balance_release`, `refund`, `refund_failure`, `reserve_transaction`, `reserved_funds`, `stripe_fee`, `stripe_fx_fee`, `tax_fee`, `topup`, `topup_reversal`, `transfer`, `transfer_cancel`, `transfer_failure`, or `transfer_refund`.
-      sig { returns(String) }
+      # Only returns transactions of the given type. One of: `adjustment`, `advance`, `advance_funding`, `anticipation_repayment`, `application_fee`, `application_fee_refund`, `charge`, `climate_order_purchase`, `climate_order_refund`, `connect_collection_transfer`, `contribution`, `issuing_authorization_hold`, `issuing_authorization_release`, `issuing_dispute`, `issuing_transaction`, `obligation_outbound`, `obligation_reversal_inbound`, `payment`, `payment_failure_refund`, `payment_network_reserve_hold`, `payment_network_reserve_release`, `payment_refund`, `payment_reversal`, `payment_unreconciled`, `payout`, `payout_cancel`, `payout_failure`, `payout_minimum_balance_hold`, `payout_minimum_balance_release`, `refund`, `refund_failure`, `reserve_transaction`, `reserved_funds`, `stripe_fee`, `stripe_fx_fee`, `stripe_balance_payment_debit`, `stripe_balance_payment_debit_reversal`, `tax_fee`, `topup`, `topup_reversal`, `transfer`, `transfer_cancel`, `transfer_failure`, or `transfer_refund`.
+      sig { returns(T.nilable(String)) }
       attr_accessor :type
       sig {
-        params(created: T.any(::Stripe::BalanceTransaction::ListParams::Created, Integer), currency: String, ending_before: String, expand: T::Array[String], limit: Integer, payout: String, source: String, starting_after: String, type: String).void
+        params(created: T.nilable(T.any(::Stripe::BalanceTransaction::ListParams::Created, Integer)), currency: T.nilable(String), ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), payout: T.nilable(String), source: T.nilable(String), starting_after: T.nilable(String), type: T.nilable(String)).void
        }
       def initialize(
         created: nil,
@@ -131,13 +133,6 @@ module Stripe
         type: 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 transactions that have contributed to the Stripe account balance (e.g., charges, transfers, and so forth). The transactions are returned in sorted order, with the most recent transactions appearing first.
     #
     # Note that this endpoint was previously called “Balance history” and used the path /v1/balance/history.

data/rbi/stripe/resources/bank_account.rbi

@@ -61,7 +61,7 @@ module Stripe
       sig { returns(T.nilable(T::Array[String])) }
       attr_reader :pending_verification
     end
-    # The ID of the account that the bank account is associated with.
+    # The account this bank account belongs to. Only applicable on Accounts (not customers or recipients) This property is only available when returned as an [External Account](/api/external_account_bank_accounts/object) where [controller.is_controller](/api/accounts/object#account_object-controller-is_controller) is `true`.
     sig { returns(T.nilable(T.any(String, Stripe::Account))) }
     attr_reader :account
     # The name of the person or business that owns the bank account.

data/rbi/stripe/resources/billing/alert.rbi

@@ -51,25 +51,25 @@ module Stripe
       attr_reader :usage_threshold
       class ListParams < Stripe::RequestParams
         # Filter results to only include this type of alert.
-        sig { returns(String) }
+        sig { returns(T.nilable(String)) }
         attr_accessor :alert_type
         # 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) }
+        sig { returns(T.nilable(String)) }
         attr_accessor :ending_before
         # Specifies which fields in the response should be expanded.
-        sig { returns(T::Array[String]) }
+        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(Integer) }
+        sig { returns(T.nilable(Integer)) }
         attr_accessor :limit
         # Filter results to only include alerts with the given meter.
-        sig { returns(String) }
+        sig { returns(T.nilable(String)) }
         attr_accessor :meter
         # 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) }
+        sig { returns(T.nilable(String)) }
         attr_accessor :starting_after
         sig {
-          params(alert_type: String, ending_before: String, expand: T::Array[String], limit: Integer, meter: String, starting_after: String).void
+          params(alert_type: T.nilable(String), ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), meter: T.nilable(String), starting_after: T.nilable(String)).void
          }
         def initialize(
           alert_type: nil,
@@ -84,28 +84,30 @@ module Stripe
         class UsageThreshold < Stripe::RequestParams
           class Filter < Stripe::RequestParams
             # Limit the scope to this usage alert only to this customer.
-            sig { returns(String) }
+            sig { returns(T.nilable(String)) }
             attr_accessor :customer
             # What type of filter is being applied to this usage alert.
             sig { returns(String) }
             attr_accessor :type
-            sig { params(customer: String, type: String).void }
+            sig { params(customer: T.nilable(String), type: String).void }
             def initialize(customer: nil, type: nil); end
           end
           # The filters allows limiting the scope of this usage alert. You can only specify up to one filter at this time.
-          sig { returns(T::Array[::Stripe::Billing::Alert::CreateParams::UsageThreshold::Filter]) }
+          sig {
+            returns(T.nilable(T::Array[::Stripe::Billing::Alert::CreateParams::UsageThreshold::Filter]))
+           }
           attr_accessor :filters
           # Defines at which value the alert will fire.
           sig { returns(Integer) }
           attr_accessor :gte
           # The [Billing Meter](/api/billing/meter) ID whose usage is monitored.
-          sig { returns(String) }
+          sig { returns(T.nilable(String)) }
           attr_accessor :meter
           # Whether the alert should only fire only once, or once per billing cycle.
           sig { returns(String) }
           attr_accessor :recurrence
           sig {
-            params(filters: T::Array[::Stripe::Billing::Alert::CreateParams::UsageThreshold::Filter], gte: Integer, meter: String, recurrence: String).void
+            params(filters: T.nilable(T::Array[::Stripe::Billing::Alert::CreateParams::UsageThreshold::Filter]), gte: Integer, meter: T.nilable(String), recurrence: String).void
            }
           def initialize(filters: nil, gte: nil, meter: nil, recurrence: nil); end
         end
@@ -113,45 +115,38 @@ module Stripe
         sig { returns(String) }
         attr_accessor :alert_type
         # Specifies which fields in the response should be expanded.
-        sig { returns(T::Array[String]) }
+        sig { returns(T.nilable(T::Array[String])) }
         attr_accessor :expand
         # The title of the alert.
         sig { returns(String) }
         attr_accessor :title
         # The configuration of the usage threshold.
-        sig { returns(::Stripe::Billing::Alert::CreateParams::UsageThreshold) }
+        sig { returns(T.nilable(::Stripe::Billing::Alert::CreateParams::UsageThreshold)) }
         attr_accessor :usage_threshold
         sig {
-          params(alert_type: String, expand: T::Array[String], title: String, usage_threshold: ::Stripe::Billing::Alert::CreateParams::UsageThreshold).void
+          params(alert_type: String, expand: T.nilable(T::Array[String]), title: String, usage_threshold: T.nilable(::Stripe::Billing::Alert::CreateParams::UsageThreshold)).void
          }
         def initialize(alert_type: nil, expand: nil, title: nil, usage_threshold: 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
       class ActivateParams < Stripe::RequestParams
         # Specifies which fields in the response should be expanded.
-        sig { returns(T::Array[String]) }
+        sig { returns(T.nilable(T::Array[String])) }
         attr_accessor :expand
-        sig { params(expand: T::Array[String]).void }
+        sig { params(expand: T.nilable(T::Array[String])).void }
         def initialize(expand: nil); end
       end
       class ArchiveParams < Stripe::RequestParams
         # Specifies which fields in the response should be expanded.
-        sig { returns(T::Array[String]) }
+        sig { returns(T.nilable(T::Array[String])) }
         attr_accessor :expand
-        sig { params(expand: T::Array[String]).void }
+        sig { params(expand: T.nilable(T::Array[String])).void }
         def initialize(expand: nil); end
       end
       class DeactivateParams < Stripe::RequestParams
         # Specifies which fields in the response should be expanded.
-        sig { returns(T::Array[String]) }
+        sig { returns(T.nilable(T::Array[String])) }
         attr_accessor :expand
-        sig { params(expand: T::Array[String]).void }
+        sig { params(expand: T.nilable(T::Array[String])).void }
         def initialize(expand: nil); end
       end
       # Reactivates this alert, allowing it to trigger again.

data/rbi/stripe/resources/billing/credit_balance_summary.rbi

@@ -58,59 +58,6 @@ module Stripe
       # String representing the object's type. Objects of the same type share the same value.
       sig { returns(String) }
       attr_reader :object
-      class RetrieveParams < Stripe::RequestParams
-        class Filter < Stripe::RequestParams
-          class ApplicabilityScope < Stripe::RequestParams
-            class Price < Stripe::RequestParams
-              # The price ID this credit grant should apply to.
-              sig { returns(String) }
-              attr_accessor :id
-              sig { params(id: String).void }
-              def initialize(id: nil); end
-            end
-            # The price type that credit grants can apply to. We currently only support the `metered` price type.
-            sig { returns(String) }
-            attr_accessor :price_type
-            # A list of prices that the credit grant can apply to. We currently only support the `metered` prices.
-            sig {
-              returns(T::Array[::Stripe::Billing::CreditBalanceSummary::RetrieveParams::Filter::ApplicabilityScope::Price])
-             }
-            attr_accessor :prices
-            sig {
-              params(price_type: String, prices: T::Array[::Stripe::Billing::CreditBalanceSummary::RetrieveParams::Filter::ApplicabilityScope::Price]).void
-             }
-            def initialize(price_type: nil, prices: nil); end
-          end
-          # The billing credit applicability scope for which to fetch credit balance summary.
-          sig {
-            returns(::Stripe::Billing::CreditBalanceSummary::RetrieveParams::Filter::ApplicabilityScope)
-           }
-          attr_accessor :applicability_scope
-          # The credit grant for which to fetch credit balance summary.
-          sig { returns(String) }
-          attr_accessor :credit_grant
-          # Specify the type of this filter.
-          sig { returns(String) }
-          attr_accessor :type
-          sig {
-            params(applicability_scope: ::Stripe::Billing::CreditBalanceSummary::RetrieveParams::Filter::ApplicabilityScope, credit_grant: String, type: String).void
-           }
-          def initialize(applicability_scope: nil, credit_grant: nil, type: nil); end
-        end
-        # The customer for which to fetch credit balance summary.
-        sig { returns(String) }
-        attr_accessor :customer
-        # Specifies which fields in the response should be expanded.
-        sig { returns(T::Array[String]) }
-        attr_accessor :expand
-        # The filter criteria for the credit balance summary.
-        sig { returns(::Stripe::Billing::CreditBalanceSummary::RetrieveParams::Filter) }
-        attr_accessor :filter
-        sig {
-          params(customer: String, expand: T::Array[String], filter: ::Stripe::Billing::CreditBalanceSummary::RetrieveParams::Filter).void
-         }
-        def initialize(customer: nil, expand: nil, filter: nil); end
-      end
     end
   end
 end

data/rbi/stripe/resources/billing/credit_balance_transaction.rbi

@@ -108,25 +108,25 @@ module Stripe
       attr_reader :type
       class ListParams < Stripe::RequestParams
         # The credit grant for which to fetch credit balance transactions.
-        sig { returns(String) }
+        sig { returns(T.nilable(String)) }
         attr_accessor :credit_grant
         # The customer for which to fetch credit balance transactions.
         sig { returns(String) }
         attr_accessor :customer
         # 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) }
+        sig { returns(T.nilable(String)) }
         attr_accessor :ending_before
         # Specifies which fields in the response should be expanded.
-        sig { returns(T::Array[String]) }
+        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(Integer) }
+        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(String) }
+        sig { returns(T.nilable(String)) }
         attr_accessor :starting_after
         sig {
-          params(credit_grant: String, customer: String, ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String).void
+          params(credit_grant: T.nilable(String), customer: String, ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), starting_after: T.nilable(String)).void
          }
         def initialize(
           credit_grant: nil,
@@ -137,13 +137,6 @@ module Stripe
           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
       # Retrieve a list of credit balance transactions.
       sig {
         params(params: T.any(::Stripe::Billing::CreditBalanceTransaction::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)