orb-billing 0.3.0 → 0.3.2

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

@@ -6,12 +6,16 @@ module Orb
       extend Orb::Internal::Type::RequestParameters::Converter
       include Orb::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # The thresholds that define the values at which the alert will be triggered.
-      sig { returns(T::Array[Orb::Models::AlertCreateForSubscriptionParams::Threshold]) }
+      sig do
+        returns(T::Array[Orb::AlertCreateForSubscriptionParams::Threshold])
+      end
       attr_accessor :thresholds
 
       # The type of alert to create. This must be a valid alert type.
-      sig { returns(Orb::Models::AlertCreateForSubscriptionParams::Type::OrSymbol) }
+      sig { returns(Orb::AlertCreateForSubscriptionParams::Type::OrSymbol) }
       attr_accessor :type
 
       # The metric to track usage for.
@@ -20,12 +24,12 @@ module Orb
 
       sig do
         params(
-          thresholds: T::Array[T.any(Orb::Models::AlertCreateForSubscriptionParams::Threshold, Orb::Internal::AnyHash)],
-          type: Orb::Models::AlertCreateForSubscriptionParams::Type::OrSymbol,
+          thresholds:
+            T::Array[Orb::AlertCreateForSubscriptionParams::Threshold::OrHash],
+          type: Orb::AlertCreateForSubscriptionParams::Type::OrSymbol,
           metric_id: T.nilable(String),
-          request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # The thresholds that define the values at which the alert will be triggered.
@@ -35,21 +39,26 @@ module Orb
         # The metric to track usage for.
         metric_id: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              thresholds: T::Array[Orb::Models::AlertCreateForSubscriptionParams::Threshold],
-              type: Orb::Models::AlertCreateForSubscriptionParams::Type::OrSymbol,
-              metric_id: T.nilable(String),
-              request_options: Orb::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            thresholds:
+              T::Array[Orb::AlertCreateForSubscriptionParams::Threshold],
+            type: Orb::AlertCreateForSubscriptionParams::Type::OrSymbol,
+            metric_id: T.nilable(String),
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class Threshold < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         # The value at which an alert will fire. For credit balance alerts, the alert will
         # fire at or below this value. For usage and cost alerts, the alert will fire at
         # or above this value.
@@ -64,24 +73,42 @@ module Orb
           # fire at or below this value. For usage and cost alerts, the alert will fire at
           # or above this value.
           value:
-        ); end
-        sig { override.returns({value: Float}) }
-        def to_hash; end
+        )
+        end
+
+        sig { override.returns({ value: Float }) }
+        def to_hash
+        end
       end
 
       # The type of alert to create. This must be a valid alert type.
       module Type
         extend Orb::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::AlertCreateForSubscriptionParams::Type) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Orb::AlertCreateForSubscriptionParams::Type)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         USAGE_EXCEEDED =
