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

data/rbi/stigg/models/v1_create_event_params.rbi

@@ -1,160 +0,0 @@
-# typed: strong
-
-module Stigg
-  module Models
-    class V1CreateEventParams < Stigg::Internal::Type::BaseModel
-      extend Stigg::Internal::Type::RequestParameters::Converter
-      include Stigg::Internal::Type::RequestParameters
-
-      OrHash =
-        T.type_alias do
-          T.any(Stigg::V1CreateEventParams, Stigg::Internal::AnyHash)
-        end
-
-      # A list of usage events to report
-      sig { returns(T::Array[Stigg::V1CreateEventParams::Event]) }
-      attr_accessor :events
-
-      sig do
-        params(
-          events: T::Array[Stigg::V1CreateEventParams::Event::OrHash],
-          request_options: Stigg::RequestOptions::OrHash
-        ).returns(T.attached_class)
-      end
-      def self.new(
-        # A list of usage events to report
-        events:,
-        request_options: {}
-      )
-      end
-
-      sig do
-        override.returns(
-          {
-            events: T::Array[Stigg::V1CreateEventParams::Event],
-            request_options: Stigg::RequestOptions
-          }
-        )
-      end
-      def to_hash
-      end
-
-      class Event < Stigg::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Stigg::V1CreateEventParams::Event, Stigg::Internal::AnyHash)
-          end
-
-        # Customer id
-        sig { returns(String) }
-        attr_accessor :customer_id
-
-        # The name of the usage event
-        sig { returns(String) }
-        attr_accessor :event_name
-
-        # Idempotency key
-        sig { returns(String) }
-        attr_accessor :idempotency_key
-
-        # Dimensions associated with the usage event
-        sig do
-          returns(
-            T.nilable(
-              T::Hash[
-                Symbol,
-                Stigg::V1CreateEventParams::Event::Dimension::Variants
-              ]
-            )
-          )
-        end
-        attr_reader :dimensions
-
-        sig do
-          params(
-            dimensions:
-              T::Hash[
-                Symbol,
-                Stigg::V1CreateEventParams::Event::Dimension::Variants
-              ]
-          ).void
-        end
-        attr_writer :dimensions
-
-        # Resource id
-        sig { returns(T.nilable(String)) }
-        attr_accessor :resource_id
-
-        # Timestamp
-        sig { returns(T.nilable(Time)) }
-        attr_reader :timestamp
-
-        sig { params(timestamp: Time).void }
-        attr_writer :timestamp
-
-        sig do
-          params(
-            customer_id: String,
-            event_name: String,
-            idempotency_key: String,
-            dimensions:
-              T::Hash[
-                Symbol,
-                Stigg::V1CreateEventParams::Event::Dimension::Variants
-              ],
-            resource_id: T.nilable(String),
-            timestamp: Time
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Customer id
-          customer_id:,
-          # The name of the usage event
-          event_name:,
-          # Idempotency key
-          idempotency_key:,
-          # Dimensions associated with the usage event
-          dimensions: nil,
-          # Resource id
-          resource_id: nil,
-          # Timestamp
-          timestamp: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              customer_id: String,
-              event_name: String,
-              idempotency_key: String,
-              dimensions:
-                T::Hash[
-                  Symbol,
-                  Stigg::V1CreateEventParams::Event::Dimension::Variants
-                ],
-              resource_id: T.nilable(String),
-              timestamp: Time
-            }
-          )
-        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::V1CreateEventParams::Event::Dimension::Variants]
-            )
-          end
-          def self.variants
-          end
-        end
-      end
-    end
-  end
-end

data/rbi/stigg/models/v1_create_event_response.rbi

@@ -1,23 +0,0 @@
-# typed: strong
-
-module Stigg
-  module Models
-    class V1CreateEventResponse < Stigg::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Stigg::Models::V1CreateEventResponse, Stigg::Internal::AnyHash)
-        end
-
-      sig { returns(T.anything) }
-      attr_accessor :data
-
-      sig { params(data: T.anything).returns(T.attached_class) }
-      def self.new(data:)
-      end
-
-      sig { override.returns({ data: T.anything }) }
-      def to_hash
-      end
-    end
-  end
-end

