orb-billing 0.1.0.pre.alpha.33

data/rbi/lib/orb/resources/dimensional_price_groups/external_dimensional_price_group_id.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Orb
+  module Resources
+    class DimensionalPriceGroups
+      class ExternalDimensionalPriceGroupID
+        # Fetch dimensional price group by external ID
+        sig do
+          params(
+            external_dimensional_price_group_id: String,
+            request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+          )
+            .returns(Orb::Models::DimensionalPriceGroup)
+        end
+        def retrieve(external_dimensional_price_group_id, request_options: {})
+        end
+
+        # @api private
+        sig { params(client: Orb::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/resources/dimensional_price_groups.rbi

@@ -0,0 +1,78 @@
+# typed: strong
+
+module Orb
+  module Resources
+    class DimensionalPriceGroups
+      sig { returns(Orb::Resources::DimensionalPriceGroups::ExternalDimensionalPriceGroupID) }
+      attr_reader :external_dimensional_price_group_id
+
+      # A dimensional price group is used to partition the result of a billable metric
+      #   by a set of dimensions. Prices in a price group must specify the parition used
+      #   to derive their usage.
+      #
+      #   For example, suppose we have a billable metric that measures the number of
+      #   widgets used and we want to charge differently depending on the color of the
+      #   widget. We can create a price group with a dimension "color" and two prices: one
+      #   that charges $10 per red widget and one that charges $20 per blue widget.
+      sig do
+        params(
+          billable_metric_id: String,
+          dimensions: T::Array[String],
+          name: String,
+          external_dimensional_price_group_id: T.nilable(String),
+          metadata: T.nilable(T::Hash[Symbol, T.nilable(String)]),
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Models::DimensionalPriceGroup)
+      end
+      def create(
+        billable_metric_id:,
+        # The set of keys (in order) used to disambiguate prices in the group.
+        dimensions:,
+        name:,
+        external_dimensional_price_group_id: nil,
+        # User-specified key/value pairs for the resource. Individual keys can be removed
+        #   by setting the value to `null`, and the entire metadata mapping can be cleared
+        #   by setting `metadata` to `null`.
+        metadata: nil,
+        request_options: {}
+      )
+      end
+
+      # Fetch dimensional price group
+      sig do
+        params(
+          dimensional_price_group_id: String,
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Models::DimensionalPriceGroup)
+      end
+      def retrieve(dimensional_price_group_id, request_options: {})
+      end
+
+      # List dimensional price groups
+      sig do
+        params(
+          cursor: T.nilable(String),
+          limit: Integer,
+          request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+        )
+          .returns(Orb::Page[Orb::Models::DimensionalPriceGroup])
+      end
+      def list(
+        # Cursor for pagination. This can be populated by the `next_cursor` value returned
+        #   from the initial request.
+        cursor: nil,
+        # The number of items to fetch. Defaults to 20.
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Orb::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/orb/resources/events/backfills.rbi

@@ -0,0 +1,161 @@
+# typed: strong
+
+module Orb
+  module Resources
+    class Events
+      class Backfills
+        # Creating the backfill enables adding or replacing past events, even those that
+        #   are older than the ingestion grace period. Performing a backfill in Orb involves
+        #   3 steps:
+        #
+        #   1. Create the backfill, specifying its parameters.
+        #   2. [Ingest](ingest) usage events, referencing the backfill (query parameter
+        #      `backfill_id`).
+        #   3. [Close](close-backfill) the backfill, propagating the update in past usage
+        #      throughout Orb.
+        #
+        #   Changes from a backfill are not reflected until the backfill is closed, so you
+        #   won’t need to worry about your customers seeing partially updated usage data.
+        #   Backfills are also reversible, so you’ll be able to revert a backfill if you’ve
+        #   made a mistake.
+        #
+        #   This endpoint will return a backfill object, which contains an `id`. That `id`
+        #   can then be used as the `backfill_id` query parameter to the event ingestion
+        #   endpoint to associate ingested events with this backfill. The effects (e.g.
+        #   updated usage graphs) of this backfill will not take place until the backfill is
+        #   closed.
+        #
+        #   If the `replace_existing_events` is `true`, existing events in the backfill's
+        #   timeframe will be replaced with the newly ingested events associated with the
+        #   backfill. If `false`, newly ingested events will be added to the existing
+        #   events.
+        #
+        #   If a `customer_id` or `external_customer_id` is specified, the backfill will
+        #   only affect events for that customer. If neither is specified, the backfill will
+        #   affect all customers.
+        #
+        #   When `replace_existing_events` is `true`, this indicates that existing events in
+        #   the timeframe should no longer be counted towards invoiced usage. In this
+        #   scenario, the parameter `filter` can be optionally added which enables filtering
+        #   using
+        #   [computed properties](/extensibility/advanced-metrics#computed-properties). The
+        #   expressiveness of computed properties allows you to deprecate existing events
+        #   based on both a period of time and specific property values.
+        sig do
+          params(
+            timeframe_end: Time,
+            timeframe_start: Time,
+            close_time: T.nilable(Time),
+            customer_id: T.nilable(String),
+            deprecation_filter: T.nilable(String),
+            external_customer_id: T.nilable(String),
+            replace_existing_events: T::Boolean,
+            request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+          )
+            .returns(Orb::Models::Events::BackfillCreateResponse)
+        end
+        def create(
+          # The (exclusive) end of the usage timeframe affected by this backfill. By
+          #   default, Orb allows backfills up to 10 days in duration at a time. Reach out to
+          #   discuss extending this limit and your use case.
+          timeframe_end:,
+          # The (inclusive) start of the usage timeframe affected by this backfill. By
+          #   default, Orb allows backfills up to 10 days in duration at a time. Reach out to
+          #   discuss extending this limit and your use case.
+          timeframe_start:,
+          # The time at which no more events will be accepted for this backfill. The
+          #   backfill will automatically begin reflecting throughout Orb at the close time.
+          #   If not specified, it will default to 1 day after the creation of the backfill.
+          close_time: nil,
+          # The Orb-generated ID of the customer to which this backfill is scoped. Omitting
+          #   this field will scope the backfill to all customers.
+          customer_id: nil,
+          # A boolean
+          #   [computed property](/extensibility/advanced-metrics#computed-properties) used to
+          #   filter the set of events to deprecate
+          deprecation_filter: nil,
+          # The external customer ID of the customer to which this backfill is scoped.
+          #   Omitting this field will scope the backfill to all customers.
+          external_customer_id: nil,
+          # If true, replaces all existing events in the timeframe with the newly ingested
+          #   events. If false, adds the newly ingested events to the existing events.
+          replace_existing_events: nil,
+          request_options: {}
+        )
+        end
+
+        # This endpoint returns a list of all backfills in a list format.
+        #
+        #   The list of backfills is ordered starting from the most recently created
+        #   backfill. The response also includes
+        #   [`pagination_metadata`](/api-reference/pagination), which lets the caller
+        #   retrieve the next page of results if they exist. More information about
+        #   pagination can be found in the [Pagination-metadata schema](pagination).
+        sig do
+          params(
+            cursor: T.nilable(String),
+            limit: Integer,
+            request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+          )
+            .returns(Orb::Page[Orb::Models::Events::BackfillListResponse])
+        end
+        def list(
+          # Cursor for pagination. This can be populated by the `next_cursor` value returned
+          #   from the initial request.
+          cursor: nil,
+          # The number of items to fetch. Defaults to 20.
+          limit: nil,
+          request_options: {}
+        )
+        end
+
+        # Closing a backfill makes the updated usage visible in Orb. Upon closing a
+        #   backfill, Orb will asynchronously reflect the updated usage in invoice amounts
+        #   and usage graphs. Once all of the updates are complete, the backfill's status
+        #   will transition to `reflected`.
+        sig do
+          params(
+            backfill_id: String,
+            request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+          )
+            .returns(Orb::Models::Events::BackfillCloseResponse)
+        end
+        def close(backfill_id, request_options: {})
+        end
+
+        # This endpoint is used to fetch a backfill given an identifier.
+        sig do
+          params(
+            backfill_id: String,
+            request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+          )
+            .returns(Orb::Models::Events::BackfillFetchResponse)
+        end
+        def fetch(backfill_id, request_options: {})
+        end
+
+        # Reverting a backfill undoes all the effects of closing the backfill. If the
+        #   backfill is reflected, the status will transition to `pending_revert` while the
+        #   effects of the backfill are undone. Once all effects are undone, the backfill
+        #   will transition to `reverted`.
+        #
+        #   If a backfill is reverted before its closed, no usage will be updated as a
+        #   result of the backfill and it will immediately transition to `reverted`.
+        sig do
+          params(
+            backfill_id: String,
+            request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+          )
+            .returns(Orb::Models::Events::BackfillRevertResponse)
+        end
+        def revert(backfill_id, request_options: {})
+        end
+
+        # @api private
+        sig { params(client: Orb::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/resources/events/volume.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Orb
+  module Resources
+    class Events
+      class Volume
+        # This endpoint returns the event volume for an account in a
+        #   [paginated list format](/api-reference/pagination).
+        #
+        #   The event volume is aggregated by the hour and the
+        #   [timestamp](/api-reference/event/ingest-events) field is used to determine which
+        #   hour an event is associated with. Note, this means that late-arriving events
+        #   increment the volume count for the hour window the timestamp is in, not the
+        #   latest hour window.
+        #
+        #   Each item in the response contains the count of events aggregated by the hour
+        #   where the start and end time are hour-aligned and in UTC. When a specific
+        #   timestamp is passed in for either start or end time, the response includes the
+        #   hours the timestamp falls in.
+        sig do
+          params(
+            timeframe_start: Time,
+            cursor: T.nilable(String),
+            limit: Integer,
+            timeframe_end: Time,
+            request_options: T.nilable(T.any(Orb::RequestOptions, Orb::Util::AnyHash))
+          )
+            .returns(Orb::Models::Events::EventVolumes)
+        end
+        def list(
+          # The start of the timeframe, inclusive, in which to return event volume. All
+          #   datetime values are converted to UTC time. If the specified time isn't
+          #   hour-aligned, the response includes the event volume count for the hour the time
+          #   falls in.
+          timeframe_start:,
+          # Cursor for pagination. This can be populated by the `next_cursor` value returned
+          #   from the initial request.
+          cursor: nil,
+          # The number of items to fetch. Defaults to 20.
+          limit: nil,
+          # The end of the timeframe, exclusive, in which to return event volume. If not
+          #   specified, the current time is used. All datetime values are converted to UTC
+          #   time.If the specified time isn't hour-aligned, the response includes the event
+          #   volumecount for the hour the time falls in.
+          timeframe_end: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Orb::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end