orb-billing 0.11.0 → 1.0.0

data/rbi/orb/models/billable_metric_tiny.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module Orb
+  module Models
+    class BillableMetricTiny < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Orb::BillableMetricTiny, Orb::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { params(id: String).returns(T.attached_class) }
+      def self.new(id:)
+      end
+
+      sig { override.returns({ id: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/billing_cycle_anchor_configuration.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module Orb
+  module Models
+    class BillingCycleAnchorConfiguration < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::BillingCycleAnchorConfiguration, Orb::Internal::AnyHash)
+        end
+
+      # The day of the month on which the billing cycle is anchored. If the maximum
+      # number of days in a month is greater than this value, the last day of the month
+      # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing
+      # period begins on the 30th.
+      sig { returns(Integer) }
+      attr_accessor :day
+
+      # The month on which the billing cycle is anchored (e.g. a quarterly price
+      # anchored in February would have cycles starting February, May, August, and
+      # November).
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :month
+
+      # The year on which the billing cycle is anchored (e.g. a 2 year billing cycle
+      # anchored on 2021 would have cycles starting on 2021, 2023, 2025, etc.).
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :year
+
+      sig do
+        params(
+          day: Integer,
+          month: T.nilable(Integer),
+          year: T.nilable(Integer)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The day of the month on which the billing cycle is anchored. If the maximum
+        # number of days in a month is greater than this value, the last day of the month
+        # is the billing cycle day (e.g. billing_cycle_day=31 for April means the billing
+        # period begins on the 30th.
+        day:,
+        # The month on which the billing cycle is anchored (e.g. a quarterly price
+        # anchored in February would have cycles starting February, May, August, and
+        # November).
+        month: nil,
+        # The year on which the billing cycle is anchored (e.g. a 2 year billing cycle
+        # anchored on 2021 would have cycles starting on 2021, 2023, 2025, etc.).
+        year: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { day: Integer, month: T.nilable(Integer), year: T.nilable(Integer) }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/billing_cycle_configuration.rbi

@@ -0,0 +1,70 @@
+# typed: strong
+
+module Orb
+  module Models
+    class BillingCycleConfiguration < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::BillingCycleConfiguration, Orb::Internal::AnyHash)
+        end
+
+      sig { returns(Integer) }
+      attr_accessor :duration
+
+      sig do
+        returns(Orb::BillingCycleConfiguration::DurationUnit::TaggedSymbol)
+      end
+      attr_accessor :duration_unit
+
+      sig do
+        params(
+          duration: Integer,
+          duration_unit: Orb::BillingCycleConfiguration::DurationUnit::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(duration:, duration_unit:)
+      end
+
+      sig do
+        override.returns(
+          {
+            duration: Integer,
+            duration_unit:
+              Orb::BillingCycleConfiguration::DurationUnit::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module DurationUnit
+        extend Orb::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Orb::BillingCycleConfiguration::DurationUnit)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        DAY =
+          T.let(
+            :day,
+            Orb::BillingCycleConfiguration::DurationUnit::TaggedSymbol
+          )
+        MONTH =
+          T.let(
+            :month,
+            Orb::BillingCycleConfiguration::DurationUnit::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Orb::BillingCycleConfiguration::DurationUnit::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/orb/models/bps_config.rbi

@@ -0,0 +1,36 @@
+# typed: strong
+
+module Orb
+  module Models
+    class BPSConfig < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::BPSConfig, Orb::Internal::AnyHash) }
+
+      # Basis point take rate per event
+      sig { returns(Float) }
+      attr_accessor :bps
+
+      # Optional currency amount maximum to cap spend per event
+      sig { returns(T.nilable(String)) }
+      attr_accessor :per_unit_maximum
+
+      sig do
+        params(bps: Float, per_unit_maximum: T.nilable(String)).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # Basis point take rate per event
+        bps:,
+        # Optional currency amount maximum to cap spend per event
+        per_unit_maximum: nil
+      )
+      end
+
+      sig do
+        override.returns({ bps: Float, per_unit_maximum: T.nilable(String) })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/bps_tier.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module Orb
+  module Models
+    class BPSTier < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::BPSTier, Orb::Internal::AnyHash) }
+
+      # Per-event basis point rate
+      sig { returns(Float) }
+      attr_accessor :bps
+
+      # Exclusive tier starting value
+      sig { returns(String) }
+      attr_accessor :minimum_amount
+
+      # Inclusive tier ending value
+      sig { returns(T.nilable(String)) }
+      attr_accessor :maximum_amount
+
+      # Per unit maximum to charge
+      sig { returns(T.nilable(String)) }
+      attr_accessor :per_unit_maximum
+
+      sig do
+        params(
+          bps: Float,
+          minimum_amount: String,
+          maximum_amount: T.nilable(String),
+          per_unit_maximum: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Per-event basis point rate
+        bps:,
+        # Exclusive tier starting value
+        minimum_amount:,
+        # Inclusive tier ending value
+        maximum_amount: nil,
+        # Per unit maximum to charge
+        per_unit_maximum: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            bps: Float,
+            minimum_amount: String,
+            maximum_amount: T.nilable(String),
+            per_unit_maximum: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/bulk_bps_config.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Orb
+  module Models
+    class BulkBPSConfig < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Orb::BulkBPSConfig, Orb::Internal::AnyHash) }
+
+      # Tiers for a bulk BPS pricing model where all usage is aggregated to a single
+      # tier based on total volume
+      sig { returns(T::Array[Orb::BulkBPSTier]) }
+      attr_accessor :tiers
+
+      sig do
+        params(tiers: T::Array[Orb::BulkBPSTier::OrHash]).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # Tiers for a bulk BPS pricing model where all usage is aggregated to a single
+        # tier based on total volume
+        tiers:
+      )
+      end
+
+      sig { override.returns({ tiers: T::Array[Orb::BulkBPSTier] }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/bulk_bps_tier.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Orb
+  module Models
+    class BulkBPSTier < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::BulkBPSTier, Orb::Internal::AnyHash) }
+
+      # Basis points to rate on
+      sig { returns(Float) }
+      attr_accessor :bps
+
+      # Upper bound for tier
+      sig { returns(T.nilable(String)) }
+      attr_accessor :maximum_amount
+
+      # The maximum amount to charge for any one event
+      sig { returns(T.nilable(String)) }
+      attr_accessor :per_unit_maximum
+
+      sig do
+        params(
+          bps: Float,
+          maximum_amount: T.nilable(String),
+          per_unit_maximum: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Basis points to rate on
+        bps:,
+        # Upper bound for tier
+        maximum_amount: nil,
+        # The maximum amount to charge for any one event
+        per_unit_maximum: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            bps: Float,
+            maximum_amount: T.nilable(String),
+            per_unit_maximum: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/bulk_config.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Orb
+  module Models
+    class BulkConfig < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::BulkConfig, Orb::Internal::AnyHash) }
+
+      # Bulk tiers for rating based on total usage volume
+      sig { returns(T::Array[Orb::BulkTier]) }
+      attr_accessor :tiers
+
+      sig do
+        params(tiers: T::Array[Orb::BulkTier::OrHash]).returns(T.attached_class)
+      end
+      def self.new(
+        # Bulk tiers for rating based on total usage volume
+        tiers:
+      )
+      end
+
+      sig { override.returns({ tiers: T::Array[Orb::BulkTier] }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/bulk_tier.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Orb
+  module Models
+    class BulkTier < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Orb::BulkTier, Orb::Internal::AnyHash) }
+
+      # Amount per unit
+      sig { returns(String) }
+      attr_accessor :unit_amount
+
+      # Upper bound for this tier
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :maximum_units
+
+      sig do
+        params(unit_amount: String, maximum_units: T.nilable(Float)).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # Amount per unit
+        unit_amount:,
+        # Upper bound for this tier
+        maximum_units: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { unit_amount: String, maximum_units: T.nilable(Float) }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/changed_subscription_resources.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module Orb
+  module Models
+    class ChangedSubscriptionResources < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::ChangedSubscriptionResources, Orb::Internal::AnyHash)
+        end
+
+      # The credit notes that were created as part of this operation.
+      sig { returns(T::Array[Orb::CreditNote]) }
+      attr_accessor :created_credit_notes
+
+      # The invoices that were created as part of this operation.
+      sig { returns(T::Array[Orb::Invoice]) }
+      attr_accessor :created_invoices
+
+      # The credit notes that were voided as part of this operation.
+      sig { returns(T::Array[Orb::CreditNote]) }
+      attr_accessor :voided_credit_notes
+
+      # The invoices that were voided as part of this operation.
+      sig { returns(T::Array[Orb::Invoice]) }
+      attr_accessor :voided_invoices
+
+      sig do
+        params(
+          created_credit_notes: T::Array[Orb::CreditNote::OrHash],
+          created_invoices: T::Array[Orb::Invoice::OrHash],
+          voided_credit_notes: T::Array[Orb::CreditNote::OrHash],
+          voided_invoices: T::Array[Orb::Invoice::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The credit notes that were created as part of this operation.
+        created_credit_notes:,
+        # The invoices that were created as part of this operation.
+        created_invoices:,
+        # The credit notes that were voided as part of this operation.
+        voided_credit_notes:,
+        # The invoices that were voided as part of this operation.
+        voided_invoices:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            created_credit_notes: T::Array[Orb::CreditNote],
+            created_invoices: T::Array[Orb::Invoice],
+            voided_credit_notes: T::Array[Orb::CreditNote],
+            voided_invoices: T::Array[Orb::Invoice]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/conversion_rate_tier.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Orb
+  module Models
+    class ConversionRateTier < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Orb::ConversionRateTier, Orb::Internal::AnyHash) }
+
+      # Exclusive tier starting value
+      sig { returns(Float) }
+      attr_accessor :first_unit
+
+      # Amount per unit of overage
+      sig { returns(String) }
+      attr_accessor :unit_amount
+
+      # Inclusive tier ending value. If null, this is treated as the last tier
+      sig { returns(T.nilable(Float)) }
+      attr_accessor :last_unit
+
+      sig do
+        params(
+          first_unit: Float,
+          unit_amount: String,
+          last_unit: T.nilable(Float)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Exclusive tier starting value
+        first_unit:,
+        # Amount per unit of overage
+        unit_amount:,
+        # Inclusive tier ending value. If null, this is treated as the last tier
+        last_unit: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            first_unit: Float,
+            unit_amount: String,
+            last_unit: T.nilable(Float)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/conversion_rate_tiered_config.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Orb
+  module Models
+    class ConversionRateTieredConfig < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::ConversionRateTieredConfig, Orb::Internal::AnyHash)
+        end
+
+      # Tiers for rating based on total usage quantities into the specified tier
+      sig { returns(T::Array[Orb::ConversionRateTier]) }
+      attr_accessor :tiers
+
+      sig do
+        params(tiers: T::Array[Orb::ConversionRateTier::OrHash]).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # Tiers for rating based on total usage quantities into the specified tier
+        tiers:
+      )
+      end
+
+      sig { override.returns({ tiers: T::Array[Orb::ConversionRateTier] }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/conversion_rate_unit_config.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Orb
+  module Models
+    class ConversionRateUnitConfig < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Orb::ConversionRateUnitConfig, Orb::Internal::AnyHash)
+        end
+
+      # Amount per unit of overage
+      sig { returns(String) }
+      attr_accessor :unit_amount
+
+      sig { params(unit_amount: String).returns(T.attached_class) }
+      def self.new(
+        # Amount per unit of overage
+        unit_amount:
+      )
+      end
+
+      sig { override.returns({ unit_amount: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/orb/models/coupon_redemption.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module Orb
+  module Models
+    class CouponRedemption < Orb::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Orb::CouponRedemption, Orb::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :coupon_id
+
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :end_date
+
+      sig { returns(Time) }
+      attr_accessor :start_date
+
+      sig do
+        params(
+          coupon_id: String,
+          end_date: T.nilable(Time),
+          start_date: Time
+        ).returns(T.attached_class)
+      end
+      def self.new(coupon_id:, end_date:, start_date:)
+      end
+
+      sig do
+        override.returns(
+          { coupon_id: String, end_date: T.nilable(Time), start_date: Time }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end