orb-billing 0.1.0.pre.alpha.33

data/rbi/lib/orb/models/subscription_fetch_costs_params.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Orb
+  module Models
+    class SubscriptionFetchCostsParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      # The currency or custom pricing unit to use.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :currency
+
+      # Costs returned are exclusive of `timeframe_end`.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :timeframe_end
+
+      # Costs returned are inclusive of `timeframe_start`.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :timeframe_start
+
+      # Controls whether Orb returns cumulative costs since the start of the billing
+      #   period, or incremental day-by-day costs. If your customer has minimums or
+      #   discounts, it's strongly recommended that you use the default cumulative
+      #   behavior.
+      sig { returns(T.nilable(Orb::Models::SubscriptionFetchCostsParams::ViewMode::OrSymbol)) }
+      attr_accessor :view_mode
+
+      sig do
+        params(
+          currency: T.nilable(String),
+          timeframe_end: T.nilable(Time),
+          timeframe_start: T.nilable(Time),
+          view_mode: T.nilable(Orb::Models::SubscriptionFetchCostsParams::ViewMode::OrSymbol),
+          request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        currency: nil,
+        timeframe_end: nil,
+        timeframe_start: nil,
+        view_mode: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              currency: T.nilable(String),
+              timeframe_end: T.nilable(Time),
+              timeframe_start: T.nilable(Time),
+              view_mode: T.nilable(Orb::Models::SubscriptionFetchCostsParams::ViewMode::OrSymbol),
+              request_options: Orb::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # Controls whether Orb returns cumulative costs since the start of the billing
+      #   period, or incremental day-by-day costs. If your customer has minimums or
+      #   discounts, it's strongly recommended that you use the default cumulative
+      #   behavior.
+      module ViewMode
+        extend Orb::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionFetchCostsParams::ViewMode) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, Orb::Models::SubscriptionFetchCostsParams::ViewMode::TaggedSymbol) }
+
+        PERIODIC = T.let(:periodic, Orb::Models::SubscriptionFetchCostsParams::ViewMode::TaggedSymbol)
+        CUMULATIVE = T.let(:cumulative, Orb::Models::SubscriptionFetchCostsParams::ViewMode::TaggedSymbol)
+
+        sig { override.returns(T::Array[Orb::Models::SubscriptionFetchCostsParams::ViewMode::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/subscription_fetch_costs_response.rbi

@@ -0,0 +1,210 @@
+# typed: strong
+
+module Orb
+  module Models
+    class SubscriptionFetchCostsResponse < Orb::BaseModel
+      sig { returns(T::Array[Orb::Models::SubscriptionFetchCostsResponse::Data]) }
+      attr_accessor :data
+
+      sig do
+        params(data: T::Array[T.any(Orb::Models::SubscriptionFetchCostsResponse::Data, Orb::Util::AnyHash)])
+          .returns(T.attached_class)
+      end
+      def self.new(data:)
+      end
+
+      sig { override.returns({data: T::Array[Orb::Models::SubscriptionFetchCostsResponse::Data]}) }
+      def to_hash
+      end
+
+      class Data < Orb::BaseModel
+        sig { returns(T::Array[Orb::Models::SubscriptionFetchCostsResponse::Data::PerPriceCost]) }
+        attr_accessor :per_price_costs
+
+        # Total costs for the timeframe, excluding any minimums and discounts.
+        sig { returns(String) }
+        attr_accessor :subtotal
+
+        sig { returns(Time) }
+        attr_accessor :timeframe_end
+
+        sig { returns(Time) }
+        attr_accessor :timeframe_start
+
+        # Total costs for the timeframe, including any minimums and discounts.
+        sig { returns(String) }
+        attr_accessor :total
+
+        sig do
+          params(
+            per_price_costs: T::Array[T.any(Orb::Models::SubscriptionFetchCostsResponse::Data::PerPriceCost, Orb::Util::AnyHash)],
+            subtotal: String,
+            timeframe_end: Time,
+            timeframe_start: Time,
+            total: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(per_price_costs:, subtotal:, timeframe_end:, timeframe_start:, total:)
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                per_price_costs: T::Array[Orb::Models::SubscriptionFetchCostsResponse::Data::PerPriceCost],
+                subtotal: String,
+                timeframe_end: Time,
+                timeframe_start: Time,
+                total: String
+              }
+            )
+        end
+        def to_hash
+        end
+
+        class PerPriceCost < Orb::BaseModel
+          # The price object
+          sig do
+            returns(
+              T.any(
+                Orb::Models::Price::UnitPrice,
+                Orb::Models::Price::PackagePrice,
+                Orb::Models::Price::MatrixPrice,
+                Orb::Models::Price::TieredPrice,
+                Orb::Models::Price::TieredBpsPrice,
+                Orb::Models::Price::BpsPrice,
+                Orb::Models::Price::BulkBpsPrice,
+                Orb::Models::Price::BulkPrice,
+                Orb::Models::Price::ThresholdTotalAmountPrice,
+                Orb::Models::Price::TieredPackagePrice,
+                Orb::Models::Price::GroupedTieredPrice,
+                Orb::Models::Price::TieredWithMinimumPrice,
+                Orb::Models::Price::TieredPackageWithMinimumPrice,
+                Orb::Models::Price::PackageWithAllocationPrice,
+                Orb::Models::Price::UnitWithPercentPrice,
+                Orb::Models::Price::MatrixWithAllocationPrice,
+                Orb::Models::Price::TieredWithProrationPrice,
+                Orb::Models::Price::UnitWithProrationPrice,
+                Orb::Models::Price::GroupedAllocationPrice,
+                Orb::Models::Price::GroupedWithProratedMinimumPrice,
+                Orb::Models::Price::GroupedWithMeteredMinimumPrice,
+                Orb::Models::Price::MatrixWithDisplayNamePrice,
+                Orb::Models::Price::BulkWithProrationPrice,
+                Orb::Models::Price::GroupedTieredPackagePrice,
+                Orb::Models::Price::MaxGroupTieredPackagePrice,
+                Orb::Models::Price::ScalableMatrixWithUnitPricingPrice,
+                Orb::Models::Price::ScalableMatrixWithTieredPricingPrice,
+                Orb::Models::Price::CumulativeGroupedBulkPrice
+              )
+            )
+          end
+          attr_accessor :price
+
+          # The price the cost is associated with
+          sig { returns(String) }
+          attr_accessor :price_id
+
+          # Price's contributions for the timeframe, excluding any minimums and discounts.
+          sig { returns(String) }
+          attr_accessor :subtotal
+
+          # Price's contributions for the timeframe, including minimums and discounts.
+          sig { returns(String) }
+          attr_accessor :total
+
+          # The price's quantity for the timeframe
+          sig { returns(T.nilable(Float)) }
+          attr_accessor :quantity
+
+          sig do
+            params(
+              price: T.any(
+                Orb::Models::Price::UnitPrice,
+                Orb::Util::AnyHash,
+                Orb::Models::Price::PackagePrice,
+                Orb::Models::Price::MatrixPrice,
+                Orb::Models::Price::TieredPrice,
+                Orb::Models::Price::TieredBpsPrice,
+                Orb::Models::Price::BpsPrice,
+                Orb::Models::Price::BulkBpsPrice,
+                Orb::Models::Price::BulkPrice,
+                Orb::Models::Price::ThresholdTotalAmountPrice,
+                Orb::Models::Price::TieredPackagePrice,
+                Orb::Models::Price::GroupedTieredPrice,
+                Orb::Models::Price::TieredWithMinimumPrice,
+                Orb::Models::Price::TieredPackageWithMinimumPrice,
+                Orb::Models::Price::PackageWithAllocationPrice,
+                Orb::Models::Price::UnitWithPercentPrice,
+                Orb::Models::Price::MatrixWithAllocationPrice,
+                Orb::Models::Price::TieredWithProrationPrice,
+                Orb::Models::Price::UnitWithProrationPrice,
+                Orb::Models::Price::GroupedAllocationPrice,
+                Orb::Models::Price::GroupedWithProratedMinimumPrice,
+                Orb::Models::Price::GroupedWithMeteredMinimumPrice,
+                Orb::Models::Price::MatrixWithDisplayNamePrice,
+                Orb::Models::Price::BulkWithProrationPrice,
+                Orb::Models::Price::GroupedTieredPackagePrice,
+                Orb::Models::Price::MaxGroupTieredPackagePrice,
+                Orb::Models::Price::ScalableMatrixWithUnitPricingPrice,
+                Orb::Models::Price::ScalableMatrixWithTieredPricingPrice,
+                Orb::Models::Price::CumulativeGroupedBulkPrice
+              ),
+              price_id: String,
+              subtotal: String,
+              total: String,
+              quantity: T.nilable(Float)
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(price:, price_id:, subtotal:, total:, quantity: nil)
+          end
+
+          sig do
+            override
+              .returns(
+                {
+                  price: T.any(
+                    Orb::Models::Price::UnitPrice,
+                    Orb::Models::Price::PackagePrice,
+                    Orb::Models::Price::MatrixPrice,
+                    Orb::Models::Price::TieredPrice,
+                    Orb::Models::Price::TieredBpsPrice,
+                    Orb::Models::Price::BpsPrice,
+                    Orb::Models::Price::BulkBpsPrice,
+                    Orb::Models::Price::BulkPrice,
+                    Orb::Models::Price::ThresholdTotalAmountPrice,
+                    Orb::Models::Price::TieredPackagePrice,
+                    Orb::Models::Price::GroupedTieredPrice,
+                    Orb::Models::Price::TieredWithMinimumPrice,
+                    Orb::Models::Price::TieredPackageWithMinimumPrice,
+                    Orb::Models::Price::PackageWithAllocationPrice,
+                    Orb::Models::Price::UnitWithPercentPrice,
+                    Orb::Models::Price::MatrixWithAllocationPrice,
+                    Orb::Models::Price::TieredWithProrationPrice,
+                    Orb::Models::Price::UnitWithProrationPrice,
+                    Orb::Models::Price::GroupedAllocationPrice,
+                    Orb::Models::Price::GroupedWithProratedMinimumPrice,
+                    Orb::Models::Price::GroupedWithMeteredMinimumPrice,
+                    Orb::Models::Price::MatrixWithDisplayNamePrice,
+                    Orb::Models::Price::BulkWithProrationPrice,
+                    Orb::Models::Price::GroupedTieredPackagePrice,
+                    Orb::Models::Price::MaxGroupTieredPackagePrice,
+                    Orb::Models::Price::ScalableMatrixWithUnitPricingPrice,
+                    Orb::Models::Price::ScalableMatrixWithTieredPricingPrice,
+                    Orb::Models::Price::CumulativeGroupedBulkPrice
+                  ),
+                  price_id: String,
+                  subtotal: String,
+                  total: String,
+                  quantity: T.nilable(Float)
+                }
+              )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/subscription_fetch_params.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Orb
+  module Models
+    class SubscriptionFetchParams < 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/subscription_fetch_schedule_params.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Orb
+  module Models
+    class SubscriptionFetchScheduleParams < 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 { returns(T.nilable(Time)) }
+      attr_accessor :start_date_gt
+
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :start_date_gte
+
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :start_date_lt
+
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :start_date_lte
+
+      sig do
+        params(
+          cursor: T.nilable(String),
+          limit: Integer,
+          start_date_gt: T.nilable(Time),
+          start_date_gte: T.nilable(Time),
+          start_date_lt: T.nilable(Time),
+          start_date_lte: T.nilable(Time),
+          request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        cursor: nil,
+        limit: nil,
+        start_date_gt: nil,
+        start_date_gte: nil,
+        start_date_lt: nil,
+        start_date_lte: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              cursor: T.nilable(String),
+              limit: Integer,
+              start_date_gt: T.nilable(Time),
+              start_date_gte: T.nilable(Time),
+              start_date_lt: T.nilable(Time),
+              start_date_lte: T.nilable(Time),
+              request_options: Orb::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/subscription_fetch_schedule_response.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module Orb
+  module Models
+    class SubscriptionFetchScheduleResponse < Orb::BaseModel
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :end_date
+
+      sig { returns(Orb::Models::SubscriptionFetchScheduleResponse::Plan) }
+      attr_reader :plan
+
+      sig { params(plan: T.any(Orb::Models::SubscriptionFetchScheduleResponse::Plan, Orb::Util::AnyHash)).void }
+      attr_writer :plan
+
+      sig { returns(Time) }
+      attr_accessor :start_date
+
+      sig do
+        params(
+          created_at: Time,
+          end_date: T.nilable(Time),
+          plan: T.any(Orb::Models::SubscriptionFetchScheduleResponse::Plan, Orb::Util::AnyHash),
+          start_date: Time
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(created_at:, end_date:, plan:, start_date:)
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              created_at: Time,
+              end_date: T.nilable(Time),
+              plan: Orb::Models::SubscriptionFetchScheduleResponse::Plan,
+              start_date: Time
+            }
+          )
+      end
+      def to_hash
+      end
+
+      class Plan < Orb::BaseModel
+        sig { returns(T.nilable(String)) }
+        attr_accessor :id
+
+        # An optional user-defined ID for this plan resource, used throughout the system
+        #   as an alias for this Plan. Use this field to identify a plan by an existing
+        #   identifier in your system.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :external_plan_id
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :name
+
+        sig do
+          params(id: T.nilable(String), external_plan_id: T.nilable(String), name: T.nilable(String))
+            .returns(T.attached_class)
+        end
+        def self.new(id:, external_plan_id:, name:)
+        end
+
+        sig do
+          override.returns(
+            {
+              id: T.nilable(String),
+              external_plan_id: T.nilable(String),
+              name: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/subscription_fetch_usage_params.rbi

@@ -0,0 +1,137 @@
+# typed: strong
+
+module Orb
+  module Models
+    class SubscriptionFetchUsageParams < Orb::BaseModel
+      extend Orb::Type::RequestParameters::Converter
+      include Orb::RequestParameters
+
+      # When specified in conjunction with `group_by`, this parameter filters usage to a
+      #   single billable metric. Note that both `group_by` and `billable_metric_id` must
+      #   be specified together.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :billable_metric_id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :first_dimension_key
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :first_dimension_value
+
+      # This determines the windowing of usage reporting.
+      sig { returns(T.nilable(Orb::Models::SubscriptionFetchUsageParams::Granularity::OrSymbol)) }
+      attr_accessor :granularity
+
+      # Groups per-price usage by the key provided.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :group_by
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :second_dimension_key
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :second_dimension_value
+
+      # Usage returned is exclusive of `timeframe_end`.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :timeframe_end
+
+      # Usage returned is inclusive of `timeframe_start`.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :timeframe_start
+
+      # Controls whether Orb returns cumulative usage since the start of the billing
+      #   period, or incremental day-by-day usage. If your customer has minimums or
+      #   discounts, it's strongly recommended that you use the default cumulative
+      #   behavior.
+      sig { returns(T.nilable(Orb::Models::SubscriptionFetchUsageParams::ViewMode::OrSymbol)) }
+      attr_accessor :view_mode
+
+      sig do
+        params(
+          billable_metric_id: T.nilable(String),
+          first_dimension_key: T.nilable(String),
+          first_dimension_value: T.nilable(String),
+          granularity: T.nilable(Orb::Models::SubscriptionFetchUsageParams::Granularity::OrSymbol),
+          group_by: T.nilable(String),
+          second_dimension_key: T.nilable(String),
+          second_dimension_value: T.nilable(String),
+          timeframe_end: T.nilable(Time),
+          timeframe_start: T.nilable(Time),
+          view_mode: T.nilable(Orb::Models::SubscriptionFetchUsageParams::ViewMode::OrSymbol),
+          request_options: T.any(Orb::RequestOptions, Orb::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        billable_metric_id: nil,
+        first_dimension_key: nil,
+        first_dimension_value: nil,
+        granularity: nil,
+        group_by: nil,
+        second_dimension_key: nil,
+        second_dimension_value: nil,
+        timeframe_end: nil,
+        timeframe_start: nil,
+        view_mode: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              billable_metric_id: T.nilable(String),
+              first_dimension_key: T.nilable(String),
+              first_dimension_value: T.nilable(String),
+              granularity: T.nilable(Orb::Models::SubscriptionFetchUsageParams::Granularity::OrSymbol),
+              group_by: T.nilable(String),
+              second_dimension_key: T.nilable(String),
+              second_dimension_value: T.nilable(String),
+              timeframe_end: T.nilable(Time),
+              timeframe_start: T.nilable(Time),
+              view_mode: T.nilable(Orb::Models::SubscriptionFetchUsageParams::ViewMode::OrSymbol),
+              request_options: Orb::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # This determines the windowing of usage reporting.
+      module Granularity
+        extend Orb::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionFetchUsageParams::Granularity) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, Orb::Models::SubscriptionFetchUsageParams::Granularity::TaggedSymbol) }
+
+        DAY = T.let(:day, Orb::Models::SubscriptionFetchUsageParams::Granularity::TaggedSymbol)
+
+        sig { override.returns(T::Array[Orb::Models::SubscriptionFetchUsageParams::Granularity::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      # Controls whether Orb returns cumulative usage since the start of the billing
+      #   period, or incremental day-by-day usage. If your customer has minimums or
+      #   discounts, it's strongly recommended that you use the default cumulative
+      #   behavior.
+      module ViewMode
+        extend Orb::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::SubscriptionFetchUsageParams::ViewMode) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, Orb::Models::SubscriptionFetchUsageParams::ViewMode::TaggedSymbol) }
+
+        PERIODIC = T.let(:periodic, Orb::Models::SubscriptionFetchUsageParams::ViewMode::TaggedSymbol)
+        CUMULATIVE = T.let(:cumulative, Orb::Models::SubscriptionFetchUsageParams::ViewMode::TaggedSymbol)
+
+        sig { override.returns(T::Array[Orb::Models::SubscriptionFetchUsageParams::ViewMode::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end