orb-billing 0.1.0.pre.alpha.33

data/rbi/lib/orb/models/dimensional_price_group.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module Orb
+  module Models
+    class DimensionalPriceGroup < Orb::BaseModel
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The billable metric associated with this dimensional price group. All prices
+      #   associated with this dimensional price group will be computed using this
+      #   billable metric.
+      sig { returns(String) }
+      attr_accessor :billable_metric_id
+
+      # The dimensions that this dimensional price group is defined over
+      sig { returns(T::Array[String]) }
+      attr_accessor :dimensions
+
+      # An alias for the dimensional price group
+      sig { returns(T.nilable(String)) }
+      attr_accessor :external_dimensional_price_group_id
+
+      # User specified key-value pairs for the resource. If not present, this defaults
+      #   to an empty dictionary. Individual keys can be removed by setting the value to
+      #   `null`, and the entire metadata mapping can be cleared by setting `metadata` to
+      #   `null`.
+      sig { returns(T::Hash[Symbol, String]) }
+      attr_accessor :metadata
+
+      # The name of the dimensional price group
+      sig { returns(String) }
+      attr_accessor :name
+
+      # 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.
+      sig do
+        params(
+          id: String,
+          billable_metric_id: String,
+          dimensions: T::Array[String],
+          external_dimensional_price_group_id: T.nilable(String),
+          metadata: T::Hash[Symbol, String],
+          name: String
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        billable_metric_id:,
+        dimensions:,
+        external_dimensional_price_group_id:,
+        metadata:,
+        name:
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              id: String,
+              billable_metric_id: String,
+              dimensions: T::Array[String],
+              external_dimensional_price_group_id: T.nilable(String),
+              metadata: T::Hash[Symbol, String],
+              name: String
+            }
+          )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/dimensional_price_group_create_params.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Orb
+  module Models
+    class DimensionalPriceGroupCreateParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      sig { returns(String) }
+      attr_accessor :billable_metric_id
+
+      # The set of keys (in order) used to disambiguate prices in the group.
+      sig { returns(T::Array[String]) }
+      attr_accessor :dimensions
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :external_dimensional_price_group_id
+
+      # 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`.
+      sig { returns(T.nilable(T::Hash[Symbol, T.nilable(String)])) }
+      attr_accessor :metadata
+
+      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.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        billable_metric_id:,
+        dimensions:,
+        name:,
+        external_dimensional_price_group_id: nil,
+        metadata: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              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: Orb::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/dimensional_price_group_list_params.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module Orb
+  module Models
+    class DimensionalPriceGroupListParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      # Cursor for pagination. This can be populated by the `next_cursor` value returned
+      #   from the initial request.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :cursor
+
+      # The number of items to fetch. Defaults to 20.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      sig do
+        params(
+          cursor: T.nilable(String),
+          limit: Integer,
+          request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(cursor: nil, limit: nil, request_options: {})
+      end
+
+      sig do
+        override.returns({cursor: T.nilable(String), limit: Integer, request_options: Orb::RequestOptions})
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/dimensional_price_group_retrieve_params.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Orb
+  module Models
+    class DimensionalPriceGroupRetrieveParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      sig do
+        params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class)
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({request_options: Orb::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/dimensional_price_groups/external_dimensional_price_group_id_retrieve_params.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module Orb
+  module Models
+    module DimensionalPriceGroups
+      class ExternalDimensionalPriceGroupIDRetrieveParams < Orb::BaseModel
+        extend Orb::Type::RequestParameters::Converter
+        include Orb::RequestParameters
+
+        sig do
+          params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class)
+        end
+        def self.new(request_options: {})
+        end
+
+        sig { override.returns({request_options: Orb::RequestOptions}) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/dimensional_price_groups.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Orb
+  module Models
+    class DimensionalPriceGroupsAPI < Orb::BaseModel
+      sig { returns(T::Array[Orb::Models::DimensionalPriceGroup]) }
+      attr_accessor :data
+
+      sig { returns(Orb::Models::PaginationMetadata) }
+      attr_reader :pagination_metadata
+
+      sig { params(pagination_metadata: T.any(Orb::Models::PaginationMetadata, Orb::Util::AnyHash)).void }
+      attr_writer :pagination_metadata
+
+      sig do
+        params(
+          data: T::Array[T.any(Orb::Models::DimensionalPriceGroup, Orb::Util::AnyHash)],
+          pagination_metadata: T.any(Orb::Models::PaginationMetadata, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(data:, pagination_metadata:)
+      end
+
+      sig do
+        override
+          .returns(
+            {data: T::Array[Orb::Models::DimensionalPriceGroup], pagination_metadata: Orb::Models::PaginationMetadata}
+          )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/discount.rbi

@@ -0,0 +1,18 @@
+# typed: strong
+
+module Orb
+  module Models
+    module Discount
+      extend Orb::Union
+
+      sig do
+        override
+          .returns(
+            [Orb::Models::PercentageDiscount, Orb::Models::TrialDiscount, Orb::Models::UsageDiscount, Orb::Models::AmountDiscount]
+          )
+      end
+      def self.variants
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/evaluate_price_group.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module Orb
+  module Models
+    class EvaluatePriceGroup < Orb::BaseModel
+      # The price's output for the group
+      sig { returns(String) }
+      attr_accessor :amount
+
+      # The values for the group in the order specified by `grouping_keys`
+      sig { returns(T::Array[T.any(String, Float, T::Boolean)]) }
+      attr_accessor :grouping_values
+
+      # The price's usage quantity for the group
+      sig { returns(Float) }
+      attr_accessor :quantity
+
+      sig do
+        params(amount: String, grouping_values: T::Array[T.any(String, Float, T::Boolean)], quantity: Float)
+          .returns(T.attached_class)
+      end
+      def self.new(amount:, grouping_values:, quantity:)
+      end
+
+      sig do
+        override
+          .returns({
+                     amount: String,
+                     grouping_values: T::Array[T.any(String, Float, T::Boolean)],
+                     quantity: Float
+                   })
+      end
+      def to_hash
+      end
+
+      module GroupingValue
+        extend Orb::Union
+
+        sig { override.returns([String, Float, T::Boolean]) }
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/event_deprecate_params.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Orb
+  module Models
+    class EventDeprecateParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      sig do
+        params(request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)).returns(T.attached_class)
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({request_options: Orb::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/event_deprecate_response.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Orb
+  module Models
+    class EventDeprecateResponse < Orb::BaseModel
+      # event_id of the deprecated event, if successfully updated
+      sig { returns(String) }
+      attr_accessor :deprecated
+
+      sig { params(deprecated: String).returns(T.attached_class) }
+      def self.new(deprecated:)
+      end
+
+      sig { override.returns({deprecated: String}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/event_ingest_params.rbi

@@ -0,0 +1,120 @@
+# typed: strong
+
+module Orb
+  module Models
+    class EventIngestParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      sig { returns(T::Array[Orb::Models::EventIngestParams::Event]) }
+      attr_accessor :events
+
+      # If this ingestion request is part of a backfill, this parameter ties the
+      #   ingested events to the backfill
+      sig { returns(T.nilable(String)) }
+      attr_accessor :backfill_id
+
+      # Flag to enable additional debug information in the endpoint response
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :debug
+
+      sig { params(debug: T::Boolean).void }
+      attr_writer :debug
+
+      sig do
+        params(
+          events: T::Array[T.any(Orb::Models::EventIngestParams::Event, Orb::Util::AnyHash)],
+          backfill_id: T.nilable(String),
+          debug: T::Boolean,
+          request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(events:, backfill_id: nil, debug: nil, request_options: {})
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              events: T::Array[Orb::Models::EventIngestParams::Event],
+              backfill_id: T.nilable(String),
+              debug: T::Boolean,
+              request_options: Orb::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      class Event < Orb::BaseModel
+        # A name to meaningfully identify the action or event type.
+        sig { returns(String) }
+        attr_accessor :event_name
+
+        # A unique value, generated by the client, that is used to de-duplicate events.
+        #   Exactly one event with a given idempotency key will be ingested, which allows
+        #   for safe request retries.
+        sig { returns(String) }
+        attr_accessor :idempotency_key
+
+        # A dictionary of custom properties. Values in this dictionary must be numeric,
+        #   boolean, or strings. Nested dictionaries are disallowed.
+        sig { returns(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,
+            idempotency_key: String,
+            properties: T.anything,
+            timestamp: Time,
+            customer_id: T.nilable(String),
+            external_customer_id: T.nilable(String)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          event_name:,
+          idempotency_key:,
+          properties:,
+          timestamp:,
+          customer_id: nil,
+          external_customer_id: nil
+        )
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                event_name: String,
+                idempotency_key: String,
+                properties: T.anything,
+                timestamp: Time,
+                customer_id: T.nilable(String),
+                external_customer_id: T.nilable(String)
+              }
+            )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/event_ingest_response.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Orb
+  module Models
+    class EventIngestResponse < Orb::BaseModel
+      # Contains all failing validation events. In the case of a 200, this array will
+      #   always be empty. This field will always be present.
+      sig { returns(T::Array[Orb::Models::EventIngestResponse::ValidationFailed]) }
+      attr_accessor :validation_failed
+
+      # Optional debug information (only present when debug=true is passed to the
+      #   endpoint). Contains ingested and duplicate event idempotency keys.
+      sig { returns(T.nilable(Orb::Models::EventIngestResponse::Debug)) }
+      attr_reader :debug
+
+      sig { params(debug: T.nilable(T.any(Orb::Models::EventIngestResponse::Debug, Orb::Util::AnyHash))).void }
+      attr_writer :debug
+
+      sig do
+        params(
+          validation_failed: T::Array[T.any(Orb::Models::EventIngestResponse::ValidationFailed, Orb::Util::AnyHash)],
+          debug: T.nilable(T.any(Orb::Models::EventIngestResponse::Debug, Orb::Util::AnyHash))
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(validation_failed:, debug: nil)
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              validation_failed: T::Array[Orb::Models::EventIngestResponse::ValidationFailed],
+              debug: T.nilable(Orb::Models::EventIngestResponse::Debug)
+            }
+          )
+      end
+      def to_hash
+      end
+
+      class ValidationFailed < Orb::BaseModel
+        # The passed idempotency_key corresponding to the validation_errors
+        sig { returns(String) }
+        attr_accessor :idempotency_key
+
+        # An array of strings corresponding to validation failures for this
+        #   idempotency_key.
+        sig { returns(T::Array[String]) }
+        attr_accessor :validation_errors
+
+        sig { params(idempotency_key: String, validation_errors: T::Array[String]).returns(T.attached_class) }
+        def self.new(idempotency_key:, validation_errors:)
+        end
+
+        sig { override.returns({idempotency_key: String, validation_errors: T::Array[String]}) }
+        def to_hash
+        end
+      end
+
+      class Debug < Orb::BaseModel
+        sig { returns(T::Array[String]) }
+        attr_accessor :duplicate
+
+        sig { returns(T::Array[String]) }
+        attr_accessor :ingested
+
+        # Optional debug information (only present when debug=true is passed to the
+        #   endpoint). Contains ingested and duplicate event idempotency keys.
+        sig { params(duplicate: T::Array[String], ingested: T::Array[String]).returns(T.attached_class) }
+        def self.new(duplicate:, ingested:)
+        end
+
+        sig { override.returns({duplicate: T::Array[String], ingested: T::Array[String]}) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/event_search_params.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Orb
+  module Models
+    class EventSearchParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      # This is an explicit array of IDs to filter by. Note that an event's ID is the
+      #   idempotency_key that was originally used for ingestion, and this only supports
+      #   events that have not been amended. Values in this array will be treated case
+      #   sensitively.
+      sig { returns(T::Array[String]) }
+      attr_accessor :event_ids
+
+      # The end of the timeframe, exclusive, in which to search events. If not
+      #   specified, the current time is used.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :timeframe_end
+
+      # The start of the timeframe, inclusive, in which to search events. If not
+      #   specified, the one week ago is used.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :timeframe_start
+
+      sig do
+        params(
+          event_ids: T::Array[String],
+          timeframe_end: T.nilable(Time),
+          timeframe_start: T.nilable(Time),
+          request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(event_ids:, timeframe_end: nil, timeframe_start: nil, request_options: {})
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              event_ids: T::Array[String],
+              timeframe_end: T.nilable(Time),
+              timeframe_start: T.nilable(Time),
+              request_options: Orb::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+    end
+  end
+end