metronome-sdk 0.1.0.pre.alpha.1

data/rbi/metronome_sdk/models/v1/contracts/rate_cards/rate_list_params.rbi

@@ -0,0 +1,169 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    module V1
+      module Contracts
+        module RateCards
+          class RateListParams < MetronomeSDK::Internal::Type::BaseModel
+            extend MetronomeSDK::Internal::Type::RequestParameters::Converter
+            include MetronomeSDK::Internal::Type::RequestParameters
+
+            # inclusive starting point for the rates schedule
+            sig { returns(Time) }
+            attr_accessor :at
+
+            # ID of the rate card to get the schedule for
+            sig { returns(String) }
+            attr_accessor :rate_card_id
+
+            # Max number of results that should be returned
+            sig { returns(T.nilable(Integer)) }
+            attr_reader :limit
+
+            sig { params(limit: Integer).void }
+            attr_writer :limit
+
+            # Cursor that indicates where the next page of results should start.
+            sig { returns(T.nilable(String)) }
+            attr_reader :next_page
+
+            sig { params(next_page: String).void }
+            attr_writer :next_page
+
+            # List of rate selectors, rates matching ANY of the selector will be included in
+            # the response Passing no selectors will result in all rates being returned.
+            sig { returns(T.nilable(T::Array[MetronomeSDK::Models::V1::Contracts::RateCards::RateListParams::Selector])) }
+            attr_reader :selectors
+
+            sig do
+              params(
+                selectors: T::Array[
+                  T.any(
+                    MetronomeSDK::Models::V1::Contracts::RateCards::RateListParams::Selector,
+                    MetronomeSDK::Internal::AnyHash
+                  )
+                ]
+              )
+                .void
+            end
+            attr_writer :selectors
+
+            sig do
+              params(
+                at: Time,
+                rate_card_id: String,
+                limit: Integer,
+                next_page: String,
+                selectors: T::Array[
+                  T.any(
+                    MetronomeSDK::Models::V1::Contracts::RateCards::RateListParams::Selector,
+                    MetronomeSDK::Internal::AnyHash
+                  )
+                ],
+                request_options: T.any(MetronomeSDK::RequestOptions, MetronomeSDK::Internal::AnyHash)
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+              # inclusive starting point for the rates schedule
+              at:,
+              # ID of the rate card to get the schedule for
+              rate_card_id:,
+              # Max number of results that should be returned
+              limit: nil,
+              # Cursor that indicates where the next page of results should start.
+              next_page: nil,
+              # List of rate selectors, rates matching ANY of the selector will be included in
+              # the response Passing no selectors will result in all rates being returned.
+              selectors: nil,
+              request_options: {}
+            ); end
+            sig do
+              override
+                .returns(
+                  {
+                    at: Time,
+                    rate_card_id: String,
+                    limit: Integer,
+                    next_page: String,
+                    selectors: T::Array[MetronomeSDK::Models::V1::Contracts::RateCards::RateListParams::Selector],
+                    request_options: MetronomeSDK::RequestOptions
+                  }
+                )
+            end
+            def to_hash; end
+
+            class Selector < MetronomeSDK::Internal::Type::BaseModel
+              # List of pricing group key value pairs, rates containing the matching key / value
+              # pairs will be included in the response.
+              sig { returns(T.nilable(T::Hash[Symbol, String])) }
+              attr_reader :partial_pricing_group_values
+
+              sig { params(partial_pricing_group_values: T::Hash[Symbol, String]).void }
+              attr_writer :partial_pricing_group_values
+
+              # List of pricing group key value pairs, rates matching all of the key / value
+              # pairs will be included in the response.
+              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
+
+              # Rates matching the product id will be included in the response.
+              sig { returns(T.nilable(String)) }
+              attr_reader :product_id
+
+              sig { params(product_id: String).void }
+              attr_writer :product_id
+
+              # List of product tags, rates matching any of the tags will be included in the
+              # response.
+              sig { returns(T.nilable(T::Array[String])) }
+              attr_reader :product_tags
+
+              sig { params(product_tags: T::Array[String]).void }
+              attr_writer :product_tags
+
+              sig do
+                params(
+                  partial_pricing_group_values: T::Hash[Symbol, String],
+                  pricing_group_values: T::Hash[Symbol, String],
+                  product_id: String,
+                  product_tags: T::Array[String]
+                )
+                  .returns(T.attached_class)
+              end
+              def self.new(
+                # List of pricing group key value pairs, rates containing the matching key / value
+                # pairs will be included in the response.
+                partial_pricing_group_values: nil,
+                # List of pricing group key value pairs, rates matching all of the key / value
+                # pairs will be included in the response.
+                pricing_group_values: nil,
+                # Rates matching the product id will be included in the response.
+                product_id: nil,
+                # List of product tags, rates matching any of the tags will be included in the
+                # response.
+                product_tags: nil
+              ); end
+              sig do
+                override
+                  .returns(
+                    {
+                      partial_pricing_group_values: T::Hash[Symbol, String],
+                      pricing_group_values: T::Hash[Symbol, String],
+                      product_id: String,
+                      product_tags: T::Array[String]
+                    }
+                  )
+              end
+              def to_hash; end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/v1/contracts/rate_cards/rate_list_response.rbi

