stigg 0.1.0.pre.alpha.1 → 0.1.0.pre.alpha.3

data/rbi/stigg/models/v1/subscriptions/{future_update_cancel_schedule_response.rbi → cancel_subscription.rbi}

@@ -3,35 +3,32 @@
 module Stigg
   module Models
     module V1
+      CancelSubscription = Subscriptions::CancelSubscription
+
       module Subscriptions
-        class FutureUpdateCancelScheduleResponse < Stigg::Internal::Type::BaseModel
+        class CancelSubscription < Stigg::Internal::Type::BaseModel
           OrHash =
             T.type_alias do
               T.any(
-                Stigg::Models::V1::Subscriptions::FutureUpdateCancelScheduleResponse,
+                Stigg::V1::Subscriptions::CancelSubscription,
                 Stigg::Internal::AnyHash
               )
             end
 
-          sig do
-            returns(
-              Stigg::Models::V1::Subscriptions::FutureUpdateCancelScheduleResponse::Data
-            )
-          end
+          sig { returns(Stigg::V1::Subscriptions::CancelSubscription::Data) }
           attr_reader :data
 
           sig do
             params(
-              data:
-                Stigg::Models::V1::Subscriptions::FutureUpdateCancelScheduleResponse::Data::OrHash
+              data: Stigg::V1::Subscriptions::CancelSubscription::Data::OrHash
             ).void
           end
           attr_writer :data
 
+          # Response object
           sig do
             params(
-              data:
-                Stigg::Models::V1::Subscriptions::FutureUpdateCancelScheduleResponse::Data::OrHash
+              data: Stigg::V1::Subscriptions::CancelSubscription::Data::OrHash
             ).returns(T.attached_class)
           end
           def self.new(data:)
@@ -39,10 +36,7 @@ module Stigg
 
           sig do
             override.returns(
-              {
-                data:
-                  Stigg::Models::V1::Subscriptions::FutureUpdateCancelScheduleResponse::Data
-              }
+              { data: Stigg::V1::Subscriptions::CancelSubscription::Data }
             )
           end
           def to_hash
@@ -52,7 +46,7 @@ module Stigg
             OrHash =
               T.type_alias do
                 T.any(
-                  Stigg::Models::V1::Subscriptions::FutureUpdateCancelScheduleResponse::Data,
+                  Stigg::V1::Subscriptions::CancelSubscription::Data,
                   Stigg::Internal::AnyHash
                 )
               end

