metronome-sdk 0.1.0.pre.alpha.3 → 0.1.0.pre.alpha.4

data/rbi/metronome_sdk/models/pro_service.rbi

@@ -0,0 +1,98 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    class ProService < MetronomeSDK::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(MetronomeSDK::ProService, MetronomeSDK::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Maximum amount for the term.
+      sig { returns(Float) }
+      attr_accessor :max_amount
+
+      sig { returns(String) }
+      attr_accessor :product_id
+
+      # Quantity for the charge. Will be multiplied by unit_price to determine the
+      # amount.
+      sig { returns(Float) }
+      attr_accessor :quantity
+
+      # Unit price for the charge. Will be multiplied by quantity to determine the
+      # amount and must be specified.
+      sig { returns(Float) }
+      attr_accessor :unit_price
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :custom_fields
+
+      sig { params(custom_fields: T::Hash[Symbol, String]).void }
+      attr_writer :custom_fields
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :description
+
+      sig { params(description: String).void }
+      attr_writer :description
+
+      # This field's availability is dependent on your client's configuration.
+      sig { returns(T.nilable(String)) }
+      attr_reader :netsuite_sales_order_id
+
+      sig { params(netsuite_sales_order_id: String).void }
+      attr_writer :netsuite_sales_order_id
+
+      sig do
+        params(
+          id: String,
+          max_amount: Float,
+          product_id: String,
+          quantity: Float,
+          unit_price: Float,
+          custom_fields: T::Hash[Symbol, String],
+          description: String,
+          netsuite_sales_order_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        # Maximum amount for the term.
+        max_amount:,
+        product_id:,
+        # Quantity for the charge. Will be multiplied by unit_price to determine the
+        # amount.
+        quantity:,
+        # Unit price for the charge. Will be multiplied by quantity to determine the
+        # amount and must be specified.
+        unit_price:,
+        custom_fields: nil,
+        description: nil,
+        # This field's availability is dependent on your client's configuration.
+        netsuite_sales_order_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            max_amount: Float,
+            product_id: String,
+            quantity: Float,
+            unit_price: Float,
+            custom_fields: T::Hash[Symbol, String],
+            description: String,
+            netsuite_sales_order_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/property_filter.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    class PropertyFilter < MetronomeSDK::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(MetronomeSDK::PropertyFilter, MetronomeSDK::Internal::AnyHash)
+        end
+
+      # The name of the event property.
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Determines whether the property must exist in the event. If true, only events
+      # with this property will pass the filter. If false, only events without this
+      # property will pass the filter. If null or omitted, the existence of the property
+      # is optional.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :exists
+
+      sig { params(exists: T::Boolean).void }
+      attr_writer :exists
+
+      # Specifies the allowed values for the property to match an event. An event will
+      # pass the filter only if its property value is included in this list. If
+      # undefined, all property values will pass the filter. Must be non-empty if
+      # present.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :in_values
+
+      sig { params(in_values: T::Array[String]).void }
+      attr_writer :in_values
+
+      # Specifies the values that prevent an event from matching the filter. An event
+      # will not pass the filter if its property value is included in this list. If null
+      # or empty, all property values will pass the filter. Must be non-empty if
+      # present.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :not_in_values
+
+      sig { params(not_in_values: T::Array[String]).void }
+      attr_writer :not_in_values
+
+      sig do
+        params(
+          name: String,
+          exists: T::Boolean,
+          in_values: T::Array[String],
+          not_in_values: T::Array[String]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The name of the event property.
+        name:,
+        # Determines whether the property must exist in the event. If true, only events
+        # with this property will pass the filter. If false, only events without this
+        # property will pass the filter. If null or omitted, the existence of the property
+        # is optional.
+        exists: nil,
+        # Specifies the allowed values for the property to match an event. An event will
+        # pass the filter only if its property value is included in this list. If
+        # undefined, all property values will pass the filter. Must be non-empty if
+        # present.
+        in_values: nil,
+        # Specifies the values that prevent an event from matching the filter. An event
+        # will not pass the filter if its property value is included in this list. If null
+        # or empty, all property values will pass the filter. Must be non-empty if
+        # present.
+        not_in_values: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            name: String,
+            exists: T::Boolean,
+            in_values: T::Array[String],
+            not_in_values: T::Array[String]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/rate.rbi

@@ -0,0 +1,155 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    class Rate < MetronomeSDK::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(MetronomeSDK::Rate, MetronomeSDK::Internal::AnyHash)
+        end
+
+      sig { returns(MetronomeSDK::Rate::RateType::TaggedSymbol) }
+      attr_accessor :rate_type
+
+      sig { returns(T.nilable(MetronomeSDK::CreditTypeData)) }
+      attr_reader :credit_type
+
+      sig { params(credit_type: MetronomeSDK::CreditTypeData::OrHash).void }
+      attr_writer :credit_type
+
+      # Only set for CUSTOM rate_type. This field is interpreted by custom rate
+      # processors.
+      sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+      attr_reader :custom_rate
+
+      sig { params(custom_rate: T::Hash[Symbol, T.anything]).void }
+      attr_writer :custom_rate
+
+      # Default proration configuration. Only valid for SUBSCRIPTION rate_type. Must be
+      # set to true.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_prorated
+
+      sig { params(is_prorated: T::Boolean).void }
+      attr_writer :is_prorated
+
+      # Default price. For FLAT rate_type, this must be >=0. For PERCENTAGE rate_type,
+      # this is a decimal fraction, e.g. use 0.1 for 10%; this must be >=0 and <=1.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :price
+
+      sig { params(price: Float).void }
+      attr_writer :price
+
+      # if pricing groups are used, this will contain the values used to calculate the
+      # price
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :pricing_group_values
+
+      sig { params(pricing_group_values: T::Hash[Symbol, String]).void }
+      attr_writer :pricing_group_values
+
+      # Default quantity. For SUBSCRIPTION rate_type, this must be >=0.
+      sig { returns(T.nilable(Float)) }
+      attr_reader :quantity
+
+      sig { params(quantity: Float).void }
+      attr_writer :quantity
+
+      # Only set for TIERED rate_type.
+      sig { returns(T.nilable(T::Array[MetronomeSDK::Tier])) }
+      attr_reader :tiers
+
+      sig { params(tiers: T::Array[MetronomeSDK::Tier::OrHash]).void }
+      attr_writer :tiers
+
+      # Only set for PERCENTAGE rate_type. Defaults to false. If true, rate is computed
+      # using list prices rather than the standard rates for this product on the
+      # contract.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :use_list_prices
+
+      sig { params(use_list_prices: T::Boolean).void }
+      attr_writer :use_list_prices
+
+      sig do
+        params(
+          rate_type: MetronomeSDK::Rate::RateType::OrSymbol,
+          credit_type: MetronomeSDK::CreditTypeData::OrHash,
+          custom_rate: T::Hash[Symbol, T.anything],
+          is_prorated: T::Boolean,
+          price: Float,
+          pricing_group_values: T::Hash[Symbol, String],
+          quantity: Float,
+          tiers: T::Array[MetronomeSDK::Tier::OrHash],
+          use_list_prices: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        rate_type:,
+        credit_type: nil,
+        # Only set for CUSTOM rate_type. This field is interpreted by custom rate
+        # processors.
+        custom_rate: nil,
+        # Default proration configuration. Only valid for SUBSCRIPTION rate_type. Must be
+        # set to true.
+        is_prorated: nil,
+        # Default price. For FLAT rate_type, this must be >=0. For PERCENTAGE rate_type,
+        # this is a decimal fraction, e.g. use 0.1 for 10%; this must be >=0 and <=1.
+        price: nil,
+        # if pricing groups are used, this will contain the values used to calculate the
+        # price
+        pricing_group_values: nil,
+        # Default quantity. For SUBSCRIPTION rate_type, this must be >=0.
+        quantity: nil,
+        # Only set for TIERED rate_type.
+        tiers: nil,
+        # Only set for PERCENTAGE rate_type. Defaults to false. If true, rate is computed
+        # using list prices rather than the standard rates for this product on the
+        # contract.
+        use_list_prices: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            rate_type: MetronomeSDK::Rate::RateType::TaggedSymbol,
+            credit_type: MetronomeSDK::CreditTypeData,
+            custom_rate: T::Hash[Symbol, T.anything],
+            is_prorated: T::Boolean,
+            price: Float,
+            pricing_group_values: T::Hash[Symbol, String],
+            quantity: Float,
+            tiers: T::Array[MetronomeSDK::Tier],
+            use_list_prices: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module RateType
+        extend MetronomeSDK::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, MetronomeSDK::Rate::RateType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        FLAT = T.let(:FLAT, MetronomeSDK::Rate::RateType::TaggedSymbol)
+        PERCENTAGE =
+          T.let(:PERCENTAGE, MetronomeSDK::Rate::RateType::TaggedSymbol)
+        SUBSCRIPTION =
+          T.let(:SUBSCRIPTION, MetronomeSDK::Rate::RateType::TaggedSymbol)
+        CUSTOM = T.let(:CUSTOM, MetronomeSDK::Rate::RateType::TaggedSymbol)
+        TIERED = T.let(:TIERED, MetronomeSDK::Rate::RateType::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[MetronomeSDK::Rate::RateType::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/schedule_duration.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    class ScheduleDuration < MetronomeSDK::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(MetronomeSDK::ScheduleDuration, MetronomeSDK::Internal::AnyHash)
+        end
+
+      sig { returns(T::Array[MetronomeSDK::ScheduleDuration::ScheduleItem]) }
+      attr_accessor :schedule_items
+
+      sig { returns(T.nilable(MetronomeSDK::CreditTypeData)) }
+      attr_reader :credit_type
+
+      sig { params(credit_type: MetronomeSDK::CreditTypeData::OrHash).void }
+      attr_writer :credit_type
+
+      sig do
+        params(
+          schedule_items:
+            T::Array[MetronomeSDK::ScheduleDuration::ScheduleItem::OrHash],
+          credit_type: MetronomeSDK::CreditTypeData::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(schedule_items:, credit_type: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            schedule_items:
+              T::Array[MetronomeSDK::ScheduleDuration::ScheduleItem],
+            credit_type: MetronomeSDK::CreditTypeData
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class ScheduleItem < MetronomeSDK::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              MetronomeSDK::ScheduleDuration::ScheduleItem,
+              MetronomeSDK::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(Float) }
+        attr_accessor :amount
+
+        sig { returns(Time) }
+        attr_accessor :ending_before
+
+        sig { returns(Time) }
+        attr_accessor :starting_at
+
+        sig do
+          params(
+            id: String,
+            amount: Float,
+            ending_before: Time,
+            starting_at: Time
+          ).returns(T.attached_class)
+        end
+        def self.new(id:, amount:, ending_before:, starting_at:)
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              amount: Float,
+              ending_before: Time,
+              starting_at: Time
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/schedule_point_in_time.rbi

@@ -0,0 +1,121 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    class SchedulePointInTime < MetronomeSDK::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            MetronomeSDK::SchedulePointInTime,
+            MetronomeSDK::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(MetronomeSDK::CreditTypeData)) }
+      attr_reader :credit_type
+
+      sig { params(credit_type: MetronomeSDK::CreditTypeData::OrHash).void }
+      attr_writer :credit_type
+
+      sig do
+        returns(
+          T.nilable(T::Array[MetronomeSDK::SchedulePointInTime::ScheduleItem])
+        )
+      end
+      attr_reader :schedule_items
+
+      sig do
+        params(
+          schedule_items:
+            T::Array[MetronomeSDK::SchedulePointInTime::ScheduleItem::OrHash]
+        ).void
+      end
+      attr_writer :schedule_items
+
+      sig do
+        params(
+          credit_type: MetronomeSDK::CreditTypeData::OrHash,
+          schedule_items:
+            T::Array[MetronomeSDK::SchedulePointInTime::ScheduleItem::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(credit_type: nil, schedule_items: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            credit_type: MetronomeSDK::CreditTypeData,
+            schedule_items:
+              T::Array[MetronomeSDK::SchedulePointInTime::ScheduleItem]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class ScheduleItem < MetronomeSDK::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              MetronomeSDK::SchedulePointInTime::ScheduleItem,
+              MetronomeSDK::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(Float) }
+        attr_accessor :amount
+
+        sig { returns(Float) }
+        attr_accessor :quantity
+
+        sig { returns(Time) }
+        attr_accessor :timestamp
+
+        sig { returns(Float) }
+        attr_accessor :unit_price
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :invoice_id
+
+        sig do
+          params(
+            id: String,
+            amount: Float,
+            quantity: Float,
+            timestamp: Time,
+            unit_price: Float,
+            invoice_id: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          amount:,
+          quantity:,
+          timestamp:,
+          unit_price:,
+          invoice_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              amount: Float,
+              quantity: Float,
+              timestamp: Time,
+              unit_price: Float,
+              invoice_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/scheduled_charge.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    class ScheduledCharge < MetronomeSDK::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(MetronomeSDK::ScheduledCharge, MetronomeSDK::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(MetronomeSDK::ScheduledCharge::Product) }
+      attr_reader :product
+
+      sig do
+        params(product: MetronomeSDK::ScheduledCharge::Product::OrHash).void
+      end
+      attr_writer :product
+
+      sig { returns(MetronomeSDK::SchedulePointInTime) }
+      attr_reader :schedule
+
+      sig { params(schedule: MetronomeSDK::SchedulePointInTime::OrHash).void }
+      attr_writer :schedule
+
+      sig { returns(T.nilable(Time)) }
+      attr_reader :archived_at
+
+      sig { params(archived_at: Time).void }
+      attr_writer :archived_at
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :custom_fields
+
+      sig { params(custom_fields: T::Hash[Symbol, String]).void }
+      attr_writer :custom_fields
+
+      # displayed on invoices
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      # This field's availability is dependent on your client's configuration.
+      sig { returns(T.nilable(String)) }
+      attr_reader :netsuite_sales_order_id
+
+      sig { params(netsuite_sales_order_id: String).void }
+      attr_writer :netsuite_sales_order_id
+
+      sig do
+        params(
+          id: String,
+          product: MetronomeSDK::ScheduledCharge::Product::OrHash,
+          schedule: MetronomeSDK::SchedulePointInTime::OrHash,
+          archived_at: Time,
+          custom_fields: T::Hash[Symbol, String],
+          name: String,
+          netsuite_sales_order_id: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        product:,
+        schedule:,
+        archived_at: nil,
+        custom_fields: nil,
+        # displayed on invoices
+        name: nil,
+        # This field's availability is dependent on your client's configuration.
+        netsuite_sales_order_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            product: MetronomeSDK::ScheduledCharge::Product,
+            schedule: MetronomeSDK::SchedulePointInTime,
+            archived_at: Time,
+            custom_fields: T::Hash[Symbol, String],
+            name: String,
+            netsuite_sales_order_id: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Product < MetronomeSDK::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              MetronomeSDK::ScheduledCharge::Product,
+              MetronomeSDK::Internal::AnyHash
+            )
+          end
+
+        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
+    end
+  end
+end

data/rbi/metronome_sdk/models/tier.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    class Tier < MetronomeSDK::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(MetronomeSDK::Tier, MetronomeSDK::Internal::AnyHash)
+        end
+
+      sig { returns(Float) }
+      attr_accessor :price
+
+      sig { returns(T.nilable(Float)) }
+      attr_reader :size
+
+      sig { params(size: Float).void }
+      attr_writer :size
+
+      sig { params(price: Float, size: Float).returns(T.attached_class) }
+      def self.new(price:, size: nil)
+      end
+
+      sig { override.returns({ price: Float, size: Float }) }
+      def to_hash
+      end
+    end
+  end
+end