metronome-sdk 0.1.0.pre.alpha.1

data/rbi/metronome_sdk/models/pro_service.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    class ProService < MetronomeSDK::Internal::Type::BaseModel
+      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,75 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    class PropertyFilter < MetronomeSDK::Internal::Type::BaseModel
+      # 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,143 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    class Rate < MetronomeSDK::Internal::Type::BaseModel
+      sig { returns(MetronomeSDK::Models::Rate::RateType::TaggedSymbol) }
+      attr_accessor :rate_type
+
+      sig { returns(T.nilable(MetronomeSDK::Models::CreditTypeData)) }
+      attr_reader :credit_type
+
+      sig { params(credit_type: T.any(MetronomeSDK::Models::CreditTypeData, MetronomeSDK::Internal::AnyHash)).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::Models::Tier])) }
+      attr_reader :tiers
+
+      sig { params(tiers: T::Array[T.any(MetronomeSDK::Models::Tier, MetronomeSDK::Internal::AnyHash)]).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::Models::Rate::RateType::OrSymbol,
+          credit_type: T.any(MetronomeSDK::Models::CreditTypeData, MetronomeSDK::Internal::AnyHash),
+          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[T.any(MetronomeSDK::Models::Tier, MetronomeSDK::Internal::AnyHash)],
+          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::Models::Rate::RateType::TaggedSymbol,
+              credit_type: MetronomeSDK::Models::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::Models::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::Models::Rate::RateType) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        FLAT = T.let(:FLAT, MetronomeSDK::Models::Rate::RateType::TaggedSymbol)
+        PERCENTAGE = T.let(:PERCENTAGE, MetronomeSDK::Models::Rate::RateType::TaggedSymbol)
+        SUBSCRIPTION = T.let(:SUBSCRIPTION, MetronomeSDK::Models::Rate::RateType::TaggedSymbol)
+        CUSTOM = T.let(:CUSTOM, MetronomeSDK::Models::Rate::RateType::TaggedSymbol)
+        TIERED = T.let(:TIERED, MetronomeSDK::Models::Rate::RateType::TaggedSymbol)
+
+        sig { override.returns(T::Array[MetronomeSDK::Models::Rate::RateType::TaggedSymbol]) }
+        def self.values; end
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/schedule_duration.rbi

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

data/rbi/metronome_sdk/models/schedule_point_in_time.rbi

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

data/rbi/metronome_sdk/models/scheduled_charge.rbi

@@ -0,0 +1,104 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    class ScheduledCharge < MetronomeSDK::Internal::Type::BaseModel
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(MetronomeSDK::Models::ScheduledCharge::Product) }
+      attr_reader :product
+
+      sig do
+        params(product: T.any(MetronomeSDK::Models::ScheduledCharge::Product, MetronomeSDK::Internal::AnyHash))
+          .void
+      end
+      attr_writer :product
+
+      sig { returns(MetronomeSDK::Models::SchedulePointInTime) }
+      attr_reader :schedule
+
+      sig { params(schedule: T.any(MetronomeSDK::Models::SchedulePointInTime, MetronomeSDK::Internal::AnyHash)).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: T.any(MetronomeSDK::Models::ScheduledCharge::Product, MetronomeSDK::Internal::AnyHash),
+          schedule: T.any(MetronomeSDK::Models::SchedulePointInTime, MetronomeSDK::Internal::AnyHash),
+          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::Models::ScheduledCharge::Product,
+              schedule: MetronomeSDK::Models::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
+        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,22 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    class Tier < MetronomeSDK::Internal::Type::BaseModel
+      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

data/rbi/metronome_sdk/models/v1/alert_archive_params.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    module V1
+      class AlertArchiveParams < MetronomeSDK::Internal::Type::BaseModel
+        extend MetronomeSDK::Internal::Type::RequestParameters::Converter
+        include MetronomeSDK::Internal::Type::RequestParameters
+
+        # The Metronome ID of the alert
+        sig { returns(String) }
+        attr_accessor :id
+
+        # If true, resets the uniqueness key on this alert so it can be re-used
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :release_uniqueness_key
+
+        sig { params(release_uniqueness_key: T::Boolean).void }
+        attr_writer :release_uniqueness_key
+
+        sig do
+          params(
+            id: String,
+            release_uniqueness_key: T::Boolean,
+            request_options: T.any(MetronomeSDK::RequestOptions, MetronomeSDK::Internal::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          # The Metronome ID of the alert
+          id:,
+          # If true, resets the uniqueness key on this alert so it can be re-used
+          release_uniqueness_key: nil,
+          request_options: {}
+        ); end
+        sig do
+          override
+            .returns({
+                       id: String,
+                       release_uniqueness_key: T::Boolean,
+                       request_options: MetronomeSDK::RequestOptions
+                     })
+        end
+        def to_hash; end
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/v1/alert_archive_response.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    module V1
+      class AlertArchiveResponse < MetronomeSDK::Internal::Type::BaseModel
+        sig { returns(MetronomeSDK::Models::ID) }
+        attr_reader :data
+
+        sig { params(data: T.any(MetronomeSDK::Models::ID, MetronomeSDK::Internal::AnyHash)).void }
+        attr_writer :data
+
+        sig { params(data: T.any(MetronomeSDK::Models::ID, MetronomeSDK::Internal::AnyHash)).returns(T.attached_class) }
+        def self.new(data:); end
+
+        sig { override.returns({data: MetronomeSDK::Models::ID}) }
+        def to_hash; end
+      end
+    end
+  end
+end