data/rbi/stigg/models/v1/usage_history_params.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Stigg
+  module Models
+    module V1
+      class UsageHistoryParams < Stigg::Internal::Type::BaseModel
+        extend Stigg::Internal::Type::RequestParameters::Converter
+        include Stigg::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Stigg::V1::UsageHistoryParams, Stigg::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :customer_id
+
+        # The start date of the range
+        sig { returns(Time) }
+        attr_accessor :start_date
+
+        # The end date of the range
+        sig { returns(T.nilable(Time)) }
+        attr_reader :end_date
+
+        sig { params(end_date: Time).void }
+        attr_writer :end_date
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :group_by
+
+        sig { params(group_by: String).void }
+        attr_writer :group_by
+
+        # Resource id
+        sig { returns(T.nilable(String)) }
+        attr_accessor :resource_id
+
+        sig do
+          params(
+            customer_id: String,
+            start_date: Time,
+            end_date: Time,
+            group_by: String,
+            resource_id: T.nilable(String),
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          customer_id:,
+          # The start date of the range
+          start_date:,
+          # The end date of the range
+          end_date: nil,
+          group_by: nil,
+          # Resource id
+          resource_id: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              customer_id: String,
+              start_date: Time,
+              end_date: Time,
+              group_by: String,
+              resource_id: T.nilable(String),
+              request_options: Stigg::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/stigg/models/v1/usage_history_response.rbi

@@ -0,0 +1,347 @@
+# typed: strong
+
+module Stigg
+  module Models
+    module V1
+      class UsageHistoryResponse < Stigg::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Stigg::Models::V1::UsageHistoryResponse,
+              Stigg::Internal::AnyHash
+            )
+          end
+
+        # Historical usage time series
+        sig { returns(Stigg::Models::V1::UsageHistoryResponse::Data) }
+        attr_reader :data
+
+        sig do
+          params(
+            data: Stigg::Models::V1::UsageHistoryResponse::Data::OrHash
+          ).void
+        end
+        attr_writer :data
+
+        # Response object
+        sig do
+          params(
+            data: Stigg::Models::V1::UsageHistoryResponse::Data::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Historical usage time series
+          data:
+        )
+        end
+
+        sig do
+          override.returns(
+            { data: Stigg::Models::V1::UsageHistoryResponse::Data }
+          )
+        end
+        def to_hash
+        end
+
+        class Data < Stigg::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Stigg::Models::V1::UsageHistoryResponse::Data,
+                Stigg::Internal::AnyHash
+              )
+            end
+
+          # Markers for events that affecting feature usage
+          sig do
+            returns(
+              T::Array[Stigg::Models::V1::UsageHistoryResponse::Data::Marker]
+            )
+          end
+          attr_accessor :markers
+
+          # Series of usage history
+          sig do
+            returns(
+              T::Array[Stigg::Models::V1::UsageHistoryResponse::Data::Series]
+            )
+          end
+          attr_accessor :series
+
+          # Historical usage time series
+          sig do
+            params(
+              markers:
+                T::Array[
+                  Stigg::Models::V1::UsageHistoryResponse::Data::Marker::OrHash
+                ],
+              series:
+                T::Array[
+                  Stigg::Models::V1::UsageHistoryResponse::Data::Series::OrHash
+                ]
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Markers for events that affecting feature usage
+            markers:,
+            # Series of usage history
+            series:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                markers:
+                  T::Array[
+                    Stigg::Models::V1::UsageHistoryResponse::Data::Marker
+                  ],
+                series:
+                  T::Array[
+                    Stigg::Models::V1::UsageHistoryResponse::Data::Series
+                  ]
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Marker < Stigg::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Stigg::Models::V1::UsageHistoryResponse::Data::Marker,
+                  Stigg::Internal::AnyHash
+                )
+              end
+
+            # Timestamp of the marker
+            sig { returns(Time) }
+            attr_accessor :timestamp
+
+            # Type of marker for a usage history point
+            sig do
+              returns(
+                Stigg::Models::V1::UsageHistoryResponse::Data::Marker::Type::TaggedSymbol
+              )
+            end
+            attr_accessor :type
+
+            # Usage reset or change marker
+            sig do
+              params(
+                timestamp: Time,
+                type:
+                  Stigg::Models::V1::UsageHistoryResponse::Data::Marker::Type::OrSymbol
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Timestamp of the marker
+              timestamp:,
+              # Type of marker for a usage history point
+              type:
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  timestamp: Time,
+                  type:
+                    Stigg::Models::V1::UsageHistoryResponse::Data::Marker::Type::TaggedSymbol
+                }
+              )
+            end
+            def to_hash
+            end
+
+            # Type of marker for a usage history point
+            module Type
+              extend Stigg::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Stigg::Models::V1::UsageHistoryResponse::Data::Marker::Type
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              PERIODIC_RESET =
+                T.let(
+                  :PERIODIC_RESET,
+                  Stigg::Models::V1::UsageHistoryResponse::Data::Marker::Type::TaggedSymbol
+                )
+              SUBSCRIPTION_CHANGE_RESET =
+                T.let(
+                  :SUBSCRIPTION_CHANGE_RESET,
+                  Stigg::Models::V1::UsageHistoryResponse::Data::Marker::Type::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Stigg::Models::V1::UsageHistoryResponse::Data::Marker::Type::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+          end
+
+          class Series < Stigg::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Stigg::Models::V1::UsageHistoryResponse::Data::Series,
+                  Stigg::Internal::AnyHash
+                )
+              end
+
+            # Points in the usage history series
+            sig do
+              returns(
+                T::Array[
+                  Stigg::Models::V1::UsageHistoryResponse::Data::Series::Point
+                ]
+              )
+            end
+            attr_accessor :points
+
+            # Tags for the usage history series
+            sig do
+              returns(
+                T::Array[
+                  Stigg::Models::V1::UsageHistoryResponse::Data::Series::Tag
+                ]
+              )
+            end
+            attr_accessor :tags
+
+            # Usage data points with tags
+            sig do
+              params(
+                points:
+                  T::Array[
+                    Stigg::Models::V1::UsageHistoryResponse::Data::Series::Point::OrHash
+                  ],
+                tags:
+                  T::Array[
+                    Stigg::Models::V1::UsageHistoryResponse::Data::Series::Tag::OrHash
+                  ]
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Points in the usage history series
+              points:,
+              # Tags for the usage history series
+              tags:
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  points:
+                    T::Array[
+                      Stigg::Models::V1::UsageHistoryResponse::Data::Series::Point
+                    ],
+                  tags:
+                    T::Array[
+                      Stigg::Models::V1::UsageHistoryResponse::Data::Series::Tag
+                    ]
+                }
+              )
+            end
+            def to_hash
+            end
+
+            class Point < Stigg::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Stigg::Models::V1::UsageHistoryResponse::Data::Series::Point,
+                    Stigg::Internal::AnyHash
+                  )
+                end
+
+              # Indicates whether there was usage reset in this point, see `markers` for details
+              sig { returns(T::Boolean) }
+              attr_accessor :is_reset_point
+
+              # Timestamp of the usage history point
+              sig { returns(Time) }
+              attr_accessor :timestamp
+
+              # Value of the usage history point
+              sig { returns(Float) }
+              attr_accessor :value
+
+              # Single usage data point
+              sig do
+                params(
+                  is_reset_point: T::Boolean,
+                  timestamp: Time,
+                  value: Float
+                ).returns(T.attached_class)
+              end
+              def self.new(
+                # Indicates whether there was usage reset in this point, see `markers` for details
+                is_reset_point:,
+                # Timestamp of the usage history point
+                timestamp:,
+                # Value of the usage history point
+                value:
+              )
+              end
+
+              sig do
+                override.returns(
+                  { is_reset_point: T::Boolean, timestamp: Time, value: Float }
+                )
+              end
+              def to_hash
+              end
+            end
+
+            class Tag < Stigg::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Stigg::Models::V1::UsageHistoryResponse::Data::Series::Tag,
+                    Stigg::Internal::AnyHash
+                  )
+                end
+
+              # Key of the tag
+              sig { returns(String) }
+              attr_accessor :key
+
+              # Value of the tag
+              sig { returns(String) }
+              attr_accessor :value
+
+              # Grouping tag key-value
+              sig do
+                params(key: String, value: String).returns(T.attached_class)
+              end
+              def self.new(
+                # Key of the tag
+                key:,
+                # Value of the tag
+                value:
+              )
+              end
+
+              sig { override.returns({ key: String, value: String }) }
+              def to_hash
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/stigg/models/v1/usage_report_params.rbi