@@ -0,0 +1,210 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    module V1
+      module Contracts
+        module RateCards
+          class RateListResponse < MetronomeSDK::Internal::Type::BaseModel
+            sig { returns(T::Boolean) }
+            attr_accessor :entitled
+
+            sig { returns(T::Hash[Symbol, String]) }
+            attr_accessor :product_custom_fields
+
+            sig { returns(String) }
+            attr_accessor :product_id
+
+            sig { returns(String) }
+            attr_accessor :product_name
+
+            sig { returns(T::Array[String]) }
+            attr_accessor :product_tags
+
+            sig { returns(MetronomeSDK::Models::Rate) }
+            attr_reader :rate
+
+            sig { params(rate: T.any(MetronomeSDK::Models::Rate, MetronomeSDK::Internal::AnyHash)).void }
+            attr_writer :rate
+
+            sig { returns(Time) }
+            attr_accessor :starting_at
+
+            # A distinct rate on the rate card. You can choose to use this rate rather than
+            # list rate when consuming a credit or commit.
+            sig { returns(T.nilable(MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate)) }
+            attr_reader :commit_rate
+
+            sig do
+              params(
+                commit_rate: T.any(
+                  MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate,
+                  MetronomeSDK::Internal::AnyHash
+                )
+              )
+                .void
+            end
+            attr_writer :commit_rate
+
+            sig { returns(T.nilable(Time)) }
+            attr_reader :ending_before
+
+            sig { params(ending_before: Time).void }
+            attr_writer :ending_before
+
+            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
+
+            sig do
+              params(
+                entitled: T::Boolean,
+                product_custom_fields: T::Hash[Symbol, String],
+                product_id: String,
+                product_name: String,
+                product_tags: T::Array[String],
+                rate: T.any(MetronomeSDK::Models::Rate, MetronomeSDK::Internal::AnyHash),
+                starting_at: Time,
+                commit_rate: T.any(
+                  MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate,
+                  MetronomeSDK::Internal::AnyHash
+                ),
+                ending_before: Time,
+                pricing_group_values: T::Hash[Symbol, String]
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+              entitled:,
+              product_custom_fields:,
+              product_id:,
+              product_name:,
+              product_tags:,
+              rate:,
+              starting_at:,
+              # A distinct rate on the rate card. You can choose to use this rate rather than
+              # list rate when consuming a credit or commit.
+              commit_rate: nil,
+              ending_before: nil,
+              pricing_group_values: nil
+            ); end
+            sig do
+              override
+                .returns(
+                  {
+                    entitled: T::Boolean,
+                    product_custom_fields: T::Hash[Symbol, String],
+                    product_id: String,
+                    product_name: String,
+                    product_tags: T::Array[String],
+                    rate: MetronomeSDK::Models::Rate,
+                    starting_at: Time,
+                    commit_rate: MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate,
+                    ending_before: Time,
+                    pricing_group_values: T::Hash[Symbol, String]
+                  }
+                )
+            end
+            def to_hash; end
+
+            class CommitRate < MetronomeSDK::Internal::Type::BaseModel
+              sig do
+                returns(
+                  MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate::RateType::TaggedSymbol
+                )
+              end
+              attr_accessor :rate_type
+
+              # Commit rate price. For FLAT rate_type, this must be >=0.
+              sig { returns(T.nilable(Float)) }
+              attr_reader :price
+
+              sig { params(price: Float).void }
+              attr_writer :price
+
+              # 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
+
+              # A distinct rate on the rate card. You can choose to use this rate rather than
+              # list rate when consuming a credit or commit.
+              sig do
+                params(
+                  rate_type: MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate::RateType::OrSymbol,
+                  price: Float,
+                  tiers: T::Array[T.any(MetronomeSDK::Models::Tier, MetronomeSDK::Internal::AnyHash)]
+                )
+                  .returns(T.attached_class)
+              end
+              def self.new(
+                rate_type:,
+                # Commit rate price. For FLAT rate_type, this must be >=0.
+                price: nil,
+                # Only set for TIERED rate_type.
+                tiers: nil
+              ); end
+              sig do
+                override
+                  .returns(
+                    {
+                      rate_type: MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate::RateType::TaggedSymbol,
+                      price: Float,
+                      tiers: T::Array[MetronomeSDK::Models::Tier]
+                    }
+                  )
+              end
+              def to_hash; end
+
+              module RateType
+                extend MetronomeSDK::Internal::Type::Enum
+
+                TaggedSymbol =
+                  T.type_alias { T.all(Symbol, MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate::RateType) }
+                OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                FLAT =
+                  T.let(
+                    :FLAT,
+                    MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate::RateType::TaggedSymbol
+                  )
+                PERCENTAGE =
+                  T.let(
+                    :PERCENTAGE,
+                    MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate::RateType::TaggedSymbol
+                  )
+                SUBSCRIPTION =
+                  T.let(
+                    :SUBSCRIPTION,
+                    MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate::RateType::TaggedSymbol
+                  )
+                TIERED =
+                  T.let(
+                    :TIERED,
+                    MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate::RateType::TaggedSymbol
+                  )
+                CUSTOM =
+                  T.let(
+                    :CUSTOM,
+                    MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate::RateType::TaggedSymbol
+                  )
+
+                sig do
+                  override
+                    .returns(
+                      T::Array[MetronomeSDK::Models::V1::Contracts::RateCards::RateListResponse::CommitRate::RateType::TaggedSymbol]
+                    )
+                end
+                def self.values; end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/v1/credit_grant_create_params.rbi

