stripe 13.6.0.pre.beta.1 → 14.0.0

data/rbi/stripe/services/apple_pay_domain_service.rbi

@@ -9,29 +9,29 @@ module Stripe
     end
     class RetrieveParams < 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 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,
@@ -46,9 +46,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/services/application_fee_refund_service.rbi

@@ -6,51 +6,53 @@ module Stripe
   class ApplicationFeeRefundService < StripeService
     class RetrieveParams < 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 UpdateParams < 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
       # 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])) }
+      sig { returns(T.nilable(T.nilable(T.any(String, T::Hash[String, String])))) }
       attr_accessor :metadata
-      sig { params(expand: T::Array[String], metadata: T.nilable(T::Hash[String, String])).void }
+      sig {
+        params(expand: T.nilable(T::Array[String]), metadata: T.nilable(T.nilable(T.any(String, T::Hash[String, String])))).void
+       }
       def initialize(expand: nil, metadata: nil); end
     end
     class ListParams < Stripe::RequestParams
       # A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
-      sig { returns(String) }
+      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(ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String).void
+        params(ending_before: T.nilable(String), expand: T.nilable(T::Array[String]), limit: T.nilable(Integer), starting_after: T.nilable(String)).void
        }
       def initialize(ending_before: nil, expand: nil, limit: nil, starting_after: nil); end
     end
     class CreateParams < Stripe::RequestParams
       # A positive integer, in _cents (or local equivalent)_, representing how much of this fee to refund. Can refund only up to the remaining unrefunded amount of the fee.
-      sig { returns(Integer) }
+      sig { returns(T.nilable(Integer)) }
       attr_accessor :amount
       # Specifies which fields in the response should be expanded.
-      sig { returns(T::Array[String]) }
+      sig { returns(T.nilable(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]) }
+      sig { returns(T.nilable(T::Hash[String, String])) }
       attr_accessor :metadata
       sig {
-        params(amount: Integer, expand: T::Array[String], metadata: T::Hash[String, String]).void
+        params(amount: T.nilable(Integer), expand: T.nilable(T::Array[String]), metadata: T.nilable(T::Hash[String, String])).void
        }
       def initialize(amount: nil, expand: nil, metadata: nil); end
     end

data/rbi/stripe/services/application_fee_service.rbi

@@ -8,40 +8,44 @@ 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::ApplicationFeeService::ListParams::Created, Integer)) }
+      sig {
+        returns(T.nilable(T.any(::Stripe::ApplicationFeeService::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::ApplicationFeeService::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::ApplicationFeeService::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,
@@ -54,9 +58,9 @@ module Stripe
     end
     class RetrieveParams < 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
     # 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.

data/rbi/stripe/services/apps/secret_service.rbi

@@ -11,28 +11,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::SecretService::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::SecretService::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::SecretService::ListParams::Scope, starting_after: T.nilable(String)).void
          }
         def initialize(
           ending_before: nil,
@@ -48,16 +48,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) }
@@ -69,7 +69,7 @@ module Stripe
         sig { returns(::Stripe::Apps::SecretService::CreateParams::Scope) }
         attr_accessor :scope
         sig {
-          params(expand: T::Array[String], expires_at: Integer, name: String, payload: String, scope: ::Stripe::Apps::SecretService::CreateParams::Scope).void
+          params(expand: T.nilable(T::Array[String]), expires_at: T.nilable(Integer), name: String, payload: String, scope: ::Stripe::Apps::SecretService::CreateParams::Scope).void
          }
         def initialize(expand: nil, expires_at: nil, name: nil, payload: nil, scope: nil); end
       end
@@ -79,13 +79,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) }
@@ -94,7 +94,7 @@ module Stripe
         sig { returns(::Stripe::Apps::SecretService::FindParams::Scope) }
         attr_accessor :scope
         sig {
-          params(expand: T::Array[String], name: String, scope: ::Stripe::Apps::SecretService::FindParams::Scope).void
+          params(expand: T.nilable(T::Array[String]), name: String, scope: ::Stripe::Apps::SecretService::FindParams::Scope).void
          }
         def initialize(expand: nil, name: nil, scope: nil); end
       end
@@ -104,13 +104,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) }
@@ -119,7 +119,7 @@ module Stripe
         sig { returns(::Stripe::Apps::SecretService::DeleteWhereParams::Scope) }
         attr_accessor :scope
         sig {
-          params(expand: T::Array[String], name: String, scope: ::Stripe::Apps::SecretService::DeleteWhereParams::Scope).void
+          params(expand: T.nilable(T::Array[String]), name: String, scope: ::Stripe::Apps::SecretService::DeleteWhereParams::Scope).void
          }
         def initialize(expand: nil, name: nil, scope: nil); end
       end

data/rbi/stripe/services/balance_service.rbi

@@ -6,9 +6,9 @@ module Stripe
   class BalanceService < StripeService
     class RetrieveParams < 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
     # Retrieves the current account balance, based on the authentication that was used to make the request.

data/rbi/stripe/services/balance_transaction_service.rbi

