stripe 13.3.0 → 13.4.0.pre.beta.2

data/rbi/stripe/services/apple_pay_domain_service.rbi

@@ -0,0 +1,78 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  class ApplePayDomainService < StripeService
+    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) }
+      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) }
+      attr_accessor :ending_before
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T::Array[String]) }
+      attr_accessor :expand
+      # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+      sig { returns(Integer) }
+      attr_accessor :limit
+      # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
+      sig { returns(String) }
+      attr_accessor :starting_after
+      sig {
+        params(domain_name: String, ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String).void
+       }
+      def initialize(
+        domain_name: nil,
+        ending_before: nil,
+        expand: nil,
+        limit: nil,
+        starting_after: nil
+      ); end
+    end
+    class CreateParams < Stripe::RequestParams
+      # Attribute for param field domain_name
+      sig { returns(String) }
+      attr_accessor :domain_name
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T::Array[String]) }
+      attr_accessor :expand
+      sig { params(domain_name: String, expand: T::Array[String]).void }
+      def initialize(domain_name: nil, expand: nil); end
+    end
+    # Create an apple pay domain.
+    sig {
+      params(params: T.any(::Stripe::ApplePayDomainService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ApplePayDomain)
+     }
+    def create(params = {}, opts = {}); end
+
+    # Delete an apple pay domain.
+    sig {
+      params(domain: String, params: T.any(::Stripe::ApplePayDomainService::DeleteParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ApplePayDomain)
+     }
+    def delete(domain, params = {}, opts = {}); end
+
+    # List apple pay domains.
+    sig {
+      params(params: T.any(::Stripe::ApplePayDomainService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+     }
+    def list(params = {}, opts = {}); end
+
+    # Retrieve an apple pay domain.
+    sig {
+      params(domain: String, params: T.any(::Stripe::ApplePayDomainService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ApplePayDomain)
+     }
+    def retrieve(domain, params = {}, opts = {}); end
+  end
+end

data/rbi/stripe/services/application_fee_refund_service.rbi

@@ -0,0 +1,91 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  class ApplicationFeeRefundService < StripeService
+    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 UpdateParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T::Array[String]) }
+      attr_accessor :expand
+      # Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
+      sig { returns(T.nilable(T::Hash[String, String])) }
+      attr_accessor :metadata
+      sig { params(expand: T::Array[String], metadata: T.nilable(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) }
+      attr_accessor :ending_before
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T::Array[String]) }
+      attr_accessor :expand
+      # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+      sig { returns(Integer) }
+      attr_accessor :limit
+      # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
+      sig { returns(String) }
+      attr_accessor :starting_after
+      sig {
+        params(ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String).void
+       }
+      def initialize(ending_before: nil, expand: nil, limit: nil, starting_after: nil); end
+    end
+    class 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) }
+      attr_accessor :amount
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T::Array[String]) }
+      attr_accessor :expand
+      # Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
+      sig { returns(T::Hash[String, String]) }
+      attr_accessor :metadata
+      sig {
+        params(amount: Integer, expand: T::Array[String], metadata: T::Hash[String, String]).void
+       }
+      def initialize(amount: nil, expand: nil, metadata: nil); end
+    end
+    # Refunds an application fee that has previously been collected but not yet refunded.
+    # Funds will be refunded to the Stripe account from which the fee was originally collected.
+    #
+    # You can optionally refund only part of an application fee.
+    # You can do so multiple times, until the entire fee has been refunded.
+    #
+    # Once entirely refunded, an application fee can't be refunded again.
+    # This method will raise an error when called on an already-refunded application fee,
+    # or when trying to refund more money than is left on an application fee.
+    sig {
+      params(id: String, params: T.any(::Stripe::ApplicationFeeRefundService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ApplicationFeeRefund)
+     }
+    def create(id, params = {}, opts = {}); end
+
+    # You can see a list of the refunds belonging to a specific application fee. Note that the 10 most recent refunds are always available by default on the application fee object. If you need more than those 10, you can use this API method and the limit and starting_after parameters to page through additional refunds.
+    sig {
+      params(id: String, params: T.any(::Stripe::ApplicationFeeRefundService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+     }
+    def list(id, params = {}, opts = {}); end
+
+    # By default, you can see the 10 most recent refunds stored directly on the application fee object, but you can also retrieve details about a specific refund stored on the application fee.
+    sig {
+      params(fee: String, id: String, params: T.any(::Stripe::ApplicationFeeRefundService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ApplicationFeeRefund)
+     }
+    def retrieve(fee, id, params = {}, opts = {}); end
+
+    # Updates the specified application fee refund by setting the values of the parameters passed. Any parameters not provided will be left unchanged.
+    #
+    # This request only accepts metadata as an argument.
+    sig {
+      params(fee: String, id: String, params: T.any(::Stripe::ApplicationFeeRefundService::UpdateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ApplicationFeeRefund)
+     }
+    def update(fee, id, params = {}, opts = {}); end
+  end
+end

data/rbi/stripe/services/application_fee_service.rbi

@@ -0,0 +1,74 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  class ApplicationFeeService < StripeService
+    attr_reader :refunds
+    class ListParams < Stripe::RequestParams
+      class Created < Stripe::RequestParams
+        # Minimum value to filter by (exclusive)
+        sig { returns(Integer) }
+        attr_accessor :gt
+        # Minimum value to filter by (inclusive)
+        sig { returns(Integer) }
+        attr_accessor :gte
+        # Maximum value to filter by (exclusive)
+        sig { returns(Integer) }
+        attr_accessor :lt
+        # Maximum value to filter by (inclusive)
+        sig { returns(Integer) }
+        attr_accessor :lte
+        sig { params(gt: Integer, gte: Integer, lt: Integer, lte: Integer).void }
+        def initialize(gt: nil, gte: nil, lt: nil, lte: nil); end
+      end
+      # Only return application fees for the charge specified by this charge ID.
+      sig { returns(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)) }
+      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) }
+      attr_accessor :ending_before
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T::Array[String]) }
+      attr_accessor :expand
+      # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+      sig { returns(Integer) }
+      attr_accessor :limit
+      # A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
+      sig { returns(String) }
+      attr_accessor :starting_after
+      sig {
+        params(charge: String, created: T.any(::Stripe::ApplicationFeeService::ListParams::Created, Integer), ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String).void
+       }
+      def initialize(
+        charge: nil,
+        created: nil,
+        ending_before: nil,
+        expand: nil,
+        limit: nil,
+        starting_after: nil
+      ); end
+    end
+    class RetrieveParams < Stripe::RequestParams
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T::Array[String]) }
+      attr_accessor :expand
+      sig { params(expand: T::Array[String]).void }
+      def initialize(expand: nil); end
+    end
+    # Returns a list of 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::ApplicationFeeService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+     }
+    def list(params = {}, opts = {}); end
+
+    # Retrieves the details of an application fee that your account has collected. The same information is returned when refunding the application fee.
+    sig {
+      params(id: String, params: T.any(::Stripe::ApplicationFeeService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ApplicationFee)
+     }
+    def retrieve(id, params = {}, opts = {}); end
+  end
+end

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

@@ -0,0 +1,151 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Apps
+    class SecretService < StripeService
+      class ListParams < Stripe::RequestParams
+        class Scope < Stripe::RequestParams
+          # The secret scope type.
+          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) }
+          attr_accessor :user
+          sig { params(type: String, user: 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) }
+        attr_accessor :ending_before
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+        sig { returns(Integer) }
+        attr_accessor :limit
+        # 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) }
+        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
+         }
+        def initialize(
+          ending_before: nil,
+          expand: nil,
+          limit: nil,
+          scope: nil,
+          starting_after: nil
+        ); end
+      end
+      class CreateParams < Stripe::RequestParams
+        class Scope < Stripe::RequestParams
+          # The secret scope type.
+          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) }
+          attr_accessor :user
+          sig { params(type: String, user: String).void }
+          def initialize(type: nil, user: nil); end
+        end
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # The Unix timestamp for the expiry time of the secret, after which the secret deletes.
+        sig { returns(Integer) }
+        attr_accessor :expires_at
+        # A name for the secret that's unique within the scope.
+        sig { returns(String) }
+        attr_accessor :name
+        # The plaintext secret value to be stored.
+        sig { returns(String) }
+        attr_accessor :payload
+        # 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::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
+         }
+        def initialize(expand: nil, expires_at: nil, name: nil, payload: nil, scope: nil); end
+      end
+      class FindParams < Stripe::RequestParams
+        class Scope < Stripe::RequestParams
+          # The secret scope type.
+          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) }
+          attr_accessor :user
+          sig { params(type: String, user: String).void }
+          def initialize(type: nil, user: nil); end
+        end
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # A name for the secret that's unique within the scope.
+        sig { returns(String) }
+        attr_accessor :name
+        # 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::FindParams::Scope) }
+        attr_accessor :scope
+        sig {
+          params(expand: T::Array[String], name: String, scope: ::Stripe::Apps::SecretService::FindParams::Scope).void
+         }
+        def initialize(expand: nil, name: nil, scope: nil); end
+      end
+      class DeleteWhereParams < Stripe::RequestParams
+        class Scope < Stripe::RequestParams
+          # The secret scope type.
+          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) }
+          attr_accessor :user
+          sig { params(type: String, user: String).void }
+          def initialize(type: nil, user: nil); end
+        end
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # A name for the secret that's unique within the scope.
+        sig { returns(String) }
+        attr_accessor :name
+        # 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::DeleteWhereParams::Scope) }
+        attr_accessor :scope
+        sig {
+          params(expand: T::Array[String], name: String, scope: ::Stripe::Apps::SecretService::DeleteWhereParams::Scope).void
+         }
+        def initialize(expand: nil, name: nil, scope: nil); end
+      end
+      # Create or replace a secret in the secret store.
+      sig {
+        params(params: T.any(::Stripe::Apps::SecretService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Apps::Secret)
+       }
+      def create(params = {}, opts = {}); end
+
+      # Deletes a secret from the secret store by name and scope.
+      sig {
+        params(params: T.any(::Stripe::Apps::SecretService::DeleteWhereParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Apps::Secret)
+       }
+      def delete_where(params = {}, opts = {}); end
+
+      # Finds a secret in the secret store by name and scope.
+      sig {
+        params(params: T.any(::Stripe::Apps::SecretService::FindParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Apps::Secret)
+       }
+      def find(params = {}, opts = {}); end
+
+      # List all secrets stored on the given scope.
+      sig {
+        params(params: T.any(::Stripe::Apps::SecretService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def list(params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/services/apps_service.rbi

@@ -0,0 +1,9 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  class AppsService < StripeService
+    attr_reader :secrets
+  end
+end

data/rbi/stripe/services/balance_service.rbi

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  class BalanceService < StripeService
+    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
+    # Retrieves the current account balance, based on the authentication that was used to make the request.
+    #  For a sample request, see [Accounting for negative balances](https://stripe.com/docs/connect/account-balances#accounting-for-negative-balances).
+    sig {
+      params(params: T.any(::Stripe::BalanceService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Balance)
+     }
+    def retrieve(params = {}, opts = {}); end
+  end
+end

data/rbi/stripe/services/balance_transaction_service.rbi

@@ -0,0 +1,89 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  class BalanceTransactionService < StripeService
+    class ListParams < Stripe::RequestParams
+      class Created < Stripe::RequestParams
+        # Minimum value to filter by (exclusive)
+        sig { returns(Integer) }
+        attr_accessor :gt
+        # Minimum value to filter by (inclusive)
+        sig { returns(Integer) }
+        attr_accessor :gte
+        # Maximum value to filter by (exclusive)
+        sig { returns(Integer) }
+        attr_accessor :lt
+        # Maximum value to filter by (inclusive)
+        sig { returns(Integer) }
+        attr_accessor :lte
+        sig { params(gt: Integer, gte: Integer, lt: Integer, lte: Integer).void }
+        def initialize(gt: nil, gte: nil, lt: nil, lte: nil); end
+      end
+      # Only return transactions that were created during the given date interval.
+      sig { returns(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) }
+      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) }
+      attr_accessor :ending_before
+      # Specifies which fields in the response should be expanded.
+      sig { returns(T::Array[String]) }
+      attr_accessor :expand
+      # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+      sig { returns(Integer) }
+      attr_accessor :limit
+      # For automatic Stripe payouts only, only returns transactions that were paid out on the specified payout ID.
+      sig { returns(String) }
+      attr_accessor :payout
+      # Only returns the original transaction.
+      sig { returns(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) }
+      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) }
+      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
+       }
+      def initialize(
+        created: nil,
+        currency: nil,
+        ending_before: nil,
+        expand: nil,
+        limit: nil,
+        payout: nil,
+        source: nil,
+        starting_after: nil,
+        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.
+    sig {
+      params(params: T.any(::Stripe::BalanceTransactionService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+     }
+    def list(params = {}, opts = {}); end
+
+    # Retrieves the balance transaction with the given ID.
+    #
+    # Note that this endpoint previously used the path /v1/balance/history/:id.
+    sig {
+      params(id: String, params: T.any(::Stripe::BalanceTransactionService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::BalanceTransaction)
+     }
+    def retrieve(id, params = {}, opts = {}); end
+  end
+end

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

@@ -0,0 +1,152 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Billing
+    class AlertService < StripeService
+      class ListParams < Stripe::RequestParams
+        # Filter results to only include this type of alert.
+        sig { returns(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) }
+        attr_accessor :ending_before
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+        # A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
+        sig { returns(Integer) }
+        attr_accessor :limit
+        # Filter results to only include alerts with the given meter.
+        sig { returns(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) }
+        attr_accessor :starting_after
+        sig {
+          params(alert_type: String, ending_before: String, expand: T::Array[String], limit: Integer, meter: String, starting_after: String).void
+         }
+        def initialize(
+          alert_type: nil,
+          ending_before: nil,
+          expand: nil,
+          limit: nil,
+          meter: nil,
+          starting_after: nil
+        ); end
+      end
+      class CreateParams < Stripe::RequestParams
+        class UsageThreshold < Stripe::RequestParams
+          class Filter < Stripe::RequestParams
+            # Limit the scope to this usage alert only to this customer.
+            sig { returns(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 }
+            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])
+           }
+          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) }
+          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
+           }
+          def initialize(filters: nil, gte: nil, meter: nil, recurrence: nil); end
+        end
+        # The type of alert to create.
+        sig { returns(String) }
+        attr_accessor :alert_type
+        # Specifies which fields in the response should be expanded.
+        sig { returns(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) }
+        attr_accessor :usage_threshold
+        sig {
+          params(alert_type: String, expand: T::Array[String], title: String, usage_threshold: ::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]) }
+        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]) }
+        attr_accessor :expand
+        sig { params(expand: 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]) }
+        attr_accessor :expand
+        sig { params(expand: 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]) }
+        attr_accessor :expand
+        sig { params(expand: T::Array[String]).void }
+        def initialize(expand: nil); end
+      end
+      # Reactivates this alert, allowing it to trigger again.
+      sig {
+        params(id: String, params: T.any(::Stripe::Billing::AlertService::ActivateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::Alert)
+       }
+      def activate(id, params = {}, opts = {}); end
+
+      # Archives this alert, removing it from the list view and APIs. This is non-reversible.
+      sig {
+        params(id: String, params: T.any(::Stripe::Billing::AlertService::ArchiveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::Alert)
+       }
+      def archive(id, params = {}, opts = {}); end
+
+      # Creates a billing alert
+      sig {
+        params(params: T.any(::Stripe::Billing::AlertService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::Alert)
+       }
+      def create(params = {}, opts = {}); end
+
+      # Deactivates this alert, preventing it from triggering.
+      sig {
+        params(id: String, params: T.any(::Stripe::Billing::AlertService::DeactivateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::Alert)
+       }
+      def deactivate(id, params = {}, opts = {}); end
+
+      # Lists billing active and inactive alerts
+      sig {
+        params(params: T.any(::Stripe::Billing::AlertService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def list(params = {}, opts = {}); end
+
+      # Retrieves a billing alert given an ID
+      sig {
+        params(id: String, params: T.any(::Stripe::Billing::AlertService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::Alert)
+       }
+      def retrieve(id, params = {}, opts = {}); end
+    end
+  end
+end