orb-billing 0.3.0 → 0.3.2

data/rbi/orb/models/customers/balance_transaction_list_response.rbi

@@ -0,0 +1,301 @@
+# typed: strong
+
+module Orb
+  module Models
+    module Customers
+      class BalanceTransactionListResponse < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
+        # A unique id for this transaction.
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig do
+          returns(
+            Orb::Models::Customers::BalanceTransactionListResponse::Action::TaggedSymbol
+          )
+        end
+        attr_accessor :action
+
+        # The value of the amount changed in the transaction.
+        sig { returns(String) }
+        attr_accessor :amount
+
+        # The creation time of this transaction.
+        sig { returns(Time) }
+        attr_accessor :created_at
+
+        sig do
+          returns(
+            T.nilable(
+              Orb::Models::Customers::BalanceTransactionListResponse::CreditNote
+            )
+          )
+        end
+        attr_reader :credit_note
+
+        sig do
+          params(
+            credit_note:
+              T.nilable(
+                Orb::Models::Customers::BalanceTransactionListResponse::CreditNote::OrHash
+              )
+          ).void
+        end
+        attr_writer :credit_note
+
+        # An optional description provided for manual customer balance adjustments.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :description
+
+        # The new value of the customer's balance prior to the transaction, in the
+        # customer's currency.
+        sig { returns(String) }
+        attr_accessor :ending_balance
+
+        sig do
+          returns(
+            T.nilable(
+              Orb::Models::Customers::BalanceTransactionListResponse::Invoice
+            )
+          )
+        end
+        attr_reader :invoice
+
+        sig do
+          params(
+            invoice:
+              T.nilable(
+                Orb::Models::Customers::BalanceTransactionListResponse::Invoice::OrHash
+              )
+          ).void
+        end
+        attr_writer :invoice
+
+        # The original value of the customer's balance prior to the transaction, in the
+        # customer's currency.
+        sig { returns(String) }
+        attr_accessor :starting_balance
+
+        sig do
+          returns(
+            Orb::Models::Customers::BalanceTransactionListResponse::Type::TaggedSymbol
+          )
+        end
+        attr_accessor :type
+
+        sig do
+          params(
+            id: String,
+            action:
+              Orb::Models::Customers::BalanceTransactionListResponse::Action::OrSymbol,
+            amount: String,
+            created_at: Time,
+            credit_note:
+              T.nilable(
+                Orb::Models::Customers::BalanceTransactionListResponse::CreditNote::OrHash
+              ),
+            description: T.nilable(String),
+            ending_balance: String,
+            invoice:
+              T.nilable(
+                Orb::Models::Customers::BalanceTransactionListResponse::Invoice::OrHash
+              ),
+            starting_balance: String,
+            type:
+              Orb::Models::Customers::BalanceTransactionListResponse::Type::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A unique id for this transaction.
+          id:,
+          action:,
+          # The value of the amount changed in the transaction.
+          amount:,
+          # The creation time of this transaction.
+          created_at:,
+          credit_note:,
+          # An optional description provided for manual customer balance adjustments.
+          description:,
+          # The new value of the customer's balance prior to the transaction, in the
+          # customer's currency.
+          ending_balance:,
+          invoice:,
+          # The original value of the customer's balance prior to the transaction, in the
+          # customer's currency.
+          starting_balance:,
+          type:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              action:
+                Orb::Models::Customers::BalanceTransactionListResponse::Action::TaggedSymbol,
+              amount: String,
+              created_at: Time,
+              credit_note:
+                T.nilable(
+                  Orb::Models::Customers::BalanceTransactionListResponse::CreditNote
+                ),
+              description: T.nilable(String),
+              ending_balance: String,
+              invoice:
+                T.nilable(
+                  Orb::Models::Customers::BalanceTransactionListResponse::Invoice
+                ),
+              starting_balance: String,
+              type:
+                Orb::Models::Customers::BalanceTransactionListResponse::Type::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Action
+          extend Orb::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Orb::Models::Customers::BalanceTransactionListResponse::Action
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          APPLIED_TO_INVOICE =
+            T.let(
+              :applied_to_invoice,
+              Orb::Models::Customers::BalanceTransactionListResponse::Action::TaggedSymbol
+            )
+          MANUAL_ADJUSTMENT =
+            T.let(
+              :manual_adjustment,
+              Orb::Models::Customers::BalanceTransactionListResponse::Action::TaggedSymbol
+            )
+          PRORATED_REFUND =
+            T.let(
+              :prorated_refund,
+              Orb::Models::Customers::BalanceTransactionListResponse::Action::TaggedSymbol
+            )
+          REVERT_PRORATED_REFUND =
+            T.let(
+              :revert_prorated_refund,
+              Orb::Models::Customers::BalanceTransactionListResponse::Action::TaggedSymbol
+            )
+          RETURN_FROM_VOIDING =
+            T.let(
+              :return_from_voiding,
+              Orb::Models::Customers::BalanceTransactionListResponse::Action::TaggedSymbol
+            )
+          CREDIT_NOTE_APPLIED =
+            T.let(
+              :credit_note_applied,
+              Orb::Models::Customers::BalanceTransactionListResponse::Action::TaggedSymbol
+            )
+          CREDIT_NOTE_VOIDED =
+            T.let(
+              :credit_note_voided,
+              Orb::Models::Customers::BalanceTransactionListResponse::Action::TaggedSymbol
+            )
+          OVERPAYMENT_REFUND =
+            T.let(
+              :overpayment_refund,
+              Orb::Models::Customers::BalanceTransactionListResponse::Action::TaggedSymbol
+            )
+          EXTERNAL_PAYMENT =
+            T.let(
+              :external_payment,
+              Orb::Models::Customers::BalanceTransactionListResponse::Action::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Orb::Models::Customers::BalanceTransactionListResponse::Action::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        class CreditNote < Orb::Internal::Type::BaseModel
+          OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
+          # The id of the Credit note
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig { params(id: String).returns(T.attached_class) }
+          def self.new(
+            # The id of the Credit note
+            id:
+          )
+          end
+
+          sig { override.returns({ id: String }) }
+          def to_hash
+          end
+        end
+
+        class Invoice < Orb::Internal::Type::BaseModel
+          OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
+          # The Invoice id
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig { params(id: String).returns(T.attached_class) }
+          def self.new(
+            # The Invoice id
+            id:
+          )
+          end
+
+          sig { override.returns({ id: String }) }
+          def to_hash
+          end
+        end
+
+        module Type
+          extend Orb::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Orb::Models::Customers::BalanceTransactionListResponse::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          INCREMENT =
+            T.let(
+              :increment,
+              Orb::Models::Customers::BalanceTransactionListResponse::Type::TaggedSymbol
+            )
+          DECREMENT =
+            T.let(
+              :decrement,
+              Orb::Models::Customers::BalanceTransactionListResponse::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Orb::Models::Customers::BalanceTransactionListResponse::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/{lib/orb → orb}/models/customers/cost_list_by_external_id_params.rbi

@@ -7,6 +7,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) }
+
         # The currency or custom pricing unit to use.
         sig { returns(T.nilable(String)) }
         attr_accessor :currency
@@ -23,7 +25,13 @@ module Orb
         # 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::Customers::CostListByExternalIDParams::ViewMode::OrSymbol)) }
+        sig do
+          returns(
+            T.nilable(
+              Orb::Customers::CostListByExternalIDParams::ViewMode::OrSymbol
+            )
+          )
+        end
         attr_accessor :view_mode
 
         sig do
@@ -31,10 +39,12 @@ module Orb
             currency: T.nilable(String),
             timeframe_end: T.nilable(Time),
             timeframe_start: T.nilable(Time),
-            view_mode: T.nilable(Orb::Models::Customers::CostListByExternalIDParams::ViewMode::OrSymbol),
-            request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)
-          )
-            .returns(T.attached_class)
+            view_mode:
+              T.nilable(
+                Orb::Customers::CostListByExternalIDParams::ViewMode::OrSymbol
+              ),
+            request_options: Orb::RequestOptions::OrHash
+          ).returns(T.attached_class)
         end
         def self.new(
           # The currency or custom pricing unit to use.
@@ -49,20 +59,25 @@ module Orb
           # behavior.
           view_mode: nil,
           request_options: {}
-        ); end
+        )
+        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::Customers::CostListByExternalIDParams::ViewMode::OrSymbol),
-                request_options: Orb::RequestOptions
-              }
-            )
+          override.returns(
+            {
+              currency: T.nilable(String),
+              timeframe_end: T.nilable(Time),
+              timeframe_start: T.nilable(Time),
+              view_mode:
+                T.nilable(
+                  Orb::Customers::CostListByExternalIDParams::ViewMode::OrSymbol
+                ),
+              request_options: Orb::RequestOptions
+            }
+          )
+        end
+        def to_hash
         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