@@ -7,49 +7,53 @@ 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 transactions that were created during the given date interval.
-      sig { returns(T.any(::Stripe::BalanceTransactionService::ListParams::Created, Integer)) }
+      sig {
+        returns(T.nilable(T.any(::Stripe::BalanceTransactionService::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::BalanceTransactionService::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::BalanceTransactionService::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,
@@ -65,9 +69,9 @@ module Stripe
     end
     class RetrieveParams < 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
     # 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.

data/rbi/stripe/services/billing/alert_service.rbi

@@ -7,25 +7,25 @@ module Stripe
     class AlertService < StripeService
       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,
@@ -40,30 +40,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::AlertService::CreateParams::UsageThreshold::Filter])
+            returns(T.nilable(T::Array[::Stripe::Billing::AlertService::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::AlertService::CreateParams::UsageThreshold::Filter], gte: Integer, meter: String, recurrence: String).void
+            params(filters: T.nilable(T::Array[::Stripe::Billing::AlertService::CreateParams::UsageThreshold::Filter]), gte: Integer, meter: T.nilable(String), recurrence: String).void
            }
           def initialize(filters: nil, gte: nil, meter: nil, recurrence: nil); end
         end
@@ -71,45 +71,45 @@ 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::AlertService::CreateParams::UsageThreshold) }
+        sig { returns(T.nilable(::Stripe::Billing::AlertService::CreateParams::UsageThreshold)) }
         attr_accessor :usage_threshold
         sig {
-          params(alert_type: String, expand: T::Array[String], title: String, usage_threshold: ::Stripe::Billing::AlertService::CreateParams::UsageThreshold).void
+          params(alert_type: String, expand: T.nilable(T::Array[String]), title: String, usage_threshold: T.nilable(::Stripe::Billing::AlertService::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]) }
+        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 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/services/billing/credit_balance_summary_service.rbi

@@ -15,32 +15,32 @@ module Stripe
               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) }
+            # The price type that credit grants can apply to. We currently only support the `metered` price type. Cannot be used in combination with `prices`.
+            sig { returns(T.nilable(String)) }
             attr_accessor :price_type
-            # A list of prices that the credit grant can apply to. We currently only support the `metered` prices.
+            # A list of prices that the credit grant can apply to. We currently only support the `metered` prices. Cannot be used in combination with `price_type`.
             sig {
-              returns(T::Array[::Stripe::Billing::CreditBalanceSummaryService::RetrieveParams::Filter::ApplicabilityScope::Price])
+              returns(T.nilable(T::Array[::Stripe::Billing::CreditBalanceSummaryService::RetrieveParams::Filter::ApplicabilityScope::Price]))
              }
             attr_accessor :prices
             sig {
-              params(price_type: String, prices: T::Array[::Stripe::Billing::CreditBalanceSummaryService::RetrieveParams::Filter::ApplicabilityScope::Price]).void
+              params(price_type: T.nilable(String), prices: T.nilable(T::Array[::Stripe::Billing::CreditBalanceSummaryService::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::CreditBalanceSummaryService::RetrieveParams::Filter::ApplicabilityScope)
+            returns(T.nilable(::Stripe::Billing::CreditBalanceSummaryService::RetrieveParams::Filter::ApplicabilityScope))
            }
           attr_accessor :applicability_scope
           # The credit grant for which to fetch credit balance summary.
-          sig { returns(String) }
+          sig { returns(T.nilable(String)) }
           attr_accessor :credit_grant
           # Specify the type of this filter.
           sig { returns(String) }
           attr_accessor :type
           sig {
-            params(applicability_scope: ::Stripe::Billing::CreditBalanceSummaryService::RetrieveParams::Filter::ApplicabilityScope, credit_grant: String, type: String).void
+            params(applicability_scope: T.nilable(::Stripe::Billing::CreditBalanceSummaryService::RetrieveParams::Filter::ApplicabilityScope), credit_grant: T.nilable(String), type: String).void
            }
           def initialize(applicability_scope: nil, credit_grant: nil, type: nil); end
         end
@@ -48,13 +48,13 @@ module Stripe
         sig { returns(String) }
         attr_accessor :customer
         # 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 filter criteria for the credit balance summary.
         sig { returns(::Stripe::Billing::CreditBalanceSummaryService::RetrieveParams::Filter) }
         attr_accessor :filter
         sig {
-          params(customer: String, expand: T::Array[String], filter: ::Stripe::Billing::CreditBalanceSummaryService::RetrieveParams::Filter).void
+          params(customer: String, expand: T.nilable(T::Array[String]), filter: ::Stripe::Billing::CreditBalanceSummaryService::RetrieveParams::Filter).void
          }
         def initialize(customer: nil, expand: nil, filter: nil); end
       end

data/rbi/stripe/services/billing/credit_balance_transaction_service.rbi

@@ -7,25 +7,25 @@ module Stripe
     class CreditBalanceTransactionService < StripeService
       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,
@@ -38,9 +38,9 @@ module Stripe
       end
       class RetrieveParams < 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
       # Retrieve a list of credit balance transactions.