@@ -0,0 +1,227 @@
+# typed: strong
+
+module Stigg
+  module Models
+    module V1
+      class UsageReportParams < Stigg::Internal::Type::BaseModel
+        extend Stigg::Internal::Type::RequestParameters::Converter
+        include Stigg::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Stigg::V1::UsageReportParams, Stigg::Internal::AnyHash)
+          end
+
+        # A list of usage reports to be submitted in bulk
+        sig { returns(T::Array[Stigg::V1::UsageReportParams::Usage]) }
+        attr_accessor :usages
+
+        sig do
+          params(
+            usages: T::Array[Stigg::V1::UsageReportParams::Usage::OrHash],
+            request_options: Stigg::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # A list of usage reports to be submitted in bulk
+          usages:,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              usages: T::Array[Stigg::V1::UsageReportParams::Usage],
+              request_options: Stigg::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Usage < Stigg::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Stigg::V1::UsageReportParams::Usage,
+                Stigg::Internal::AnyHash
+              )
+            end
+
+          # Customer id
+          sig { returns(String) }
+          attr_accessor :customer_id
+
+          # Feature id
+          sig { returns(String) }
+          attr_accessor :feature_id
+
+          # The value to report for usage
+          sig { returns(Integer) }
+          attr_accessor :value
+
+          # Timestamp of when the record was created
+          sig { returns(T.nilable(Time)) }
+          attr_reader :created_at
+
+          sig { params(created_at: Time).void }
+          attr_writer :created_at
+
+          # Additional dimensions for the usage report
+          sig do
+            returns(
+              T.nilable(
+                T::Hash[
+                  Symbol,
+                  Stigg::V1::UsageReportParams::Usage::Dimension::Variants
+                ]
+              )
+            )
+          end
+          attr_reader :dimensions
+
+          sig do
+            params(
+              dimensions:
+                T::Hash[
+                  Symbol,
+                  Stigg::V1::UsageReportParams::Usage::Dimension::Variants
+                ]
+            ).void
+          end
+          attr_writer :dimensions
+
+          # Resource id
+          sig { returns(T.nilable(String)) }
+          attr_accessor :resource_id
+
+          # The method by which the usage value should be updated
+          sig do
+            returns(
+              T.nilable(
+                Stigg::V1::UsageReportParams::Usage::UpdateBehavior::OrSymbol
+              )
+            )
+          end
+          attr_reader :update_behavior
+
+          sig do
+            params(
+              update_behavior:
+                Stigg::V1::UsageReportParams::Usage::UpdateBehavior::OrSymbol
+            ).void
+          end
+          attr_writer :update_behavior
+
+          # Single usage measurement
+          sig do
+            params(
+              customer_id: String,
+              feature_id: String,
+              value: Integer,
+              created_at: Time,
+              dimensions:
+                T::Hash[
+                  Symbol,
+                  Stigg::V1::UsageReportParams::Usage::Dimension::Variants
+                ],
+              resource_id: T.nilable(String),
+              update_behavior:
+                Stigg::V1::UsageReportParams::Usage::UpdateBehavior::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Customer id
+            customer_id:,
+            # Feature id
+            feature_id:,
+            # The value to report for usage
+            value:,
+            # Timestamp of when the record was created
+            created_at: nil,
+            # Additional dimensions for the usage report
+            dimensions: nil,
+            # Resource id
+            resource_id: nil,
+            # The method by which the usage value should be updated
+            update_behavior: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                customer_id: String,
+                feature_id: String,
+                value: Integer,
+                created_at: Time,
+                dimensions:
+                  T::Hash[
+                    Symbol,
+                    Stigg::V1::UsageReportParams::Usage::Dimension::Variants
+                  ],
+                resource_id: T.nilable(String),
+                update_behavior:
+                  Stigg::V1::UsageReportParams::Usage::UpdateBehavior::OrSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Dimension
+            extend Stigg::Internal::Type::Union
+
+            Variants = T.type_alias { T.any(String, Float, T::Boolean) }
+
+            sig do
+              override.returns(
+                T::Array[
+                  Stigg::V1::UsageReportParams::Usage::Dimension::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
+
+          # The method by which the usage value should be updated
+          module UpdateBehavior
+            extend Stigg::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Stigg::V1::UsageReportParams::Usage::UpdateBehavior
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            DELTA =
+              T.let(
+                :DELTA,
+                Stigg::V1::UsageReportParams::Usage::UpdateBehavior::TaggedSymbol
+              )
+            SET =
+              T.let(
+                :SET,
+                Stigg::V1::UsageReportParams::Usage::UpdateBehavior::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Stigg::V1::UsageReportParams::Usage::UpdateBehavior::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+    end
+  end
+end