-          T.let(:usage_exceeded, Orb::Models::AlertCreateForSubscriptionParams::Type::TaggedSymbol)
-        COST_EXCEEDED = T.let(:cost_exceeded, Orb::Models::AlertCreateForSubscriptionParams::Type::TaggedSymbol)
+          T.let(
+            :usage_exceeded,
+            Orb::AlertCreateForSubscriptionParams::Type::TaggedSymbol
+          )
+        COST_EXCEEDED =
+          T.let(
+            :cost_exceeded,
+            Orb::AlertCreateForSubscriptionParams::Type::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Orb::Models::AlertCreateForSubscriptionParams::Type::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Orb::AlertCreateForSubscriptionParams::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
     end
   end

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

@@ -6,6 +6,8 @@ module Orb
       extend Orb::Internal::Type::RequestParameters::Converter
       include Orb::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # Used to update the status of a plan alert scoped to this subscription_id
       sig { returns(T.nilable(String)) }
       attr_accessor :subscription_id
@@ -13,17 +15,26 @@ module Orb
       sig do
         params(
           subscription_id: T.nilable(String),
-          request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # Used to update the status of a plan alert scoped to this subscription_id
         subscription_id: nil,
         request_options: {}
-      ); end
-      sig { override.returns({subscription_id: T.nilable(String), request_options: Orb::RequestOptions}) }
-      def to_hash; end
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            subscription_id: T.nilable(String),
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
     end
   end
 end

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

@@ -6,6 +6,8 @@ module Orb
       extend Orb::Internal::Type::RequestParameters::Converter
       include Orb::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # Used to update the status of a plan alert scoped to this subscription_id
       sig { returns(T.nilable(String)) }
       attr_accessor :subscription_id
@@ -13,17 +15,26 @@ module Orb
       sig do
         params(
           subscription_id: T.nilable(String),
-          request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # Used to update the status of a plan alert scoped to this subscription_id
         subscription_id: nil,
         request_options: {}
-      ); end
-      sig { override.returns({subscription_id: T.nilable(String), request_options: Orb::RequestOptions}) }
-      def to_hash; end
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            subscription_id: T.nilable(String),
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
     end
   end
 end

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

@@ -6,6 +6,8 @@ module Orb
       extend Orb::Internal::Type::RequestParameters::Converter
       include Orb::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       sig { returns(T.nilable(Time)) }
       attr_accessor :created_at_gt
 
@@ -53,9 +55,8 @@ module Orb
           external_customer_id: T.nilable(String),
           limit: Integer,
           subscription_id: T.nilable(String),
-          request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         created_at_gt: nil,
@@ -74,25 +75,27 @@ module Orb
         # Fetch alerts scoped to this subscription_id
         subscription_id: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              created_at_gt: T.nilable(Time),
-              created_at_gte: T.nilable(Time),
-              created_at_lt: T.nilable(Time),
-              created_at_lte: T.nilable(Time),
-              cursor: T.nilable(String),
-              customer_id: T.nilable(String),
-              external_customer_id: T.nilable(String),
-              limit: Integer,
-              subscription_id: T.nilable(String),
-              request_options: Orb::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            created_at_gt: T.nilable(Time),
+            created_at_gte: T.nilable(Time),
+            created_at_lt: T.nilable(Time),
+            created_at_lte: T.nilable(Time),
+            cursor: T.nilable(String),
+            customer_id: T.nilable(String),
+            external_customer_id: T.nilable(String),
+            limit: Integer,
+            subscription_id: T.nilable(String),
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
     end
   end
 end

data/rbi/orb/models/alert_retrieve_params.rbi

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

@@ -6,31 +6,39 @@ module Orb
       extend Orb::Internal::Type::RequestParameters::Converter
       include Orb::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # The thresholds that define the values at which the alert will be triggered.
-      sig { returns(T::Array[Orb::Models::AlertUpdateParams::Threshold]) }
+      sig { returns(T::Array[Orb::AlertUpdateParams::Threshold]) }
       attr_accessor :thresholds
 
       sig do
         params(
-          thresholds: T::Array[T.any(Orb::Models::AlertUpdateParams::Threshold, Orb::Internal::AnyHash)],
-          request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          thresholds: T::Array[Orb::AlertUpdateParams::Threshold::OrHash],
+          request_options: Orb::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # The thresholds that define the values at which the alert will be triggered.
         thresholds:,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {thresholds: T::Array[Orb::Models::AlertUpdateParams::Threshold], request_options: Orb::RequestOptions}
-          )
+        override.returns(
+          {
+            thresholds: T::Array[Orb::AlertUpdateParams::Threshold],
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class Threshold < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         # The value at which an alert will fire. For credit balance alerts, the alert will
         # fire at or below this value. For usage and cost alerts, the alert will fire at
         # or above this value.
@@ -45,9 +53,12 @@ module Orb
           # fire at or below this value. For usage and cost alerts, the alert will fire at
           # or above this value.
           value:
-        ); end
-        sig { override.returns({value: Float}) }
-        def to_hash; end
+        )
+        end
+
+        sig { override.returns({ value: Float }) }
+        def to_hash
+        end
       end
     end
   end

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

@@ -3,6 +3,8 @@
 module Orb
   module Models
     class AmountDiscount < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # Only available if discount_type is `amount`.
       sig { returns(String) }
       attr_accessor :amount_discount
@@ -12,7 +14,7 @@ module Orb
       sig { returns(T::Array[String]) }
       attr_accessor :applies_to_price_ids
 
-      sig { returns(Orb::Models::AmountDiscount::DiscountType::OrSymbol) }
+      sig { returns(Orb::AmountDiscount::DiscountType::OrSymbol) }
       attr_accessor :discount_type
 
       sig { returns(T.nilable(String)) }
@@ -22,10 +24,9 @@ module Orb
         params(
           amount_discount: String,
           applies_to_price_ids: T::Array[String],
-          discount_type: Orb::Models::AmountDiscount::DiscountType::OrSymbol,
+          discount_type: Orb::AmountDiscount::DiscountType::OrSymbol,
           reason: T.nilable(String)
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # Only available if discount_type is `amount`.
@@ -35,30 +36,38 @@ module Orb
         applies_to_price_ids:,
         discount_type:,
         reason: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              amount_discount: String,
-              applies_to_price_ids: T::Array[String],
-              discount_type: Orb::Models::AmountDiscount::DiscountType::OrSymbol,
-              reason: T.nilable(String)
-            }
-          )
+        override.returns(
+          {
+            amount_discount: String,
+            applies_to_price_ids: T::Array[String],
+            discount_type: Orb::AmountDiscount::DiscountType::OrSymbol,
+            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::AmountDiscount::DiscountType) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Orb::AmountDiscount::DiscountType) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        AMOUNT = T.let(:amount, Orb::Models::AmountDiscount::DiscountType::TaggedSymbol)
+        AMOUNT = T.let(:amount, Orb::AmountDiscount::DiscountType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Orb::Models::AmountDiscount::DiscountType::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Orb::AmountDiscount::DiscountType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
     end
   end

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

@@ -3,6 +3,8 @@
 module Orb
   module Models
     class BillableMetric < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       sig { returns(String) }
       attr_accessor :id
 
@@ -12,10 +14,10 @@ module Orb
       # The Item resource represents a sellable product or good. Items are associated
       # with all line items, billable metrics, and prices and are used for defining
       # external sync behavior for invoices and tax calculation purposes.
-      sig { returns(Orb::Models::Item) }
+      sig { returns(Orb::Item) }
       attr_reader :item
 
-      sig { params(item: T.any(Orb::Models::Item, Orb::Internal::AnyHash)).void }
+      sig { params(item: Orb::Item::OrHash).void }
       attr_writer :item
 
       # User specified key-value pairs for the resource. If not present, this defaults
@@ -28,7 +30,7 @@ module Orb
       sig { returns(String) }
       attr_accessor :name
 
-      sig { returns(Orb::Models::BillableMetric::Status::TaggedSymbol) }
+      sig { returns(Orb::BillableMetric::Status::TaggedSymbol) }
       attr_accessor :status
 
       # The Metric resource represents a calculation of a quantity based on events.
@@ -38,12 +40,11 @@ module Orb
         params(
           id: String,
           description: T.nilable(String),
-          item: T.any(Orb::Models::Item, Orb::Internal::AnyHash),
+          item: Orb::Item::OrHash,
           metadata: T::Hash[Symbol, String],
           name: String,
-          status: Orb::Models::BillableMetric::Status::OrSymbol
-        )
-          .returns(T.attached_class)
+          status: Orb::BillableMetric::Status::OrSymbol
+        ).returns(T.attached_class)
       end
       def self.new(
         id:,
@@ -59,34 +60,40 @@ module Orb
         metadata:,
         name:,
         status:
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              id: String,
-              description: T.nilable(String),
-              item: Orb::Models::Item,
-              metadata: T::Hash[Symbol, String],
-              name: String,
-              status: Orb::Models::BillableMetric::Status::TaggedSymbol
-            }
-          )
+        override.returns(
+          {
+            id: String,
+            description: T.nilable(String),
+            item: Orb::Item,
+            metadata: T::Hash[Symbol, String],
+            name: String,
+            status: Orb::BillableMetric::Status::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       module Status
         extend Orb::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::BillableMetric::Status) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Orb::BillableMetric::Status) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        ACTIVE = T.let(:active, Orb::Models::BillableMetric::Status::TaggedSymbol)
