orb-billing 0.1.0.pre.alpha.33

data/rbi/lib/orb/models/subscription_usage.rbi

@@ -0,0 +1,323 @@
+# typed: strong
+
+module Orb
+  module Models
+    module SubscriptionUsage
+      extend Orb::Union
+
+      class UngroupedSubscriptionUsage < Orb::BaseModel
+        sig { returns(T::Array[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data]) }
+        attr_accessor :data
+
+        sig do
+          params(
+            data: T::Array[T.any(Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data, Orb::Util::AnyHash)]
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(data:)
+        end
+
+        sig { override.returns({data: T::Array[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data]}) }
+        def to_hash
+        end
+
+        class Data < Orb::BaseModel
+          sig { returns(Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::BillableMetric) }
+          attr_reader :billable_metric
+
+          sig do
+            params(
+              billable_metric: T.any(
+                Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::BillableMetric,
+                Orb::Util::AnyHash
+              )
+            )
+              .void
+          end
+          attr_writer :billable_metric
+
+          sig { returns(T::Array[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::Usage]) }
+          attr_accessor :usage
+
+          sig { returns(Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode::TaggedSymbol) }
+          attr_accessor :view_mode
+
+          sig do
+            params(
+              billable_metric: T.any(
+                Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::BillableMetric,
+                Orb::Util::AnyHash
+              ),
+              usage: T::Array[T.any(Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::Usage, Orb::Util::AnyHash)],
+              view_mode: Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode::OrSymbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(billable_metric:, usage:, view_mode:)
+          end
+
+          sig do
+            override
+              .returns(
+                {
+                  billable_metric: Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::BillableMetric,
+                  usage: T::Array[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::Usage],
+                  view_mode: Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode::TaggedSymbol
+                }
+              )
+          end
+          def to_hash
+          end
+
+          class BillableMetric < Orb::BaseModel
+            sig { returns(String) }
+            attr_accessor :id
+
+            sig { returns(String) }
+            attr_accessor :name
+
+            sig { params(id: String, name: String).returns(T.attached_class) }
+            def self.new(id:, name:)
+            end
+
+            sig { override.returns({id: String, name: String}) }
+            def to_hash
+            end
+          end
+
+          class Usage < Orb::BaseModel
+            sig { returns(Float) }
+            attr_accessor :quantity
+
+            sig { returns(Time) }
+            attr_accessor :timeframe_end
+
+            sig { returns(Time) }
+            attr_accessor :timeframe_start
+
+            sig do
+              params(quantity: Float, timeframe_end: Time, timeframe_start: Time).returns(T.attached_class)
+            end
+            def self.new(quantity:, timeframe_end:, timeframe_start:)
+            end
+
+            sig { override.returns({quantity: Float, timeframe_end: Time, timeframe_start: Time}) }
+            def to_hash
+            end
+          end
+
+          module ViewMode
+            extend Orb::Enum
+
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode) }
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  String,
+                  Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode::TaggedSymbol
+                )
+              end
+
+            PERIODIC =
+              T.let(:periodic, Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode::TaggedSymbol)
+            CUMULATIVE =
+              T.let(
+                :cumulative,
+                Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode::TaggedSymbol
+              )
+
+            sig do
+              override
+                .returns(
+                  T::Array[Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage::Data::ViewMode::TaggedSymbol]
+                )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+
+      class GroupedSubscriptionUsage < Orb::BaseModel
+        sig { returns(T::Array[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data]) }
+        attr_accessor :data
+
+        sig { returns(T.nilable(Orb::Models::PaginationMetadata)) }
+        attr_reader :pagination_metadata
+
+        sig { params(pagination_metadata: T.nilable(T.any(Orb::Models::PaginationMetadata, Orb::Util::AnyHash))).void }
+        attr_writer :pagination_metadata
+
+        sig do
+          params(
+            data: T::Array[T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data, Orb::Util::AnyHash)],
+            pagination_metadata: T.nilable(T.any(Orb::Models::PaginationMetadata, Orb::Util::AnyHash))
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(data:, pagination_metadata: nil)
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                data: T::Array[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data],
+                pagination_metadata: T.nilable(Orb::Models::PaginationMetadata)
+              }
+            )
+        end
+        def to_hash
+        end
+
+        class Data < Orb::BaseModel
+          sig { returns(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric) }
+          attr_reader :billable_metric
+
+          sig do
+            params(
+              billable_metric: T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric, Orb::Util::AnyHash)
+            )
+              .void
+          end
+          attr_writer :billable_metric
+
+          sig { returns(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::MetricGroup) }
+          attr_reader :metric_group
+
+          sig do
+            params(
+              metric_group: T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::MetricGroup, Orb::Util::AnyHash)
+            )
+              .void
+          end
+          attr_writer :metric_group
+
+          sig { returns(T::Array[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::Usage]) }
+          attr_accessor :usage
+
+          sig { returns(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode::TaggedSymbol) }
+          attr_accessor :view_mode
+
+          sig do
+            params(
+              billable_metric: T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric, Orb::Util::AnyHash),
+              metric_group: T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::MetricGroup, Orb::Util::AnyHash),
+              usage: T::Array[T.any(Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::Usage, Orb::Util::AnyHash)],
+              view_mode: Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode::OrSymbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(billable_metric:, metric_group:, usage:, view_mode:)
+          end
+
+          sig do
+            override
+              .returns(
+                {
+                  billable_metric: Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::BillableMetric,
+                  metric_group: Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::MetricGroup,
+                  usage: T::Array[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::Usage],
+                  view_mode: Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode::TaggedSymbol
+                }
+              )
+          end
+          def to_hash
+          end
+
+          class BillableMetric < Orb::BaseModel
+            sig { returns(String) }
+            attr_accessor :id
+
+            sig { returns(String) }
+            attr_accessor :name
+
+            sig { params(id: String, name: String).returns(T.attached_class) }
+            def self.new(id:, name:)
+            end
+
+            sig { override.returns({id: String, name: String}) }
+            def to_hash
+            end
+          end
+
+          class MetricGroup < Orb::BaseModel
+            sig { returns(String) }
+            attr_accessor :property_key
+
+            sig { returns(String) }
+            attr_accessor :property_value
+
+            sig { params(property_key: String, property_value: String).returns(T.attached_class) }
+            def self.new(property_key:, property_value:)
+            end
+
+            sig { override.returns({property_key: String, property_value: String}) }
+            def to_hash
+            end
+          end
+
+          class Usage < Orb::BaseModel
+            sig { returns(Float) }
+            attr_accessor :quantity
+
+            sig { returns(Time) }
+            attr_accessor :timeframe_end
+
+            sig { returns(Time) }
+            attr_accessor :timeframe_start
+
+            sig do
+              params(quantity: Float, timeframe_end: Time, timeframe_start: Time).returns(T.attached_class)
+            end
+            def self.new(quantity:, timeframe_end:, timeframe_start:)
+            end
+
+            sig { override.returns({quantity: Float, timeframe_end: Time, timeframe_start: Time}) }
+            def to_hash
+            end
+          end
+
+          module ViewMode
+            extend Orb::Enum
+
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode) }
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  String,
+                  Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode::TaggedSymbol
+                )
+              end
+
+            PERIODIC =
+              T.let(:periodic, Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode::TaggedSymbol)
+            CUMULATIVE =
+              T.let(:cumulative, Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode::TaggedSymbol)
+
+            sig do
+              override
+                .returns(T::Array[Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage::Data::ViewMode::TaggedSymbol])
+            end
+            def self.values
+            end
+          end
+        end
+      end
+
+      sig do
+        override
+          .returns(
+            [Orb::Models::SubscriptionUsage::UngroupedSubscriptionUsage, Orb::Models::SubscriptionUsage::GroupedSubscriptionUsage]
+          )
+      end
+      def self.variants
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/subscriptions.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Orb
+  module Models
+    class SubscriptionsAPI < Orb::BaseModel
+      sig { returns(T::Array[Orb::Models::Subscription]) }
+      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::Subscription, 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::Subscription], pagination_metadata: Orb::Models::PaginationMetadata})
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/top_level_ping_params.rbi

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