data/rbi/stigg/models/v1_create_usage_params.rbi

@@ -1,177 +0,0 @@
-# typed: strong
-
-module Stigg
-  module Models
-    class V1CreateUsageParams < Stigg::Internal::Type::BaseModel
-      extend Stigg::Internal::Type::RequestParameters::Converter
-      include Stigg::Internal::Type::RequestParameters
-
-      OrHash =
-        T.type_alias do
-          T.any(Stigg::V1CreateUsageParams, Stigg::Internal::AnyHash)
-        end
-
-      # A list of usage reports to be submitted in bulk
-      sig { returns(T::Array[Stigg::V1CreateUsageParams::Usage]) }
-      attr_accessor :usages
-
-      sig do
-        params(
-          usages: T::Array[Stigg::V1CreateUsageParams::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::V1CreateUsageParams::Usage],
-            request_options: Stigg::RequestOptions
-          }
-        )
-      end
-      def to_hash
-      end
-
-      class Usage < Stigg::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Stigg::V1CreateUsageParams::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 { returns(T.nilable(T::Hash[Symbol, String])) }
-        attr_reader :dimensions
-
-        sig { params(dimensions: T::Hash[Symbol, String]).void }
-        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::V1CreateUsageParams::Usage::UpdateBehavior::OrSymbol
-            )
-          )
-        end
-        attr_reader :update_behavior
-
-        sig do
-          params(
-            update_behavior:
-              Stigg::V1CreateUsageParams::Usage::UpdateBehavior::OrSymbol
-          ).void
-        end
-        attr_writer :update_behavior
-
-        sig do
-          params(
-            customer_id: String,
-            feature_id: String,
-            value: Integer,
-            created_at: Time,
-            dimensions: T::Hash[Symbol, String],
-            resource_id: T.nilable(String),
-            update_behavior:
-              Stigg::V1CreateUsageParams::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, String],
-              resource_id: T.nilable(String),
-              update_behavior:
-                Stigg::V1CreateUsageParams::Usage::UpdateBehavior::OrSymbol
-            }
-          )
-        end
-        def to_hash
-        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::V1CreateUsageParams::Usage::UpdateBehavior)
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          DELTA =
-            T.let(
-              :DELTA,
-              Stigg::V1CreateUsageParams::Usage::UpdateBehavior::TaggedSymbol
-            )
-          SET =
-            T.let(
-              :SET,
-              Stigg::V1CreateUsageParams::Usage::UpdateBehavior::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[
-                Stigg::V1CreateUsageParams::Usage::UpdateBehavior::TaggedSymbol
-              ]
-            )
-          end
-          def self.values
-          end
-        end
-      end
-    end
-  end
-end

data/rbi/stigg/models/v1_create_usage_response.rbi

