stripe 13.3.0 → 13.4.0.pre.beta.1

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

@@ -0,0 +1,172 @@
+# 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

data/rbi/stripe/services/billing/credit_balance_summary_service.rbi

@@ -0,0 +1,61 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Billing
+    class CreditBalanceSummaryService < StripeService
+      class RetrieveParams < Stripe::RequestParams
+        class Filter < Stripe::RequestParams
+          class ApplicabilityScope < Stripe::RequestParams
+            # The price type that credit grants can apply to. We currently only support the `metered` price type.
+            sig { returns(String) }
+            attr_accessor :price_type
+
+            sig { params(price_type: String).void }
+            def initialize(price_type: nil); end
+          end
+          # The billing credit applicability scope for which to fetch credit balance summary.
+          sig {
+            returns(::Stripe::Billing::CreditBalanceSummaryService::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::CreditBalanceSummaryService::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::CreditBalanceSummaryService::RetrieveParams::Filter) }
+        attr_accessor :filter
+
+        sig {
+          params(customer: String, expand: T::Array[String], filter: ::Stripe::Billing::CreditBalanceSummaryService::RetrieveParams::Filter).void
+         }
+        def initialize(customer: nil, expand: nil, filter: nil); end
+      end
+      # Retrieves the credit balance summary for a customer.
+      sig {
+        params(params: T.any(::Stripe::Billing::CreditBalanceSummaryService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::CreditBalanceSummary)
+       }
+      def retrieve(params = {}, opts = {}); end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Billing
+    class CreditBalanceTransactionService < StripeService
+      class ListParams < Stripe::RequestParams
+        # The credit grant for which to fetch credit balance transactions.
+        sig { returns(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) }
+        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(credit_grant: String, customer: String, ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String).void
+         }
+        def initialize(
+          credit_grant: nil,
+          customer: 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
+      # Retrieve a list of credit balance transactions.
+      sig {
+        params(params: T.any(::Stripe::Billing::CreditBalanceTransactionService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def list(params = {}, opts = {}); end
+
+      # Retrieves a credit balance transaction.
+      sig {
+        params(id: String, params: T.any(::Stripe::Billing::CreditBalanceTransactionService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::CreditBalanceTransaction)
+       }
+      def retrieve(id, params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/services/billing/credit_grant_service.rbi

@@ -0,0 +1,217 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Billing
+    class CreditGrantService < StripeService
+      class ListParams < Stripe::RequestParams
+        # Only return credit grants for this customer.
+        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) }
+        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(customer: String, ending_before: String, expand: T::Array[String], limit: Integer, starting_after: String).void
+         }
+        def initialize(
+          customer: nil,
+          ending_before: nil,
+          expand: nil,
+          limit: nil,
+          starting_after: nil
+        ); end
+      end
+      class CreateParams < Stripe::RequestParams
+        class Amount < Stripe::RequestParams
+          class Monetary < Stripe::RequestParams
+            # Three-letter [ISO code for the currency](https://stripe.com/docs/currencies) of the `value` parameter.
+            sig { returns(String) }
+            attr_accessor :currency
+
+            # A positive integer representing the amount of the credit grant.
+            sig { returns(Integer) }
+            attr_accessor :value
+
+            sig { params(currency: String, value: Integer).void }
+            def initialize(currency: nil, value: nil); end
+          end
+          # The monetary amount.
+          sig { returns(::Stripe::Billing::CreditGrantService::CreateParams::Amount::Monetary) }
+          attr_accessor :monetary
+
+          # Specify the type of this amount. We currently only support `monetary` billing credits.
+          sig { returns(String) }
+          attr_accessor :type
+
+          sig {
+            params(monetary: ::Stripe::Billing::CreditGrantService::CreateParams::Amount::Monetary, type: String).void
+           }
+          def initialize(monetary: nil, type: nil); end
+        end
+        class ApplicabilityConfig < Stripe::RequestParams
+          class Scope < Stripe::RequestParams
+            # The price type that credit grants can apply to. We currently only support the `metered` price type.
+            sig { returns(String) }
+            attr_accessor :price_type
+
+            sig { params(price_type: String).void }
+            def initialize(price_type: nil); end
+          end
+          # Specify the scope of this applicability config.
+          sig {
+            returns(::Stripe::Billing::CreditGrantService::CreateParams::ApplicabilityConfig::Scope)
+           }
+          attr_accessor :scope
+
+          sig {
+            params(scope: ::Stripe::Billing::CreditGrantService::CreateParams::ApplicabilityConfig::Scope).void
+           }
+          def initialize(scope: nil); end
+        end
+        # Amount of this credit grant.
+        sig { returns(::Stripe::Billing::CreditGrantService::CreateParams::Amount) }
+        attr_accessor :amount
+
+        # Configuration specifying what this credit grant applies to.
+        sig { returns(::Stripe::Billing::CreditGrantService::CreateParams::ApplicabilityConfig) }
+        attr_accessor :applicability_config
+
+        # The category of this credit grant.
+        sig { returns(String) }
+        attr_accessor :category
+
+        # ID of the customer to receive the billing credits.
+        sig { returns(String) }
+        attr_accessor :customer
+
+        # The time when the billing credits become effective-when they're eligible for use. It defaults to the current timestamp if not specified.
+        sig { returns(Integer) }
+        attr_accessor :effective_at
+
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+
+        # The time when the billing credits expire. If not specified, the billing credits don't expire.
+        sig { returns(Integer) }
+        attr_accessor :expires_at
+
+        # Set of key-value pairs that you can attach to an object. You can use this to store additional information about the object (for example, cost basis) in a structured format.
+        sig { returns(T::Hash[String, String]) }
+        attr_accessor :metadata
+
+        # A descriptive name shown in the Dashboard.
+        sig { returns(String) }
+        attr_accessor :name
+
+        sig {
+          params(amount: ::Stripe::Billing::CreditGrantService::CreateParams::Amount, applicability_config: ::Stripe::Billing::CreditGrantService::CreateParams::ApplicabilityConfig, category: String, customer: String, effective_at: Integer, expand: T::Array[String], expires_at: Integer, metadata: T::Hash[String, String], name: String).void
+         }
+        def initialize(
+          amount: nil,
+          applicability_config: nil,
+          category: nil,
+          customer: nil,
+          effective_at: nil,
+          expand: nil,
+          expires_at: nil,
+          metadata: nil,
+          name: 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 UpdateParams < Stripe::RequestParams
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+
+        # The time when the billing credits created by this credit grant expire. If set to empty, the billing credits never expire.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :expires_at
+
+        # Set of key-value pairs you can attach to an object. You can use this to store additional information about the object (for example, cost basis) in a structured format.
+        sig { returns(T::Hash[String, String]) }
+        attr_accessor :metadata
+
+        sig {
+          params(expand: T::Array[String], expires_at: T.nilable(Integer), metadata: T::Hash[String, String]).void
+         }
+        def initialize(expand: nil, expires_at: nil, metadata: nil); end
+      end
+      class ExpireParams < 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 VoidGrantParams < 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
+      # Creates a credit grant.
+      sig {
+        params(params: T.any(::Stripe::Billing::CreditGrantService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::CreditGrant)
+       }
+      def create(params = {}, opts = {}); end
+
+      # Expires a credit grant.
+      sig {
+        params(id: String, params: T.any(::Stripe::Billing::CreditGrantService::ExpireParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::CreditGrant)
+       }
+      def expire(id, params = {}, opts = {}); end
+
+      # Retrieve a list of credit grants.
+      sig {
+        params(params: T.any(::Stripe::Billing::CreditGrantService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def list(params = {}, opts = {}); end
+
+      # Retrieves a credit grant.
+      sig {
+        params(id: String, params: T.any(::Stripe::Billing::CreditGrantService::RetrieveParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::CreditGrant)
+       }
+      def retrieve(id, params = {}, opts = {}); end
+
+      # Updates a credit grant.
+      sig {
+        params(id: String, params: T.any(::Stripe::Billing::CreditGrantService::UpdateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::CreditGrant)
+       }
+      def update(id, params = {}, opts = {}); end
+
+      # Voids a credit grant.
+      sig {
+        params(id: String, params: T.any(::Stripe::Billing::CreditGrantService::VoidGrantParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::CreditGrant)
+       }
+      def void_grant(id, params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/services/billing/meter_event_adjustment_service.rbi

@@ -0,0 +1,45 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Billing
+    class MeterEventAdjustmentService < StripeService
+      class CreateParams < Stripe::RequestParams
+        class Cancel < Stripe::RequestParams
+          # Unique identifier for the event. You can only cancel events within 24 hours of Stripe receiving them.
+          sig { returns(String) }
+          attr_accessor :identifier
+
+          sig { params(identifier: String).void }
+          def initialize(identifier: nil); end
+        end
+        # Specifies which event to cancel.
+        sig { returns(::Stripe::Billing::MeterEventAdjustmentService::CreateParams::Cancel) }
+        attr_accessor :cancel
+
+        # The name of the meter event. Corresponds with the `event_name` field on a meter.
+        sig { returns(String) }
+        attr_accessor :event_name
+
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+
+        # Specifies whether to cancel a single event or a range of events for a time period. Time period cancellation is not supported yet.
+        sig { returns(String) }
+        attr_accessor :type
+
+        sig {
+          params(cancel: ::Stripe::Billing::MeterEventAdjustmentService::CreateParams::Cancel, event_name: String, expand: T::Array[String], type: String).void
+         }
+        def initialize(cancel: nil, event_name: nil, expand: nil, type: nil); end
+      end
+      # Creates a billing meter event adjustment.
+      sig {
+        params(params: T.any(::Stripe::Billing::MeterEventAdjustmentService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::MeterEventAdjustment)
+       }
+      def create(params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/services/billing/meter_event_service.rbi

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Billing
+    class MeterEventService < StripeService
+      class CreateParams < Stripe::RequestParams
+        # The name of the meter event. Corresponds with the `event_name` field on a meter.
+        sig { returns(String) }
+        attr_accessor :event_name
+
+        # Specifies which fields in the response should be expanded.
+        sig { returns(T::Array[String]) }
+        attr_accessor :expand
+
+        # A unique identifier for the event. If not provided, one is generated. We recommend using UUID-like identifiers. We will enforce uniqueness within a rolling period of at least 24 hours. The enforcement of uniqueness primarily addresses issues arising from accidental retries or other problems occurring within extremely brief time intervals. This approach helps prevent duplicate entries and ensures data integrity in high-frequency operations.
+        sig { returns(String) }
+        attr_accessor :identifier
+
+        # The payload of the event. This must contain the fields corresponding to a meter's `customer_mapping.event_payload_key` (default is `stripe_customer_id`) and `value_settings.event_payload_key` (default is `value`). Read more about the [payload](https://docs.stripe.com/billing/subscriptions/usage-based/recording-usage#payload-key-overrides).
+        sig { returns(T::Hash[String, String]) }
+        attr_accessor :payload
+
+        # The time of the event. Measured in seconds since the Unix epoch. Must be within the past 35 calendar days or up to 5 minutes in the future. Defaults to current timestamp if not specified.
+        sig { returns(Integer) }
+        attr_accessor :timestamp
+
+        sig {
+          params(event_name: String, expand: T::Array[String], identifier: String, payload: T::Hash[String, String], timestamp: Integer).void
+         }
+        def initialize(
+          event_name: nil,
+          expand: nil,
+          identifier: nil,
+          payload: nil,
+          timestamp: nil
+        ); end
+      end
+      # Creates a billing meter event.
+      sig {
+        params(params: T.any(::Stripe::Billing::MeterEventService::CreateParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::Billing::MeterEvent)
+       }
+      def create(params = {}, opts = {}); end
+    end
+  end
+end

data/rbi/stripe/services/billing/meter_event_summary_service.rbi

@@ -0,0 +1,62 @@
+# File generated from our OpenAPI spec
+# frozen_string_literal: true
+
+# typed: true
+module Stripe
+  module Billing
+    class MeterEventSummaryService < StripeService
+      class ListParams < Stripe::RequestParams
+        # The customer for which to fetch event summaries.
+        sig { returns(String) }
+        attr_accessor :customer
+
+        # The timestamp from when to stop aggregating meter events (exclusive). Must be aligned with minute boundaries.
+        sig { returns(Integer) }
+        attr_accessor :end_time
+
+        # 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
+
+        # The timestamp from when to start aggregating meter events (inclusive). Must be aligned with minute boundaries.
+        sig { returns(Integer) }
+        attr_accessor :start_time
+
+        # 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
+
+        # Specifies what granularity to use when generating event summaries. If not specified, a single event summary would be returned for the specified time range. For hourly granularity, start and end times must align with hour boundaries (e.g., 00:00, 01:00, ..., 23:00). For daily granularity, start and end times must align with UTC day boundaries (00:00 UTC).
+        sig { returns(String) }
+        attr_accessor :value_grouping_window
+
+        sig {
+          params(customer: String, end_time: Integer, ending_before: String, expand: T::Array[String], limit: Integer, start_time: Integer, starting_after: String, value_grouping_window: String).void
+         }
+        def initialize(
+          customer: nil,
+          end_time: nil,
+          ending_before: nil,
+          expand: nil,
+          limit: nil,
+          start_time: nil,
+          starting_after: nil,
+          value_grouping_window: nil
+        ); end
+      end
+      # Retrieve a list of billing meter event summaries.
+      sig {
+        params(id: String, params: T.any(::Stripe::Billing::MeterEventSummaryService::ListParams, T::Hash[T.untyped, T.untyped]), opts: T.untyped).returns(Stripe::ListObject)
+       }
+      def list(id, params = {}, opts = {}); end
+    end
+  end
+end