orb-billing 0.11.0 → 1.0.0

data/rbi/orb/models/price_evaluate_preview_events_params.rbi

@@ -0,0 +1,411 @@
+# typed: strong
+
+module Orb
+  module Models
+    class PriceEvaluatePreviewEventsParams < Orb::Internal::Type::BaseModel
+      extend Orb::Internal::Type::RequestParameters::Converter
+      include Orb::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Orb::PriceEvaluatePreviewEventsParams, Orb::Internal::AnyHash)
+        end
+
+      # The exclusive upper bound for event timestamps
+      sig { returns(Time) }
+      attr_accessor :timeframe_end
+
+      # The inclusive lower bound for event timestamps
+      sig { returns(Time) }
+      attr_accessor :timeframe_start
+
+      # The ID of the customer to which this evaluation is scoped.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :customer_id
+
+      # List of preview events to use instead of actual usage data
+      sig do
+        returns(
+          T.nilable(T::Array[Orb::PriceEvaluatePreviewEventsParams::Event])
+        )
+      end
+      attr_reader :events
+
+      sig do
+        params(
+          events: T::Array[Orb::PriceEvaluatePreviewEventsParams::Event::OrHash]
+        ).void
+      end
+      attr_writer :events
+
+      # The external customer ID of the customer to which this evaluation is scoped.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :external_customer_id
+
+      # List of prices to evaluate (max 100)
+      sig do
+        returns(
+          T.nilable(
+            T::Array[Orb::PriceEvaluatePreviewEventsParams::PriceEvaluation]
+          )
+        )
+      end
+      attr_reader :price_evaluations
+
+      sig do
+        params(
+          price_evaluations:
+            T::Array[
+              Orb::PriceEvaluatePreviewEventsParams::PriceEvaluation::OrHash
+            ]
+        ).void
+      end
+      attr_writer :price_evaluations
+
+      sig do
+        params(
+          timeframe_end: Time,
+          timeframe_start: Time,
+          customer_id: T.nilable(String),
+          events:
+            T::Array[Orb::PriceEvaluatePreviewEventsParams::Event::OrHash],
+          external_customer_id: T.nilable(String),
+          price_evaluations:
+            T::Array[
+              Orb::PriceEvaluatePreviewEventsParams::PriceEvaluation::OrHash
+            ],
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The exclusive upper bound for event timestamps
+        timeframe_end:,
+        # The inclusive lower bound for event timestamps
+        timeframe_start:,
+        # The ID of the customer to which this evaluation is scoped.
+        customer_id: nil,
+        # List of preview events to use instead of actual usage data
+        events: nil,
+        # The external customer ID of the customer to which this evaluation is scoped.
+        external_customer_id: nil,
+        # List of prices to evaluate (max 100)
+        price_evaluations: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            timeframe_end: Time,
+            timeframe_start: Time,
+            customer_id: T.nilable(String),
+            events: T::Array[Orb::PriceEvaluatePreviewEventsParams::Event],
+            external_customer_id: T.nilable(String),
+            price_evaluations:
+              T::Array[Orb::PriceEvaluatePreviewEventsParams::PriceEvaluation],
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Event < Orb::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Orb::PriceEvaluatePreviewEventsParams::Event,
+              Orb::Internal::AnyHash
+            )
+          end
+
+        # A name to meaningfully identify the action or event type.
+        sig { returns(String) }
+        attr_accessor :event_name
+
+        # A dictionary of custom properties. Values in this dictionary must be numeric,
+        # boolean, or strings. Nested dictionaries are disallowed.
+        sig { returns(T::Hash[Symbol, T.anything]) }
+        attr_accessor :properties
+
+        # An ISO 8601 format date with no timezone offset (i.e. UTC). This should
+        # represent the time that usage was recorded, and is particularly important to
+        # attribute usage to a given billing period.
+        sig { returns(Time) }
+        attr_accessor :timestamp
+
+        # The Orb Customer identifier
+        sig { returns(T.nilable(String)) }
+        attr_accessor :customer_id
+
+        # An alias for the Orb customer, whose mapping is specified when creating the
+        # customer
+        sig { returns(T.nilable(String)) }
+        attr_accessor :external_customer_id
+
+        sig do
+          params(
+            event_name: String,
+            properties: T::Hash[Symbol, T.anything],
+            timestamp: Time,
+            customer_id: T.nilable(String),
+            external_customer_id: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A name to meaningfully identify the action or event type.
+          event_name:,
+          # A dictionary of custom properties. Values in this dictionary must be numeric,
+          # boolean, or strings. Nested dictionaries are disallowed.
+          properties:,
+          # An ISO 8601 format date with no timezone offset (i.e. UTC). This should
+          # represent the time that usage was recorded, and is particularly important to
+          # attribute usage to a given billing period.
+          timestamp:,
+          # The Orb Customer identifier
+          customer_id: nil,
+          # An alias for the Orb customer, whose mapping is specified when creating the
+          # customer
+          external_customer_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_name: String,
+              properties: T::Hash[Symbol, T.anything],
+              timestamp: Time,
+              customer_id: T.nilable(String),
+              external_customer_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class PriceEvaluation < Orb::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Orb::PriceEvaluatePreviewEventsParams::PriceEvaluation,
+              Orb::Internal::AnyHash
+            )
+          end
+
+        # A boolean
+        # [computed property](/extensibility/advanced-metrics#computed-properties) used to
+        # filter the underlying billable metric
+        sig { returns(T.nilable(String)) }
+        attr_accessor :filter
+
+        # Properties (or
+        # [computed properties](/extensibility/advanced-metrics#computed-properties)) used
+        # to group the underlying billable metric
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :grouping_keys
+
+        sig { params(grouping_keys: T::Array[String]).void }
+        attr_writer :grouping_keys
+
+        # An inline price definition to evaluate, allowing you to test price
+        # configurations before adding them to Orb.
+        sig do
+          returns(
+            T.nilable(
+              T.any(
+                Orb::NewFloatingUnitPrice,
+                Orb::NewFloatingPackagePrice,
+                Orb::NewFloatingMatrixPrice,
+                Orb::NewFloatingMatrixWithAllocationPrice,
+                Orb::NewFloatingTieredPrice,
+                Orb::NewFloatingTieredBPSPrice,
+                Orb::NewFloatingBPSPrice,
+                Orb::NewFloatingBulkBPSPrice,
+                Orb::NewFloatingBulkPrice,
+                Orb::NewFloatingThresholdTotalAmountPrice,
+                Orb::NewFloatingTieredPackagePrice,
+                Orb::NewFloatingGroupedTieredPrice,
+                Orb::NewFloatingMaxGroupTieredPackagePrice,
+                Orb::NewFloatingTieredWithMinimumPrice,
+                Orb::NewFloatingPackageWithAllocationPrice,
+                Orb::NewFloatingTieredPackageWithMinimumPrice,
+                Orb::NewFloatingUnitWithPercentPrice,
+                Orb::NewFloatingTieredWithProrationPrice,
+                Orb::NewFloatingUnitWithProrationPrice,
+                Orb::NewFloatingGroupedAllocationPrice,
+                Orb::NewFloatingGroupedWithProratedMinimumPrice,
+                Orb::NewFloatingGroupedWithMeteredMinimumPrice,
+                Orb::NewFloatingMatrixWithDisplayNamePrice,
+                Orb::NewFloatingBulkWithProrationPrice,
+                Orb::NewFloatingGroupedTieredPackagePrice,
+                Orb::NewFloatingScalableMatrixWithUnitPricingPrice,
+                Orb::NewFloatingScalableMatrixWithTieredPricingPrice,
+                Orb::NewFloatingCumulativeGroupedBulkPrice
+              )
+            )
+          )
+        end
+        attr_accessor :price
+
+        # The ID of a price to evaluate that exists in your Orb account.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :price_id
+
+        sig do
+          params(
+            filter: T.nilable(String),
+            grouping_keys: T::Array[String],
+            price:
+              T.nilable(
+                T.any(
+                  Orb::NewFloatingUnitPrice::OrHash,
+                  Orb::NewFloatingPackagePrice::OrHash,
+                  Orb::NewFloatingMatrixPrice::OrHash,
+                  Orb::NewFloatingMatrixWithAllocationPrice::OrHash,
+                  Orb::NewFloatingTieredPrice::OrHash,
+                  Orb::NewFloatingTieredBPSPrice::OrHash,
+                  Orb::NewFloatingBPSPrice::OrHash,
+                  Orb::NewFloatingBulkBPSPrice::OrHash,
+                  Orb::NewFloatingBulkPrice::OrHash,
+                  Orb::NewFloatingThresholdTotalAmountPrice::OrHash,
+                  Orb::NewFloatingTieredPackagePrice::OrHash,
+                  Orb::NewFloatingGroupedTieredPrice::OrHash,
+                  Orb::NewFloatingMaxGroupTieredPackagePrice::OrHash,
+                  Orb::NewFloatingTieredWithMinimumPrice::OrHash,
+                  Orb::NewFloatingPackageWithAllocationPrice::OrHash,
+                  Orb::NewFloatingTieredPackageWithMinimumPrice::OrHash,
+                  Orb::NewFloatingUnitWithPercentPrice::OrHash,
+                  Orb::NewFloatingTieredWithProrationPrice::OrHash,
+                  Orb::NewFloatingUnitWithProrationPrice::OrHash,
+                  Orb::NewFloatingGroupedAllocationPrice::OrHash,
+                  Orb::NewFloatingGroupedWithProratedMinimumPrice::OrHash,
+                  Orb::NewFloatingGroupedWithMeteredMinimumPrice::OrHash,
+                  Orb::NewFloatingMatrixWithDisplayNamePrice::OrHash,
+                  Orb::NewFloatingBulkWithProrationPrice::OrHash,
+                  Orb::NewFloatingGroupedTieredPackagePrice::OrHash,
+                  Orb::NewFloatingScalableMatrixWithUnitPricingPrice::OrHash,
+                  Orb::NewFloatingScalableMatrixWithTieredPricingPrice::OrHash,
+                  Orb::NewFloatingCumulativeGroupedBulkPrice::OrHash
+                )
+              ),
+            price_id: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A boolean
+          # [computed property](/extensibility/advanced-metrics#computed-properties) used to
+          # filter the underlying billable metric
+          filter: nil,
+          # Properties (or
+          # [computed properties](/extensibility/advanced-metrics#computed-properties)) used
+          # to group the underlying billable metric
+          grouping_keys: nil,
+          # An inline price definition to evaluate, allowing you to test price
+          # configurations before adding them to Orb.
+          price: nil,
+          # The ID of a price to evaluate that exists in your Orb account.
+          price_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              filter: T.nilable(String),
+              grouping_keys: T::Array[String],
+              price:
+                T.nilable(
+                  T.any(
+                    Orb::NewFloatingUnitPrice,
+                    Orb::NewFloatingPackagePrice,
+                    Orb::NewFloatingMatrixPrice,
+                    Orb::NewFloatingMatrixWithAllocationPrice,
+                    Orb::NewFloatingTieredPrice,
+                    Orb::NewFloatingTieredBPSPrice,
+                    Orb::NewFloatingBPSPrice,
+                    Orb::NewFloatingBulkBPSPrice,
+                    Orb::NewFloatingBulkPrice,
+                    Orb::NewFloatingThresholdTotalAmountPrice,
+                    Orb::NewFloatingTieredPackagePrice,
+                    Orb::NewFloatingGroupedTieredPrice,
+                    Orb::NewFloatingMaxGroupTieredPackagePrice,
+                    Orb::NewFloatingTieredWithMinimumPrice,
+                    Orb::NewFloatingPackageWithAllocationPrice,
+                    Orb::NewFloatingTieredPackageWithMinimumPrice,
+                    Orb::NewFloatingUnitWithPercentPrice,
+                    Orb::NewFloatingTieredWithProrationPrice,
+                    Orb::NewFloatingUnitWithProrationPrice,
+                    Orb::NewFloatingGroupedAllocationPrice,
+                    Orb::NewFloatingGroupedWithProratedMinimumPrice,
+                    Orb::NewFloatingGroupedWithMeteredMinimumPrice,
+                    Orb::NewFloatingMatrixWithDisplayNamePrice,
+                    Orb::NewFloatingBulkWithProrationPrice,
+                    Orb::NewFloatingGroupedTieredPackagePrice,
+                    Orb::NewFloatingScalableMatrixWithUnitPricingPrice,
+                    Orb::NewFloatingScalableMatrixWithTieredPricingPrice,
+                    Orb::NewFloatingCumulativeGroupedBulkPrice
+                  )
+                ),
+              price_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # An inline price definition to evaluate, allowing you to test price
+        # configurations before adding them to Orb.
+        module Price
+          extend Orb::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                Orb::NewFloatingUnitPrice,
+                Orb::NewFloatingPackagePrice,
+                Orb::NewFloatingMatrixPrice,
+                Orb::NewFloatingMatrixWithAllocationPrice,
+                Orb::NewFloatingTieredPrice,
+                Orb::NewFloatingTieredBPSPrice,
+                Orb::NewFloatingBPSPrice,
+                Orb::NewFloatingBulkBPSPrice,
+                Orb::NewFloatingBulkPrice,
+                Orb::NewFloatingThresholdTotalAmountPrice,
+                Orb::NewFloatingTieredPackagePrice,
+                Orb::NewFloatingGroupedTieredPrice,
+                Orb::NewFloatingMaxGroupTieredPackagePrice,
+                Orb::NewFloatingTieredWithMinimumPrice,
+                Orb::NewFloatingPackageWithAllocationPrice,
+                Orb::NewFloatingTieredPackageWithMinimumPrice,
+                Orb::NewFloatingUnitWithPercentPrice,
+                Orb::NewFloatingTieredWithProrationPrice,
+                Orb::NewFloatingUnitWithProrationPrice,
+                Orb::NewFloatingGroupedAllocationPrice,
+                Orb::NewFloatingGroupedWithProratedMinimumPrice,
+                Orb::NewFloatingGroupedWithMeteredMinimumPrice,
+                Orb::NewFloatingMatrixWithDisplayNamePrice,
+                Orb::NewFloatingBulkWithProrationPrice,
+                Orb::NewFloatingGroupedTieredPackagePrice,
+                Orb::NewFloatingScalableMatrixWithUnitPricingPrice,
+                Orb::NewFloatingScalableMatrixWithTieredPricingPrice,
+                Orb::NewFloatingCumulativeGroupedBulkPrice
+              )
+            end
+
+          sig do
+            override.returns(
+              T::Array[
+                Orb::PriceEvaluatePreviewEventsParams::PriceEvaluation::Price::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/orb/models/price_evaluate_preview_events_response.rbi

@@ -0,0 +1,101 @@
+# typed: strong
+
+module Orb
+  module Models
+    class PriceEvaluatePreviewEventsResponse < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Orb::Models::PriceEvaluatePreviewEventsResponse,
+            Orb::Internal::AnyHash
+          )
+        end
+
+      sig do
+        returns(T::Array[Orb::Models::PriceEvaluatePreviewEventsResponse::Data])
+      end
+      attr_accessor :data
+
+      sig do
+        params(
+          data:
+            T::Array[
+              Orb::Models::PriceEvaluatePreviewEventsResponse::Data::OrHash
+            ]
+        ).returns(T.attached_class)
+      end
+      def self.new(data:)
+      end
+
+      sig do
+        override.returns(
+          {
+            data:
+              T::Array[Orb::Models::PriceEvaluatePreviewEventsResponse::Data]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Orb::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Orb::Models::PriceEvaluatePreviewEventsResponse::Data,
+              Orb::Internal::AnyHash
+            )
+          end
+
+        # The currency of the price
+        sig { returns(String) }
+        attr_accessor :currency
+
+        # The computed price groups associated with input price.
+        sig { returns(T::Array[Orb::EvaluatePriceGroup]) }
+        attr_accessor :price_groups
+
+        # The index of the inline price
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :inline_price_index
+
+        # The ID of the price
+        sig { returns(T.nilable(String)) }
+        attr_accessor :price_id
+
+        sig do
+          params(
+            currency: String,
+            price_groups: T::Array[Orb::EvaluatePriceGroup::OrHash],
+            inline_price_index: T.nilable(Integer),
+            price_id: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The currency of the price
+          currency:,
+          # The computed price groups associated with input price.
+          price_groups:,
+          # The index of the inline price
+          inline_price_index: nil,
+          # The ID of the price
+          price_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              currency: String,
+              price_groups: T::Array[Orb::EvaluatePriceGroup],
+              inline_price_index: T.nilable(Integer),
+              price_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/orb/models/price_interval.rbi

@@ -0,0 +1,174 @@
+# typed: strong
+
+module Orb
+  module Models
+    class PriceInterval < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Orb::PriceInterval, Orb::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The day of the month that Orb bills for this price
+      sig { returns(Integer) }
+      attr_accessor :billing_cycle_day
+
+      # The end of the current billing period. This is an exclusive timestamp, such that
+      # the instant returned is exactly the end of the billing period. Set to null if
+      # this price interval is not currently active.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :current_billing_period_end_date
+
+      # The start date of the current billing period. This is an inclusive timestamp;
+      # the instant returned is exactly the beginning of the billing period. Set to null
+      # if this price interval is not currently active.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :current_billing_period_start_date
+
+      # The end date of the price interval. This is the date that Orb stops billing for
+      # this price.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :end_date
+
+      # An additional filter to apply to usage queries.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :filter
+
+      # The fixed fee quantity transitions for this price interval. This is only
+      # relevant for fixed fees.
+      sig { returns(T.nilable(T::Array[Orb::FixedFeeQuantityTransition])) }
+      attr_accessor :fixed_fee_quantity_transitions
+
+      # The Price resource represents a price that can be billed on a subscription,
+      # resulting in a charge on an invoice in the form of an invoice line item. Prices
+      # take a quantity and determine an amount to bill.
+      #
+      # Orb supports a few different pricing models out of the box. Each of these models
+      # is serialized differently in a given Price object. The model_type field
+      # determines the key for the configuration object that is present.
+      #
+      # For more on the types of prices, see
+      # [the core concepts documentation](/core-concepts#plan-and-price)
+      sig { returns(Orb::Price::Variants) }
+      attr_accessor :price
+
+      # The start date of the price interval. This is the date that Orb starts billing
+      # for this price.
+      sig { returns(Time) }
+      attr_accessor :start_date
+
+      # A list of customer IDs whose usage events will be aggregated and billed under
+      # this price interval.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :usage_customer_ids
+
+      # The Price Interval resource represents a period of time for which a price will
+      # bill on a subscription. A subscription’s price intervals define its billing
+      # behavior.
+      sig do
+        params(
+          id: String,
+          billing_cycle_day: Integer,
+          current_billing_period_end_date: T.nilable(Time),
+          current_billing_period_start_date: T.nilable(Time),
+          end_date: T.nilable(Time),
+          filter: T.nilable(String),
+          fixed_fee_quantity_transitions:
+            T.nilable(T::Array[Orb::FixedFeeQuantityTransition::OrHash]),
+          price:
+            T.any(
+              Orb::Price::Unit::OrHash,
+              Orb::Price::Package::OrHash,
+              Orb::Price::Matrix::OrHash,
+              Orb::Price::Tiered::OrHash,
+              Orb::Price::TieredBPS::OrHash,
+              Orb::Price::BPS::OrHash,
+              Orb::Price::BulkBPS::OrHash,
+              Orb::Price::Bulk::OrHash,
+              Orb::Price::ThresholdTotalAmount::OrHash,
+              Orb::Price::TieredPackage::OrHash,
+              Orb::Price::GroupedTiered::OrHash,
+              Orb::Price::TieredWithMinimum::OrHash,
+              Orb::Price::TieredPackageWithMinimum::OrHash,
+              Orb::Price::PackageWithAllocation::OrHash,
+              Orb::Price::UnitWithPercent::OrHash,
+              Orb::Price::MatrixWithAllocation::OrHash,
+              Orb::Price::TieredWithProration::OrHash,
+              Orb::Price::UnitWithProration::OrHash,
+              Orb::Price::GroupedAllocation::OrHash,
+              Orb::Price::GroupedWithProratedMinimum::OrHash,
+              Orb::Price::GroupedWithMeteredMinimum::OrHash,
+              Orb::Price::MatrixWithDisplayName::OrHash,
+              Orb::Price::BulkWithProration::OrHash,
+              Orb::Price::GroupedTieredPackage::OrHash,
+              Orb::Price::MaxGroupTieredPackage::OrHash,
+              Orb::Price::ScalableMatrixWithUnitPricing::OrHash,
+              Orb::Price::ScalableMatrixWithTieredPricing::OrHash,
+              Orb::Price::CumulativeGroupedBulk::OrHash
+            ),
+          start_date: Time,
+          usage_customer_ids: T.nilable(T::Array[String])
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        # The day of the month that Orb bills for this price
+        billing_cycle_day:,
+        # The end of the current billing period. This is an exclusive timestamp, such that
+        # the instant returned is exactly the end of the billing period. Set to null if
+        # this price interval is not currently active.
+        current_billing_period_end_date:,
+        # The start date of the current billing period. This is an inclusive timestamp;
+        # the instant returned is exactly the beginning of the billing period. Set to null
+        # if this price interval is not currently active.
+        current_billing_period_start_date:,
+        # The end date of the price interval. This is the date that Orb stops billing for
+        # this price.
+        end_date:,
+        # An additional filter to apply to usage queries.
+        filter:,
+        # The fixed fee quantity transitions for this price interval. This is only
+        # relevant for fixed fees.
+        fixed_fee_quantity_transitions:,
+        # The Price resource represents a price that can be billed on a subscription,
+        # resulting in a charge on an invoice in the form of an invoice line item. Prices
+        # take a quantity and determine an amount to bill.
+        #
+        # Orb supports a few different pricing models out of the box. Each of these models
+        # is serialized differently in a given Price object. The model_type field
+        # determines the key for the configuration object that is present.
+        #
+        # For more on the types of prices, see
+        # [the core concepts documentation](/core-concepts#plan-and-price)
+        price:,
+        # The start date of the price interval. This is the date that Orb starts billing
+        # for this price.
+        start_date:,
+        # A list of customer IDs whose usage events will be aggregated and billed under
+        # this price interval.
+        usage_customer_ids:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            billing_cycle_day: Integer,
+            current_billing_period_end_date: T.nilable(Time),
+            current_billing_period_start_date: T.nilable(Time),
+            end_date: T.nilable(Time),
+            filter: T.nilable(String),
+            fixed_fee_quantity_transitions:
+              T.nilable(T::Array[Orb::FixedFeeQuantityTransition]),
+            price: Orb::Price::Variants,
+            start_date: Time,
+            usage_customer_ids: T.nilable(T::Array[String])
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end