metronome-sdk 0.1.0.pre.alpha.1

data/rbi/metronome_sdk/models/v1/customer_detail.rbi

@@ -0,0 +1,175 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    module V1
+      class CustomerDetail < MetronomeSDK::Internal::Type::BaseModel
+        # the Metronome ID of the customer
+        sig { returns(String) }
+        attr_accessor :id
+
+        # RFC 3339 timestamp indicating when the customer was created.
+        sig { returns(Time) }
+        attr_accessor :created_at
+
+        sig { returns(T::Hash[Symbol, String]) }
+        attr_accessor :custom_fields
+
+        sig { returns(MetronomeSDK::Models::V1::CustomerDetail::CustomerConfig) }
+        attr_reader :customer_config
+
+        sig do
+          params(
+            customer_config: T.any(MetronomeSDK::Models::V1::CustomerDetail::CustomerConfig, MetronomeSDK::Internal::AnyHash)
+          )
+            .void
+        end
+        attr_writer :customer_config
+
+        # (deprecated, use ingest_aliases instead) the first ID (Metronome or ingest
+        # alias) that can be used in usage events
+        sig { returns(String) }
+        attr_accessor :external_id
+
+        # aliases for this customer that can be used instead of the Metronome customer ID
+        # in usage events
+        sig { returns(T::Array[String]) }
+        attr_accessor :ingest_aliases
+
+        sig { returns(String) }
+        attr_accessor :name
+
+        # RFC 3339 timestamp indicating when the customer was archived. Null if the
+        # customer is active.
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :archived_at
+
+        # This field's availability is dependent on your client's configuration.
+        sig { returns(T.nilable(MetronomeSDK::Models::V1::CustomerDetail::CurrentBillableStatus)) }
+        attr_reader :current_billable_status
+
+        sig do
+          params(
+            current_billable_status: T.any(MetronomeSDK::Models::V1::CustomerDetail::CurrentBillableStatus, MetronomeSDK::Internal::AnyHash)
+          )
+            .void
+        end
+        attr_writer :current_billable_status
+
+        sig do
+          params(
+            id: String,
+            created_at: Time,
+            custom_fields: T::Hash[Symbol, String],
+            customer_config: T.any(MetronomeSDK::Models::V1::CustomerDetail::CustomerConfig, MetronomeSDK::Internal::AnyHash),
+            external_id: String,
+            ingest_aliases: T::Array[String],
+            name: String,
+            archived_at: T.nilable(Time),
+            current_billable_status: T.any(MetronomeSDK::Models::V1::CustomerDetail::CurrentBillableStatus, MetronomeSDK::Internal::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          # the Metronome ID of the customer
+          id:,
+          # RFC 3339 timestamp indicating when the customer was created.
+          created_at:,
+          custom_fields:,
+          customer_config:,
+          # (deprecated, use ingest_aliases instead) the first ID (Metronome or ingest
+          # alias) that can be used in usage events
+          external_id:,
+          # aliases for this customer that can be used instead of the Metronome customer ID
+          # in usage events
+          ingest_aliases:,
+          name:,
+          # RFC 3339 timestamp indicating when the customer was archived. Null if the
+          # customer is active.
+          archived_at: nil,
+          # This field's availability is dependent on your client's configuration.
+          current_billable_status: nil
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                id: String,
+                created_at: Time,
+                custom_fields: T::Hash[Symbol, String],
+                customer_config: MetronomeSDK::Models::V1::CustomerDetail::CustomerConfig,
+                external_id: String,
+                ingest_aliases: T::Array[String],
+                name: String,
+                archived_at: T.nilable(Time),
+                current_billable_status: MetronomeSDK::Models::V1::CustomerDetail::CurrentBillableStatus
+              }
+            )
+        end
+        def to_hash; end
+
+        class CustomerConfig < MetronomeSDK::Internal::Type::BaseModel
+          # The Salesforce account ID for the customer
+          sig { returns(T.nilable(String)) }
+          attr_accessor :salesforce_account_id
+
+          sig { params(salesforce_account_id: T.nilable(String)).returns(T.attached_class) }
+          def self.new(
+            # The Salesforce account ID for the customer
+            salesforce_account_id:
+          ); end
+          sig { override.returns({salesforce_account_id: T.nilable(String)}) }
+          def to_hash; end
+        end
+
+        class CurrentBillableStatus < MetronomeSDK::Internal::Type::BaseModel
+          sig { returns(MetronomeSDK::Models::V1::CustomerDetail::CurrentBillableStatus::Value::TaggedSymbol) }
+          attr_accessor :value
+
+          sig { returns(T.nilable(Time)) }
+          attr_accessor :effective_at
+
+          # This field's availability is dependent on your client's configuration.
+          sig do
+            params(
+              value: MetronomeSDK::Models::V1::CustomerDetail::CurrentBillableStatus::Value::OrSymbol,
+              effective_at: T.nilable(Time)
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(value:, effective_at: nil); end
+
+          sig do
+            override
+              .returns(
+                {
+                  value: MetronomeSDK::Models::V1::CustomerDetail::CurrentBillableStatus::Value::TaggedSymbol,
+                  effective_at: T.nilable(Time)
+                }
+              )
+          end
+          def to_hash; end
+
+          module Value
+            extend MetronomeSDK::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, MetronomeSDK::Models::V1::CustomerDetail::CurrentBillableStatus::Value) }
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            BILLABLE =
+              T.let(:billable, MetronomeSDK::Models::V1::CustomerDetail::CurrentBillableStatus::Value::TaggedSymbol)
+            UNBILLABLE =
+              T.let(:unbillable, MetronomeSDK::Models::V1::CustomerDetail::CurrentBillableStatus::Value::TaggedSymbol)
+
+            sig do
+              override
+                .returns(T::Array[MetronomeSDK::Models::V1::CustomerDetail::CurrentBillableStatus::Value::TaggedSymbol])
+            end
+            def self.values; end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/v1/customer_list_billable_metrics_params.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    module V1
+      class CustomerListBillableMetricsParams < MetronomeSDK::Internal::Type::BaseModel
+        extend MetronomeSDK::Internal::Type::RequestParameters::Converter
+        include MetronomeSDK::Internal::Type::RequestParameters
+
+        sig { returns(String) }
+        attr_accessor :customer_id
+
+        # If true, the list of returned metrics will include archived metrics
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :include_archived
+
+        sig { params(include_archived: T::Boolean).void }
+        attr_writer :include_archived
+
+        # 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
+
+        # If true, the list of metrics will be filtered to just ones that are on the
+        # customer's current plan
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :on_current_plan
+
+        sig { params(on_current_plan: T::Boolean).void }
+        attr_writer :on_current_plan
+
+        sig do
+          params(
+            customer_id: String,
+            include_archived: T::Boolean,
+            limit: Integer,
+            next_page: String,
+            on_current_plan: T::Boolean,
+            request_options: T.any(MetronomeSDK::RequestOptions, MetronomeSDK::Internal::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          customer_id:,
+          # If true, the list of returned metrics will include archived metrics
+          include_archived: nil,
+          # Max number of results that should be returned
+          limit: nil,
+          # Cursor that indicates where the next page of results should start.
+          next_page: nil,
+          # If true, the list of metrics will be filtered to just ones that are on the
+          # customer's current plan
+          on_current_plan: nil,
+          request_options: {}
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                customer_id: String,
+                include_archived: T::Boolean,
+                limit: Integer,
+                next_page: String,
+                on_current_plan: T::Boolean,
+                request_options: MetronomeSDK::RequestOptions
+              }
+            )
+        end
+        def to_hash; end
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/v1/customer_list_billable_metrics_response.rbi