@@ -72,15 +87,34 @@ module Orb
           extend Orb::Internal::Type::Enum
 
           TaggedSymbol =
-            T.type_alias { T.all(Symbol, Orb::Models::Customers::CostListByExternalIDParams::ViewMode) }
+            T.type_alias do
+              T.all(
+                Symbol,
+                Orb::Customers::CostListByExternalIDParams::ViewMode
+              )
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          PERIODIC = T.let(:periodic, Orb::Models::Customers::CostListByExternalIDParams::ViewMode::TaggedSymbol)
+          PERIODIC =
+            T.let(
+              :periodic,
+              Orb::Customers::CostListByExternalIDParams::ViewMode::TaggedSymbol
+            )
           CUMULATIVE =
-            T.let(:cumulative, Orb::Models::Customers::CostListByExternalIDParams::ViewMode::TaggedSymbol)
+            T.let(
+              :cumulative,
+              Orb::Customers::CostListByExternalIDParams::ViewMode::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Orb::Models::Customers::CostListByExternalIDParams::ViewMode::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[
+                Orb::Customers::CostListByExternalIDParams::ViewMode::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
         end
       end
     end

data/rbi/orb/models/customers/cost_list_by_external_id_response.rbi

@@ -0,0 +1,263 @@
+# typed: strong
+
+module Orb
+  module Models
+    module Customers
+      class CostListByExternalIDResponse < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
+        sig do
+          returns(
+            T::Array[Orb::Models::Customers::CostListByExternalIDResponse::Data]
+          )
+        end
+        attr_accessor :data
+
+        sig do
+          params(
+            data:
+              T::Array[
+                Orb::Models::Customers::CostListByExternalIDResponse::Data::OrHash
+              ]
+          ).returns(T.attached_class)
+        end
+        def self.new(data:)
+        end
+
+        sig do
+          override.returns(
+            {
+              data:
+                T::Array[
+                  Orb::Models::Customers::CostListByExternalIDResponse::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(
+              T::Array[
+                Orb::Models::Customers::CostListByExternalIDResponse::Data::PerPriceCost
+              ]
+            )
+          end
+          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[
+                  Orb::Models::Customers::CostListByExternalIDResponse::Data::PerPriceCost::OrHash
+                ],
+              subtotal: String,
+              timeframe_end: Time,
+              timeframe_start: Time,
+              total: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            per_price_costs:,
+            # Total costs for the timeframe, excluding any minimums and discounts.
+            subtotal:,
+            timeframe_end:,
+            timeframe_start:,
+            # Total costs for the timeframe, including any minimums and discounts.
+            total:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                per_price_costs:
+                  T::Array[
+                    Orb::Models::Customers::CostListByExternalIDResponse::Data::PerPriceCost
+                  ],
+                subtotal: String,
+                timeframe_end: Time,
+                timeframe_start: Time,
+                total: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class PerPriceCost < Orb::Internal::Type::BaseModel
+            OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
+            # The price object
+            sig do
+              returns(
+                T.any(
+                  Orb::Price::Unit,
+                  Orb::Price::Package,
+                  Orb::Price::Matrix,
+                  Orb::Price::Tiered,
+                  Orb::Price::TieredBps,
+                  Orb::Price::Bps,
+                  Orb::Price::BulkBps,
+                  Orb::Price::Bulk,
+                  Orb::Price::ThresholdTotalAmount,
+                  Orb::Price::TieredPackage,
+                  Orb::Price::GroupedTiered,
+                  Orb::Price::TieredWithMinimum,
+                  Orb::Price::TieredPackageWithMinimum,
+                  Orb::Price::PackageWithAllocation,
+                  Orb::Price::UnitWithPercent,
+                  Orb::Price::MatrixWithAllocation,
+                  Orb::Price::TieredWithProration,
+                  Orb::Price::UnitWithProration,
+                  Orb::Price::GroupedAllocation,
+                  Orb::Price::GroupedWithProratedMinimum,
+                  Orb::Price::GroupedWithMeteredMinimum,
+                  Orb::Price::MatrixWithDisplayName,
+                  Orb::Price::BulkWithProration,
+                  Orb::Price::GroupedTieredPackage,
+                  Orb::Price::MaxGroupTieredPackage,
+                  Orb::Price::ScalableMatrixWithUnitPricing,
+                  Orb::Price::ScalableMatrixWithTieredPricing,
+                  Orb::Price::CumulativeGroupedBulk
+                )
+              )
+            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::Price::Unit::OrHash,
+                    Orb::Price::Package::OrHash,
+                    Orb::Price::Matrix::OrHash,
+                    Orb::Price::Tiered::OrHash,
+                    Orb::Price::TieredBps::OrHash,
+                    Orb::Price::Bps::OrHash,
+                    Orb::Price::BulkBps::OrHash,
+                    Orb::Price::Bulk::OrHash,
+                    Orb::Price::ThresholdTotalAmount::OrHash,
+                    Orb::Price::TieredPackage::OrHash,
+                    Orb::Price::GroupedTiered::OrHash,
+                    Orb::Price::TieredWithMinimum::OrHash,
+                    Orb::Price::TieredPackageWithMinimum::OrHash,
+                    Orb::Price::PackageWithAllocation::OrHash,
+                    Orb::Price::UnitWithPercent::OrHash,
+                    Orb::Price::MatrixWithAllocation::OrHash,
+                    Orb::Price::TieredWithProration::OrHash,
+                    Orb::Price::UnitWithProration::OrHash,
+                    Orb::Price::GroupedAllocation::OrHash,
+                    Orb::Price::GroupedWithProratedMinimum::OrHash,
+                    Orb::Price::GroupedWithMeteredMinimum::OrHash,
+                    Orb::Price::MatrixWithDisplayName::OrHash,
+                    Orb::Price::BulkWithProration::OrHash,
+                    Orb::Price::GroupedTieredPackage::OrHash,
+                    Orb::Price::MaxGroupTieredPackage::OrHash,
+                    Orb::Price::ScalableMatrixWithUnitPricing::OrHash,
+                    Orb::Price::ScalableMatrixWithTieredPricing::OrHash,
+                    Orb::Price::CumulativeGroupedBulk::OrHash
+                  ),
+                price_id: String,
+                subtotal: String,
+                total: String,
+                quantity: T.nilable(Float)
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # The price object
+              price:,
+              # The price the cost is associated with
+              price_id:,
+              # Price's contributions for the timeframe, excluding any minimums and discounts.
+              subtotal:,
+              # Price's contributions for the timeframe, including minimums and discounts.
+              total:,
+              # The price's quantity for the timeframe
+              quantity: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  price:
+                    T.any(
+                      Orb::Price::Unit,
+                      Orb::Price::Package,
+                      Orb::Price::Matrix,
+                      Orb::Price::Tiered,
+                      Orb::Price::TieredBps,
+                      Orb::Price::Bps,
+                      Orb::Price::BulkBps,
+                      Orb::Price::Bulk,
+                      Orb::Price::ThresholdTotalAmount,
+                      Orb::Price::TieredPackage,
+                      Orb::Price::GroupedTiered,
+                      Orb::Price::TieredWithMinimum,
+                      Orb::Price::TieredPackageWithMinimum,
+                      Orb::Price::PackageWithAllocation,
+                      Orb::Price::UnitWithPercent,
+                      Orb::Price::MatrixWithAllocation,
+                      Orb::Price::TieredWithProration,
+                      Orb::Price::UnitWithProration,
+                      Orb::Price::GroupedAllocation,
+                      Orb::Price::GroupedWithProratedMinimum,
+                      Orb::Price::GroupedWithMeteredMinimum,
+                      Orb::Price::MatrixWithDisplayName,
+                      Orb::Price::BulkWithProration,
+                      Orb::Price::GroupedTieredPackage,
+                      Orb::Price::MaxGroupTieredPackage,
+                      Orb::Price::ScalableMatrixWithUnitPricing,
+                      Orb::Price::ScalableMatrixWithTieredPricing,
+                      Orb::Price::CumulativeGroupedBulk
+                    ),
+                  price_id: String,
+                  subtotal: String,
+                  total: String,
+                  quantity: T.nilable(Float)
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end