orb-billing 0.3.0 → 0.3.2

data/rbi/orb/models/subscription_usage.rbi

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

data/rbi/orb/models/subscriptions.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Orb
+  module Models
+    class SubscriptionsAPI < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
+      sig { returns(T::Array[Orb::Subscription]) }
+      attr_accessor :data
+
+      sig { returns(Orb::PaginationMetadata) }
+      attr_reader :pagination_metadata
+
+      sig { params(pagination_metadata: Orb::PaginationMetadata::OrHash).void }
+      attr_writer :pagination_metadata
+
+      sig do
+        params(
+          data: T::Array[Orb::Subscription::OrHash],
+          pagination_metadata: Orb::PaginationMetadata::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(data:, pagination_metadata:)
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T::Array[Orb::Subscription],
+            pagination_metadata: Orb::PaginationMetadata
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/top_level_ping_params.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module Orb
+  module Models
+    class TopLevelPingParams < Orb::Internal::Type::BaseModel
+      extend Orb::Internal::Type::RequestParameters::Converter
+      include Orb::Internal::Type::RequestParameters
+
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
+      sig do
+        params(request_options: Orb::RequestOptions::OrHash).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 → orb}/models/top_level_ping_response.rbi

@@ -3,14 +3,18 @@
 module Orb
   module Models
     class TopLevelPingResponse < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       sig { returns(String) }
       attr_accessor :response
 
       sig { params(response: String).returns(T.attached_class) }
-      def self.new(response:); end
+      def self.new(response:)
+      end
 
-      sig { override.returns({response: String}) }
-      def to_hash; end
+      sig { override.returns({ response: String }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/{lib/orb → orb}/models/trial_discount.rbi

@@ -3,12 +3,14 @@
 module Orb
   module Models
     class TrialDiscount < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # 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) }
+      sig { returns(Orb::TrialDiscount::DiscountType::OrSymbol) }
       attr_accessor :discount_type
 
       sig { returns(T.nilable(String)) }
@@ -25,12 +27,11 @@ module Orb
       sig do
         params(
           applies_to_price_ids: T::Array[String],
-          discount_type: Orb::Models::TrialDiscount::DiscountType::OrSymbol,
+          discount_type: Orb::TrialDiscount::DiscountType::OrSymbol,
           reason: T.nilable(String),
           trial_amount_discount: T.nilable(String),
           trial_percentage_discount: T.nilable(Float)
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # List of price_ids that this discount applies to. For plan/plan phase discounts,
@@ -42,31 +43,39 @@ module Orb
         trial_amount_discount: nil,
         # Only available if discount_type is `trial`
         trial_percentage_discount: nil
-      ); end
+      )
+      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)
-            }
-          )
+        override.returns(
+          {
+            applies_to_price_ids: T::Array[String],
+            discount_type: Orb::TrialDiscount::DiscountType::OrSymbol,
+            reason: T.nilable(String),
+            trial_amount_discount: T.nilable(String),
+            trial_percentage_discount: T.nilable(Float)
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       module DiscountType
         extend Orb::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::TrialDiscount::DiscountType) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Orb::TrialDiscount::DiscountType) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        TRIAL = T.let(:trial, Orb::Models::TrialDiscount::DiscountType::TaggedSymbol)
+        TRIAL = T.let(:trial, Orb::TrialDiscount::DiscountType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Orb::Models::TrialDiscount::DiscountType::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Orb::TrialDiscount::DiscountType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
     end
   end

data/rbi/{lib/orb → orb}/models/usage_discount.rbi

@@ -3,12 +3,14 @@
 module Orb
   module Models
     class UsageDiscount < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # 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) }
+      sig { returns(Orb::UsageDiscount::DiscountType::OrSymbol) }
       attr_accessor :discount_type
 
       # Only available if discount_type is `usage`. Number of usage units that this
@@ -22,11 +24,10 @@ module Orb
       sig do
         params(
           applies_to_price_ids: T::Array[String],
-          discount_type: Orb::Models::UsageDiscount::DiscountType::OrSymbol,
+          discount_type: Orb::UsageDiscount::DiscountType::OrSymbol,
           usage_discount: Float,
           reason: T.nilable(String)
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # List of price_ids that this discount applies to. For plan/plan phase discounts,
@@ -37,30 +38,38 @@ module Orb
         # discount is for
         usage_discount:,
         reason: nil
-      ); end
+      )
+      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)
-            }
-          )
+        override.returns(
+          {
+            applies_to_price_ids: T::Array[String],
+            discount_type: Orb::UsageDiscount::DiscountType::OrSymbol,
+            usage_discount: Float,
+            reason: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       module DiscountType
         extend Orb::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::UsageDiscount::DiscountType) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Orb::UsageDiscount::DiscountType) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        USAGE = T.let(:usage, Orb::Models::UsageDiscount::DiscountType::TaggedSymbol)
+        USAGE = T.let(:usage, Orb::UsageDiscount::DiscountType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Orb::Models::UsageDiscount::DiscountType::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Orb::UsageDiscount::DiscountType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
     end
   end