@@ -0,0 +1,233 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    module V1
+      class CustomerListBillableMetricsResponse < MetronomeSDK::Internal::Type::BaseModel
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(String) }
+        attr_accessor :name
+
+        # (DEPRECATED) use aggregation_type instead
+        sig { returns(T.nilable(String)) }
+        attr_reader :aggregate
+
+        sig { params(aggregate: String).void }
+        attr_writer :aggregate
+
+        # (DEPRECATED) use aggregation_key instead
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :aggregate_keys
+
+        sig { params(aggregate_keys: T::Array[String]).void }
+        attr_writer :aggregate_keys
+
+        # A key that specifies which property of the event is used to aggregate data. This
+        # key must be one of the property filter names and is not applicable when the
+        # aggregation type is 'count'.
+        sig { returns(T.nilable(String)) }
+        attr_reader :aggregation_key
+
+        sig { params(aggregation_key: String).void }
+        attr_writer :aggregation_key
+
+        # Specifies the type of aggregation performed on matching events.
+        sig do
+          returns(
+            T.nilable(MetronomeSDK::Models::V1::CustomerListBillableMetricsResponse::AggregationType::TaggedSymbol)
+          )
+        end
+        attr_reader :aggregation_type
+
+        sig do
+          params(
+            aggregation_type: MetronomeSDK::Models::V1::CustomerListBillableMetricsResponse::AggregationType::OrSymbol
+          )
+            .void
+        end
+        attr_writer :aggregation_type
+
+        # RFC 3339 timestamp indicating when the billable metric was archived. If not
+        # provided, the billable metric is not archived.
+        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
+
+        # An optional filtering rule to match the 'event_type' property of an event.
+        sig { returns(T.nilable(MetronomeSDK::Models::EventTypeFilter)) }
+        attr_reader :event_type_filter
+
+        sig do
+          params(event_type_filter: T.any(MetronomeSDK::Models::EventTypeFilter, MetronomeSDK::Internal::AnyHash))
+            .void
+        end
+        attr_writer :event_type_filter
+
+        # (DEPRECATED) use property_filters & event_type_filter instead
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_reader :filter
+
+        sig { params(filter: T::Hash[Symbol, T.anything]).void }
+        attr_writer :filter
+
+        # (DEPRECATED) use group_keys instead
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :group_by
+
+        sig { params(group_by: T::Array[String]).void }
+        attr_writer :group_by
+
+        # Property names that are used to group usage costs on an invoice. Each entry
+        # represents a set of properties used to slice events into distinct buckets.
+        sig { returns(T.nilable(T::Array[T::Array[String]])) }
+        attr_reader :group_keys
+
+        sig { params(group_keys: T::Array[T::Array[String]]).void }
+        attr_writer :group_keys
+
+        # A list of filters to match events to this billable metric. Each filter defines a
+        # rule on an event property. All rules must pass for the event to match the
+        # billable metric.
+        sig { returns(T.nilable(T::Array[MetronomeSDK::Models::PropertyFilter])) }
+        attr_reader :property_filters
+
+        sig do
+          params(
+            property_filters: T::Array[T.any(MetronomeSDK::Models::PropertyFilter, MetronomeSDK::Internal::AnyHash)]
+          )
+            .void
+        end
+        attr_writer :property_filters
+
+        # The SQL query associated with the billable metric
+        sig { returns(T.nilable(String)) }
+        attr_reader :sql
+
+        sig { params(sql: String).void }
+        attr_writer :sql
+
+        sig do
+          params(
+            id: String,
+            name: String,
+            aggregate: String,
+            aggregate_keys: T::Array[String],
+            aggregation_key: String,
+            aggregation_type: MetronomeSDK::Models::V1::CustomerListBillableMetricsResponse::AggregationType::OrSymbol,
+            archived_at: Time,
+            custom_fields: T::Hash[Symbol, String],
+            event_type_filter: T.any(MetronomeSDK::Models::EventTypeFilter, MetronomeSDK::Internal::AnyHash),
+            filter: T::Hash[Symbol, T.anything],
+            group_by: T::Array[String],
+            group_keys: T::Array[T::Array[String]],
+            property_filters: T::Array[T.any(MetronomeSDK::Models::PropertyFilter, MetronomeSDK::Internal::AnyHash)],
+            sql: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          name:,
+          # (DEPRECATED) use aggregation_type instead
+          aggregate: nil,
+          # (DEPRECATED) use aggregation_key instead
+          aggregate_keys: nil,
+          # A key that specifies which property of the event is used to aggregate data. This
+          # key must be one of the property filter names and is not applicable when the
+          # aggregation type is 'count'.
+          aggregation_key: nil,
+          # Specifies the type of aggregation performed on matching events.
+          aggregation_type: nil,
+          # RFC 3339 timestamp indicating when the billable metric was archived. If not
+          # provided, the billable metric is not archived.
+          archived_at: nil,
+          custom_fields: nil,
+          # An optional filtering rule to match the 'event_type' property of an event.
+          event_type_filter: nil,
+          # (DEPRECATED) use property_filters & event_type_filter instead
+          filter: nil,
+          # (DEPRECATED) use group_keys instead
+          group_by: nil,
+          # Property names that are used to group usage costs on an invoice. Each entry
+          # represents a set of properties used to slice events into distinct buckets.
+          group_keys: nil,
+          # A list of filters to match events to this billable metric. Each filter defines a
+          # rule on an event property. All rules must pass for the event to match the
+          # billable metric.
+          property_filters: nil,
+          # The SQL query associated with the billable metric
+          sql: nil
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                id: String,
+                name: String,
+                aggregate: String,
+                aggregate_keys: T::Array[String],
+                aggregation_key: String,
+                aggregation_type: MetronomeSDK::Models::V1::CustomerListBillableMetricsResponse::AggregationType::TaggedSymbol,
+                archived_at: Time,
+                custom_fields: T::Hash[Symbol, String],
+                event_type_filter: MetronomeSDK::Models::EventTypeFilter,
+                filter: T::Hash[Symbol, T.anything],
+                group_by: T::Array[String],
+                group_keys: T::Array[T::Array[String]],
+                property_filters: T::Array[MetronomeSDK::Models::PropertyFilter],
+                sql: String
+              }
+            )
+        end
+        def to_hash; end
+
+        # Specifies the type of aggregation performed on matching events.
+        module AggregationType
+          extend MetronomeSDK::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, MetronomeSDK::Models::V1::CustomerListBillableMetricsResponse::AggregationType) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          COUNT =
+            T.let(
+              :COUNT,
+              MetronomeSDK::Models::V1::CustomerListBillableMetricsResponse::AggregationType::TaggedSymbol
+            )
+          LATEST =
+            T.let(
+              :LATEST,
+              MetronomeSDK::Models::V1::CustomerListBillableMetricsResponse::AggregationType::TaggedSymbol
+            )
+          MAX =
+            T.let(:MAX, MetronomeSDK::Models::V1::CustomerListBillableMetricsResponse::AggregationType::TaggedSymbol)
+          SUM =
+            T.let(:SUM, MetronomeSDK::Models::V1::CustomerListBillableMetricsResponse::AggregationType::TaggedSymbol)
+          UNIQUE =
+            T.let(
+              :UNIQUE,
+              MetronomeSDK::Models::V1::CustomerListBillableMetricsResponse::AggregationType::TaggedSymbol
+            )
+
+          sig do
+            override
+              .returns(
+                T::Array[MetronomeSDK::Models::V1::CustomerListBillableMetricsResponse::AggregationType::TaggedSymbol]
+              )
+          end
+          def self.values; end
+        end
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/v1/customer_list_costs_params.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    module V1
+      class CustomerListCostsParams < MetronomeSDK::Internal::Type::BaseModel
+        extend MetronomeSDK::Internal::Type::RequestParameters::Converter
+        include MetronomeSDK::Internal::Type::RequestParameters
+
+        sig { returns(String) }
+        attr_accessor :customer_id
+
+        # RFC 3339 timestamp (exclusive)
+        sig { returns(Time) }
+        attr_accessor :ending_before
+
+        # RFC 3339 timestamp (inclusive)
+        sig { returns(Time) }
+        attr_accessor :starting_on
+
+        # 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
+
+        sig do
+          params(
+            customer_id: String,
+            ending_before: Time,
+            starting_on: Time,
+            limit: Integer,
+            next_page: String,
+            request_options: T.any(MetronomeSDK::RequestOptions, MetronomeSDK::Internal::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          customer_id:,
+          # RFC 3339 timestamp (exclusive)
+          ending_before:,
+          # RFC 3339 timestamp (inclusive)
+          starting_on:,
+          # Max number of results that should be returned
+          limit: nil,
+          # Cursor that indicates where the next page of results should start.
+          next_page: nil,
+          request_options: {}
+        ); end
+        sig do
+          override
+            .returns(
+              {
+                customer_id: String,
+                ending_before: Time,
+                starting_on: Time,
+                limit: Integer,
+                next_page: String,
+                request_options: MetronomeSDK::RequestOptions
+              }
+            )
+        end
+        def to_hash; end
+      end
+    end
+  end
+end

data/rbi/metronome_sdk/models/v1/customer_list_costs_response.rbi

@@ -0,0 +1,132 @@
+# typed: strong
+
+module MetronomeSDK
+  module Models
+    module V1
+      class CustomerListCostsResponse < MetronomeSDK::Internal::Type::BaseModel
+        sig { returns(T::Hash[Symbol, MetronomeSDK::Models::V1::CustomerListCostsResponse::CreditType]) }
+        attr_accessor :credit_types
+
+        sig { returns(Time) }
+        attr_accessor :end_timestamp
+
+        sig { returns(Time) }
+        attr_accessor :start_timestamp
+
+        sig do
+          params(
+            credit_types: T::Hash[
+              Symbol,
+              T.any(MetronomeSDK::Models::V1::CustomerListCostsResponse::CreditType, MetronomeSDK::Internal::AnyHash)
+            ],
+            end_timestamp: Time,
+            start_timestamp: Time
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(credit_types:, end_timestamp:, start_timestamp:); end
+
+        sig do
+          override
+            .returns(
+              {
+                credit_types: T::Hash[Symbol, MetronomeSDK::Models::V1::CustomerListCostsResponse::CreditType],
+                end_timestamp: Time,
+                start_timestamp: Time
+              }
+            )
+        end
+        def to_hash; end
+
+        class CreditType < MetronomeSDK::Internal::Type::BaseModel
+          sig { returns(T.nilable(Float)) }
+          attr_reader :cost
+
+          sig { params(cost: Float).void }
+          attr_writer :cost
+
+          sig do
+            returns(
+              T.nilable(T::Array[MetronomeSDK::Models::V1::CustomerListCostsResponse::CreditType::LineItemBreakdown])
+            )
+          end
+          attr_reader :line_item_breakdown
+
+          sig do
+            params(
+              line_item_breakdown: T::Array[
+                T.any(
+                  MetronomeSDK::Models::V1::CustomerListCostsResponse::CreditType::LineItemBreakdown,
+                  MetronomeSDK::Internal::AnyHash
+                )
+              ]
+            )
+              .void
+          end
+          attr_writer :line_item_breakdown
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :name
+
+          sig { params(name: String).void }
+          attr_writer :name
+
+          sig do
+            params(
+              cost: Float,
+              line_item_breakdown: T::Array[
+                T.any(
+                  MetronomeSDK::Models::V1::CustomerListCostsResponse::CreditType::LineItemBreakdown,
+                  MetronomeSDK::Internal::AnyHash
+                )
+              ],
+              name: String
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(cost: nil, line_item_breakdown: nil, name: nil); end
+
+          sig do
+            override
+              .returns(
+                {
+                  cost: Float,
+                  line_item_breakdown: T::Array[MetronomeSDK::Models::V1::CustomerListCostsResponse::CreditType::LineItemBreakdown],
+                  name: String
+                }
+              )
+          end
+          def to_hash; end
+
+          class LineItemBreakdown < MetronomeSDK::Internal::Type::BaseModel
+            sig { returns(Float) }
+            attr_accessor :cost
+
+            sig { returns(String) }
+            attr_accessor :name
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :group_key
+
+            sig { params(group_key: String).void }
+            attr_writer :group_key
+
+            sig { returns(T.nilable(String)) }
+            attr_accessor :group_value
+
+            sig do
+              params(cost: Float, name: String, group_key: String, group_value: T.nilable(String))
+                .returns(T.attached_class)
+            end
+            def self.new(cost:, name:, group_key: nil, group_value: nil); end
+
+            sig do
+              override.returns({cost: Float, name: String, group_key: String, group_value: T.nilable(String)})
+            end
+            def to_hash; end
+          end
+        end
+      end
+    end
+  end
+end