-        DRAFT = T.let(:draft, Orb::Models::BillableMetric::Status::TaggedSymbol)
-        ARCHIVED = T.let(:archived, Orb::Models::BillableMetric::Status::TaggedSymbol)
+        ACTIVE = T.let(:active, Orb::BillableMetric::Status::TaggedSymbol)
+        DRAFT = T.let(:draft, Orb::BillableMetric::Status::TaggedSymbol)
+        ARCHIVED = T.let(:archived, Orb::BillableMetric::Status::TaggedSymbol)
 
-        sig { override.returns(T::Array[Orb::Models::BillableMetric::Status::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(T::Array[Orb::BillableMetric::Status::TaggedSymbol])
+        end
+        def self.values
+        end
       end
     end
   end

data/rbi/orb/models/billing_cycle_relative_date.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module Orb
+  module Models
+    module BillingCycleRelativeDate
+      extend Orb::Internal::Type::Enum
+
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, Orb::BillingCycleRelativeDate) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      START_OF_TERM =
+        T.let(:start_of_term, Orb::BillingCycleRelativeDate::TaggedSymbol)
+      END_OF_TERM =
+        T.let(:end_of_term, Orb::BillingCycleRelativeDate::TaggedSymbol)
+
+      sig do
+        override.returns(T::Array[Orb::BillingCycleRelativeDate::TaggedSymbol])
+      end
+      def self.values
+      end
+    end
+  end
+end

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

@@ -3,6 +3,8 @@
 module Orb
   module Models
     class Coupon < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # Also referred to as coupon_id in this documentation.
       sig { returns(String) }
       attr_accessor :id
@@ -12,7 +14,7 @@ module Orb
       sig { returns(T.nilable(Time)) }
       attr_accessor :archived_at
 
-      sig { returns(T.any(Orb::Models::PercentageDiscount, Orb::Models::AmountDiscount)) }
+      sig { returns(T.any(Orb::PercentageDiscount, Orb::AmountDiscount)) }
       attr_accessor :discount
 
       # This allows for a coupon's discount to apply for a limited time (determined in
@@ -42,13 +44,13 @@ module Orb
         params(
           id: String,
           archived_at: T.nilable(Time),
-          discount: T.any(Orb::Models::PercentageDiscount, Orb::Internal::AnyHash, Orb::Models::AmountDiscount),
+          discount:
+            T.any(Orb::PercentageDiscount::OrHash, Orb::AmountDiscount::OrHash),
           duration_in_months: T.nilable(Integer),
           max_redemptions: T.nilable(Integer),
           redemption_code: String,
           times_redeemed: Integer
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # Also referred to as coupon_id in this documentation.
@@ -67,28 +69,34 @@ module Orb
         redemption_code:,
         # The number of times this coupon has been redeemed.
         times_redeemed:
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              id: String,
-              archived_at: T.nilable(Time),
-              discount: T.any(Orb::Models::PercentageDiscount, Orb::Models::AmountDiscount),
-              duration_in_months: T.nilable(Integer),
-              max_redemptions: T.nilable(Integer),
-              redemption_code: String,
-              times_redeemed: Integer
-            }
-          )
+        override.returns(
+          {
+            id: String,
+            archived_at: T.nilable(Time),
+            discount: T.any(Orb::PercentageDiscount, Orb::AmountDiscount),
+            duration_in_months: T.nilable(Integer),
+            max_redemptions: T.nilable(Integer),
+            redemption_code: String,
+            times_redeemed: Integer
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       module Discount
         extend Orb::Internal::Type::Union
 
-        sig { override.returns([Orb::Models::PercentageDiscount, Orb::Models::AmountDiscount]) }
-        def self.variants; end
+        Variants =
+          T.type_alias { T.any(Orb::PercentageDiscount, Orb::AmountDiscount) }
+
+        sig { override.returns(T::Array[Orb::Coupon::Discount::Variants]) }
+        def self.variants
+        end
       end
     end
   end