@@ -0,0 +1,18 @@
+# typed: strong
+
+module Orb
+  module Models
+    class TopLevelPingResponse < Orb::BaseModel
+      sig { returns(String) }
+      attr_accessor :response
+
+      sig { params(response: String).returns(T.attached_class) }
+      def self.new(response:)
+      end
+
+      sig { override.returns({response: String}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/trial_discount.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Orb
+  module Models
+    class TrialDiscount < Orb::BaseModel
+      # List of price_ids that this discount applies to. For plan/plan phase discounts,
+      #   this can be a subset of prices.
+      sig { returns(T::Array[String]) }
+      attr_accessor :applies_to_price_ids
+
+      sig { returns(Orb::Models::TrialDiscount::DiscountType::OrSymbol) }
+      attr_accessor :discount_type
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason
+
+      # Only available if discount_type is `trial`
+      sig { returns(T.nilable(String)) }
+      attr_accessor :trial_amount_discount
+
+      # Only available if discount_type is `trial`
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :trial_percentage_discount
+
+      sig do
+        params(
+          applies_to_price_ids: T::Array[String],
+          discount_type: Orb::Models::TrialDiscount::DiscountType::OrSymbol,
+          reason: T.nilable(String),
+          trial_amount_discount: T.nilable(String),
+          trial_percentage_discount: T.nilable(Float)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        applies_to_price_ids:,
+        discount_type:,
+        reason: nil,
+        trial_amount_discount: nil,
+        trial_percentage_discount: nil
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              applies_to_price_ids: T::Array[String],
+              discount_type: Orb::Models::TrialDiscount::DiscountType::OrSymbol,
+              reason: T.nilable(String),
+              trial_amount_discount: T.nilable(String),
+              trial_percentage_discount: T.nilable(Float)
+            }
+          )
+      end
+      def to_hash
+      end
+
+      module DiscountType
+        extend Orb::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::TrialDiscount::DiscountType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::TrialDiscount::DiscountType::TaggedSymbol) }
+
+        TRIAL = T.let(:trial, Orb::Models::TrialDiscount::DiscountType::TaggedSymbol)
+
+        sig { override.returns(T::Array[Orb::Models::TrialDiscount::DiscountType::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/models/usage_discount.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module Orb
+  module Models
+    class UsageDiscount < Orb::BaseModel
+      # List of price_ids that this discount applies to. For plan/plan phase discounts,
+      #   this can be a subset of prices.
+      sig { returns(T::Array[String]) }
+      attr_accessor :applies_to_price_ids
+
+      sig { returns(Orb::Models::UsageDiscount::DiscountType::OrSymbol) }
+      attr_accessor :discount_type
+
+      # Only available if discount_type is `usage`. Number of usage units that this
+      #   discount is for
+      sig { returns(Float) }
+      attr_accessor :usage_discount
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason
+
+      sig do
+        params(
+          applies_to_price_ids: T::Array[String],
+          discount_type: Orb::Models::UsageDiscount::DiscountType::OrSymbol,
+          usage_discount: Float,
+          reason: T.nilable(String)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(applies_to_price_ids:, discount_type:, usage_discount:, reason: nil)
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              applies_to_price_ids: T::Array[String],
+              discount_type: Orb::Models::UsageDiscount::DiscountType::OrSymbol,
+              usage_discount: Float,
+              reason: T.nilable(String)
+            }
+          )
+      end
+      def to_hash
+      end
+
+      module DiscountType
+        extend Orb::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::UsageDiscount::DiscountType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String, Orb::Models::UsageDiscount::DiscountType::TaggedSymbol) }
+
+        USAGE = T.let(:usage, Orb::Models::UsageDiscount::DiscountType::TaggedSymbol)
+
+        sig { override.returns(T::Array[Orb::Models::UsageDiscount::DiscountType::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/orb/page.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Orb
+  class Page
+    include Orb::Type::BasePage
+
+    Elem = type_member
+
+    sig { returns(T.nilable(T::Array[Elem])) }
+    attr_accessor :data
+
+    sig { returns(PaginationMetadata) }
+    attr_accessor :pagination_metadata
+
+    sig { returns(String) }
+    def inspect
+    end
+
+    class PaginationMetadata < Orb::BaseModel
+      sig { returns(T::Boolean) }
+      attr_accessor :has_more
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :next_cursor
+
+      sig { params(has_more: T::Boolean, next_cursor: T.nilable(String)).returns(T.attached_class) }
+      def self.new(has_more:, next_cursor:)
+      end
+
+      sig { override.returns({has_more: T::Boolean, next_cursor: T.nilable(String)}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/orb/request_options.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module Orb
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  #   or override those provided at the client level.
+  #
+  #   When making a request, you can pass an actual {RequestOptions} instance, or
+  #   simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Orb::BaseModel
+    # @api private
+    sig { params(opts: T.any(T.self_type, T::Hash[Symbol, T.anything])).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    #   sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    #   `query` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])) }
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    #   `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    #   generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig { params(values: Orb::Util::AnyHash).returns(T.attached_class) }
+    def self.new(values = {})
+    end
+  end
+end