@@ -1,150 +0,0 @@
-# typed: strong
-
-module Stigg
-  module Models
-    class V1CreateUsageResponse < Stigg::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Stigg::Models::V1CreateUsageResponse, Stigg::Internal::AnyHash)
-        end
-
-      sig { returns(T::Array[Stigg::Models::V1CreateUsageResponse::Data]) }
-      attr_accessor :data
-
-      sig do
-        params(
-          data: T::Array[Stigg::Models::V1CreateUsageResponse::Data::OrHash]
-        ).returns(T.attached_class)
-      end
-      def self.new(data:)
-      end
-
-      sig do
-        override.returns(
-          { data: T::Array[Stigg::Models::V1CreateUsageResponse::Data] }
-        )
-      end
-      def to_hash
-      end
-
-      class Data < Stigg::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Stigg::Models::V1CreateUsageResponse::Data,
-              Stigg::Internal::AnyHash
-            )
-          end
-
-        # Unique identifier for the entity
-        sig { returns(String) }
-        attr_accessor :id
-
-        # Timestamp of when the record was created
-        sig { returns(Time) }
-        attr_accessor :created_at
-
-        # Customer id
-        sig { returns(String) }
-        attr_accessor :customer_id
-
-        # Feature id
-        sig { returns(String) }
-        attr_accessor :feature_id
-
-        # Timestamp
-        sig { returns(Time) }
-        attr_accessor :timestamp
-
-        # The usage measurement record
-        sig { returns(Float) }
-        attr_accessor :value
-
-        # The current measured usage value
-        sig { returns(T.nilable(Float)) }
-        attr_accessor :current_usage
-
-        # The date when the next usage reset will occur
-        sig { returns(T.nilable(Time)) }
-        attr_accessor :next_reset_date
-
-        # Resource id
-        sig { returns(T.nilable(String)) }
-        attr_accessor :resource_id
-
-        # The end date of the usage period in which this measurement resides (for
-        # entitlements with a reset period)
-        sig { returns(T.nilable(Time)) }
-        attr_accessor :usage_period_end
-
-        # The start date of the usage period in which this measurement resides (for
-        # entitlements with a reset period)
-        sig { returns(T.nilable(Time)) }
-        attr_accessor :usage_period_start
-
-        sig do
-          params(
-            id: String,
-            created_at: Time,
-            customer_id: String,
-            feature_id: String,
-            timestamp: Time,
-            value: Float,
-            current_usage: T.nilable(Float),
-            next_reset_date: T.nilable(Time),
-            resource_id: T.nilable(String),
-            usage_period_end: T.nilable(Time),
-            usage_period_start: T.nilable(Time)
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Unique identifier for the entity
-          id:,
-          # Timestamp of when the record was created
-          created_at:,
-          # Customer id
-          customer_id:,
-          # Feature id
-          feature_id:,
-          # Timestamp
-          timestamp:,
-          # The usage measurement record
-          value:,
-          # The current measured usage value
-          current_usage: nil,
-          # The date when the next usage reset will occur
-          next_reset_date: nil,
-          # Resource id
-          resource_id: nil,
-          # The end date of the usage period in which this measurement resides (for
-          # entitlements with a reset period)
-          usage_period_end: nil,
-          # The start date of the usage period in which this measurement resides (for
-          # entitlements with a reset period)
-          usage_period_start: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              id: String,
-              created_at: Time,
-              customer_id: String,
-              feature_id: String,
-              timestamp: Time,
-              value: Float,
-              current_usage: T.nilable(Float),
-              next_reset_date: T.nilable(Time),
-              resource_id: T.nilable(String),
-              usage_period_end: T.nilable(Time),
-              usage_period_start: T.nilable(Time)
-            }
-          )
-        end
-        def to_hash
-        end
-      end
-    end
-  end
-end

data/rbi/stigg/resources/v1/customers/usage.rbi

@@ -1,45 +0,0 @@
-# typed: strong
-
-module Stigg
-  module Resources
-    class V1
-      class Customers
-        class Usage
-          # Perform retrieval on a Usage history
-          sig do
-            params(
-              feature_id: String,
-              customer_id: String,
-              start_date: Time,
-              end_date: Time,
-              group_by: String,
-              resource_id: T.nilable(String),
-              request_options: Stigg::RequestOptions::OrHash
-            ).returns(Stigg::Models::V1::Customers::UsageRetrieveResponse)
-          end
-          def retrieve(
-            # Path param: Feature id
-            feature_id,
-            # Path param: Customer id
-            customer_id:,
-            # Query param: The start date of the range
-            start_date:,
-            # Query param: The end date of the range
-            end_date: nil,
-            # Query param
-            group_by: nil,
-            # Query param: Resource id
-            resource_id: nil,
-            request_options: {}
-          )
-          end
-
-          # @api private
-          sig { params(client: Stigg::Client).returns(T.attached_class) }
-          def self.new(client:)
-          end
-        end
-      end
-    end
-  end
-end