@@ -0,0 +1,316 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    module V1
+      class CreditGrantCreateParams < MetronomeSDK::Internal::Type::BaseModel
+        extend MetronomeSDK::Internal::Type::RequestParameters::Converter
+        include MetronomeSDK::Internal::Type::RequestParameters
+
+        # the Metronome ID of the customer
+        sig { returns(String) }
+        attr_accessor :customer_id
+
+        # The credit grant will only apply to usage or charges dated before this timestamp
+        sig { returns(Time) }
+        attr_accessor :expires_at
+
+        # the amount of credits granted
+        sig { returns(MetronomeSDK::Models::V1::CreditGrantCreateParams::GrantAmount) }
+        attr_reader :grant_amount
+
+        sig do
+          params(
+            grant_amount: T.any(MetronomeSDK::Models::V1::CreditGrantCreateParams::GrantAmount, MetronomeSDK::Internal::AnyHash)
+          )
+            .void
+        end
+        attr_writer :grant_amount
+
+        # the name of the credit grant as it will appear on invoices
+        sig { returns(String) }
+        attr_accessor :name
+
+        # the amount paid for this credit grant
+        sig { returns(MetronomeSDK::Models::V1::CreditGrantCreateParams::PaidAmount) }
+        attr_reader :paid_amount
+
+        sig do
+          params(
+            paid_amount: T.any(MetronomeSDK::Models::V1::CreditGrantCreateParams::PaidAmount, MetronomeSDK::Internal::AnyHash)
+          )
+            .void
+        end
+        attr_writer :paid_amount
+
+        sig { returns(Float) }
+        attr_accessor :priority
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :credit_grant_type
+
+        sig { params(credit_grant_type: String).void }
+        attr_writer :credit_grant_type
+
+        # Custom fields to attach to the credit grant.
+        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
+
+        # The credit grant will only apply to usage or charges dated on or after this
+        # timestamp
+        sig { returns(T.nilable(Time)) }
+        attr_reader :effective_at
+
+        sig { params(effective_at: Time).void }
+        attr_writer :effective_at
+
+        # The date to issue an invoice for the paid_amount.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :invoice_date
+
+        sig { params(invoice_date: Time).void }
+        attr_writer :invoice_date
+
+        # The product(s) which these credits will be applied to. (If unspecified, the
+        # credits will be applied to charges for all products.). The array ordering
+        # specified here will be used to determine the order in which credits will be
+        # applied to invoice line items
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :product_ids
+
+        sig { params(product_ids: T::Array[String]).void }
+        attr_writer :product_ids
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :reason
+
+        sig { params(reason: String).void }
+        attr_writer :reason
+
+        # Configure a rollover for this credit grant so if it expires it rolls over a
+        # configured amount to a new credit grant. This feature is currently opt-in only.
+        # Contact Metronome to be added to the beta.
+        sig { returns(T.nilable(MetronomeSDK::Models::V1::CreditGrantCreateParams::RolloverSettings)) }
+        attr_reader :rollover_settings
+
+        sig do
+          params(
+            rollover_settings: T.any(
+              MetronomeSDK::Models::V1::CreditGrantCreateParams::RolloverSettings,
+              MetronomeSDK::Internal::AnyHash
+            )
+          )
+            .void
+        end
+        attr_writer :rollover_settings
+
+        # Prevents the creation of duplicates. If a request to create a record is made
+        # with a previously used uniqueness key, a new record will not be created and the
+        # request will fail with a 409 error.
+        sig { returns(T.nilable(String)) }
+        attr_reader :uniqueness_key
+
+        sig { params(uniqueness_key: String).void }
+        attr_writer :uniqueness_key
+
+        sig do
+          params(
+            customer_id: String,
+            expires_at: Time,
+            grant_amount: T.any(MetronomeSDK::Models::V1::CreditGrantCreateParams::GrantAmount, MetronomeSDK::Internal::AnyHash),
+            name: String,
+            paid_amount: T.any(MetronomeSDK::Models::V1::CreditGrantCreateParams::PaidAmount, MetronomeSDK::Internal::AnyHash),
+            priority: Float,
+            credit_grant_type: String,
+            custom_fields: T::Hash[Symbol, String],
+            effective_at: Time,
+            invoice_date: Time,
+            product_ids: T::Array[String],
+            reason: String,
+            rollover_settings: T.any(
+              MetronomeSDK::Models::V1::CreditGrantCreateParams::RolloverSettings,
+              MetronomeSDK::Internal::AnyHash
+            ),
+            uniqueness_key: String,
+            request_options: T.any(MetronomeSDK::RequestOptions, MetronomeSDK::Internal::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          # the Metronome ID of the customer
+          customer_id:,
+          # The credit grant will only apply to usage or charges dated before this timestamp
+          expires_at:,
+          # the amount of credits granted
+          grant_amount:,
+          # the name of the credit grant as it will appear on invoices
+          name:,
+          # the amount paid for this credit grant
+          paid_amount:,
+          priority:,
+          credit_grant_type: nil,
+          # Custom fields to attach to the credit grant.
+          custom_fields: nil,
+          # The credit grant will only apply to usage or charges dated on or after this
+          # timestamp
+          effective_at: nil,
+          # The date to issue an invoice for the paid_amount.
+          invoice_date: nil,
+          # The product(s) which these credits will be applied to. (If unspecified, the
+          # credits will be applied to charges for all products.). The array ordering
+          # specified here will be used to determine the order in which credits will be
+          # applied to invoice line items
+          product_ids: nil,
+          reason: nil,
+          # Configure a rollover for this credit grant so if it expires it rolls over a
+          # configured amount to a new credit grant. This feature is currently opt-in only.
+          # Contact Metronome to be added to the beta.
+          rollover_settings: nil,
+          # Prevents the creation of duplicates. If a request to create a record is made
+          # with a previously used uniqueness key, a new record will not be created and the
+          # request will fail with a 409 error.
+          uniqueness_key: nil,
+          request_options: {}
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                customer_id: String,
+                expires_at: Time,
+                grant_amount: MetronomeSDK::Models::V1::CreditGrantCreateParams::GrantAmount,
+                name: String,
+                paid_amount: MetronomeSDK::Models::V1::CreditGrantCreateParams::PaidAmount,
+                priority: Float,
+                credit_grant_type: String,
+                custom_fields: T::Hash[Symbol, String],
+                effective_at: Time,
+                invoice_date: Time,
+                product_ids: T::Array[String],
+                reason: String,
+                rollover_settings: MetronomeSDK::Models::V1::CreditGrantCreateParams::RolloverSettings,
+                uniqueness_key: String,
+                request_options: MetronomeSDK::RequestOptions
+              }
+            )
+        end
+        def to_hash; end
+
+        class GrantAmount < MetronomeSDK::Internal::Type::BaseModel
+          sig { returns(Float) }
+          attr_accessor :amount
+
+          # the ID of the pricing unit to be used. Defaults to USD (cents) if not passed.
+          sig { returns(String) }
+          attr_accessor :credit_type_id
+
+          # the amount of credits granted
+          sig { params(amount: Float, credit_type_id: String).returns(T.attached_class) }
+          def self.new(
+            amount:,
+            # the ID of the pricing unit to be used. Defaults to USD (cents) if not passed.
+            credit_type_id:
+          ); end
+          sig { override.returns({amount: Float, credit_type_id: String}) }
+          def to_hash; end
+        end
+
+        class PaidAmount < MetronomeSDK::Internal::Type::BaseModel
+          sig { returns(Float) }
+          attr_accessor :amount
+
+          # the ID of the pricing unit to be used. Defaults to USD (cents) if not passed.
+          sig { returns(String) }
+          attr_accessor :credit_type_id
+
+          # the amount paid for this credit grant
+          sig { params(amount: Float, credit_type_id: String).returns(T.attached_class) }
+          def self.new(
+            amount:,
+            # the ID of the pricing unit to be used. Defaults to USD (cents) if not passed.
+            credit_type_id:
+          ); end
+          sig { override.returns({amount: Float, credit_type_id: String}) }
+          def to_hash; end
+        end
+
+        class RolloverSettings < MetronomeSDK::Internal::Type::BaseModel
+          # The date to expire the rollover credits.
+          sig { returns(Time) }
+          attr_accessor :expires_at
+
+          # The priority to give the rollover credit grant that gets created when a rollover
+          # happens.
+          sig { returns(Float) }
+          attr_accessor :priority
+
+          # Specify how much to rollover to the rollover credit grant
+          sig do
+            returns(
+              T.any(
+                MetronomeSDK::Models::V1::RolloverAmountMaxPercentage,
+                MetronomeSDK::Models::V1::RolloverAmountMaxAmount
+              )
+            )
+          end
+          attr_accessor :rollover_amount
+
+          # Configure a rollover for this credit grant so if it expires it rolls over a
+          # configured amount to a new credit grant. This feature is currently opt-in only.
+          # Contact Metronome to be added to the beta.
+          sig do
+            params(
+              expires_at: Time,
+              priority: Float,
+              rollover_amount: T.any(
+                MetronomeSDK::Models::V1::RolloverAmountMaxPercentage,
+                MetronomeSDK::Internal::AnyHash,
+                MetronomeSDK::Models::V1::RolloverAmountMaxAmount
+              )
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+            # The date to expire the rollover credits.
+            expires_at:,
+            # The priority to give the rollover credit grant that gets created when a rollover
+            # happens.
+            priority:,
+            # Specify how much to rollover to the rollover credit grant
+            rollover_amount:
+          ); end
+          sig do
+            override
+              .returns(
+                {
+                  expires_at: Time,
+                  priority: Float,
+                  rollover_amount: T.any(
+                    MetronomeSDK::Models::V1::RolloverAmountMaxPercentage,
+                    MetronomeSDK::Models::V1::RolloverAmountMaxAmount
+                  )
+                }
+              )
+          end
+          def to_hash; end
+
+          # Specify how much to rollover to the rollover credit grant
+          module RolloverAmount
+            extend MetronomeSDK::Internal::Type::Union
+
+            sig do
+              override
+                .returns(
+                  [MetronomeSDK::Models::V1::RolloverAmountMaxPercentage, MetronomeSDK::Models::V1::RolloverAmountMaxAmount]
+                )
+            end
+            def self.variants; end
+          end
+        end
+      end
+    end
+  end
+end