orb-billing 0.3.1 → 0.4.0

data/rbi/orb/models/events/backfill_revert_response.rbi

@@ -4,6 +4,14 @@ module Orb
   module Models
     module Events
       class BackfillRevertResponse < Orb::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Orb::Models::Events::BackfillRevertResponse,
+              Orb::Internal::AnyHash
+            )
+          end
+
         sig { returns(String) }
         attr_accessor :id
 
@@ -35,7 +43,11 @@ module Orb
         attr_accessor :reverted_at
 
         # The status of the backfill.
-        sig { returns(Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol) }
+        sig do
+          returns(
+            Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol
+          )
+        end
         attr_accessor :status
 
         sig { returns(Time) }
@@ -61,12 +73,12 @@ module Orb
             events_ingested: Integer,
             replace_existing_events: T::Boolean,
             reverted_at: T.nilable(Time),
-            status: Orb::Models::Events::BackfillRevertResponse::Status::OrSymbol,
+            status:
+              Orb::Models::Events::BackfillRevertResponse::Status::OrSymbol,
             timeframe_end: Time,
             timeframe_start: Time,
             deprecation_filter: T.nilable(String)
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           id:,
@@ -93,42 +105,70 @@ module Orb
           # [computed property](/extensibility/advanced-metrics#computed-properties) used to
           # filter the set of events to deprecate
           deprecation_filter: nil
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                id: String,
-                close_time: T.nilable(Time),
-                created_at: Time,
-                customer_id: T.nilable(String),
-                events_ingested: Integer,
-                replace_existing_events: T::Boolean,
-                reverted_at: T.nilable(Time),
-                status: Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol,
-                timeframe_end: Time,
-                timeframe_start: Time,
-                deprecation_filter: T.nilable(String)
-              }
-            )
+          override.returns(
+            {
+              id: String,
+              close_time: T.nilable(Time),
+              created_at: Time,
+              customer_id: T.nilable(String),
+              events_ingested: Integer,
+              replace_existing_events: T::Boolean,
+              reverted_at: T.nilable(Time),
+              status:
+                Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol,
+              timeframe_end: Time,
+              timeframe_start: Time,
+              deprecation_filter: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         # The status of the backfill.
         module Status
           extend Orb::Internal::Type::Enum
 
-          TaggedSymbol = T.type_alias { T.all(Symbol, Orb::Models::Events::BackfillRevertResponse::Status) }
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Orb::Models::Events::BackfillRevertResponse::Status)
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          PENDING = T.let(:pending, Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol)
-          REFLECTED = T.let(:reflected, Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol)
+          PENDING =
+            T.let(
+              :pending,
+              Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol
+            )
+          REFLECTED =
+            T.let(
+              :reflected,
+              Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol
+            )
           PENDING_REVERT =
-            T.let(:pending_revert, Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol)
-          REVERTED = T.let(:reverted, Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol)
+            T.let(
+              :pending_revert,
+              Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol
+            )
+          REVERTED =
+            T.let(
+              :reverted,
+              Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[
+                Orb::Models::Events::BackfillRevertResponse::Status::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
         end
       end
     end

data/rbi/orb/models/events/event_volumes.rbi

@@ -6,19 +6,34 @@ module Orb
 
     module Events
       class EventVolumes < Orb::Internal::Type::BaseModel
-        sig { returns(T::Array[Orb::Models::Events::EventVolumes::Data]) }
+        OrHash =
+          T.type_alias do
+            T.any(Orb::Events::EventVolumes, Orb::Internal::AnyHash)
+          end
+
+        sig { returns(T::Array[Orb::Events::EventVolumes::Data]) }
         attr_accessor :data
 
         sig do
-          params(data: T::Array[T.any(Orb::Models::Events::EventVolumes::Data, Orb::Internal::AnyHash)])
-            .returns(T.attached_class)
+          params(
+            data: T::Array[Orb::Events::EventVolumes::Data::OrHash]
+          ).returns(T.attached_class)
+        end
+        def self.new(data:)
         end
-        def self.new(data:); end
 
-        sig { override.returns({data: T::Array[Orb::Models::Events::EventVolumes::Data]}) }
-        def to_hash; end
+        sig do
+          override.returns({ data: T::Array[Orb::Events::EventVolumes::Data] })
+        end
+        def to_hash
+        end
 
         class Data < Orb::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(Orb::Events::EventVolumes::Data, Orb::Internal::AnyHash)
+            end
+
           # The number of events ingested with a timestamp between the timeframe
           sig { returns(Integer) }
           attr_accessor :count
@@ -31,15 +46,28 @@ module Orb
 
           # An EventVolume contains the event volume ingested in an hourly window. The
           # timestamp used for the aggregation is the `timestamp` datetime field on events.
-          sig { params(count: Integer, timeframe_end: Time, timeframe_start: Time).returns(T.attached_class) }
+          sig do
+            params(
+              count: Integer,
+              timeframe_end: Time,
+              timeframe_start: Time
+            ).returns(T.attached_class)
+          end
           def self.new(
             # The number of events ingested with a timestamp between the timeframe
             count:,
             timeframe_end:,
             timeframe_start:
-          ); end
-          sig { override.returns({count: Integer, timeframe_end: Time, timeframe_start: Time}) }
-          def to_hash; end
+          )
+          end
+
+          sig do
+            override.returns(
+              { count: Integer, timeframe_end: Time, timeframe_start: Time }
+            )
+          end
+          def to_hash
+          end
         end
       end
     end

data/rbi/orb/models/events/volume_list_params.rbi

@@ -7,6 +7,11 @@ module Orb
         extend Orb::Internal::Type::RequestParameters::Converter
         include Orb::Internal::Type::RequestParameters
 
+        OrHash =
+          T.type_alias do
+            T.any(Orb::Events::VolumeListParams, Orb::Internal::AnyHash)
+          end
+
         # The start of the timeframe, inclusive, in which to return event volume. All
         # datetime values are converted to UTC time. If the specified time isn't
         # hour-aligned, the response includes the event volume count for the hour the time
@@ -42,9 +47,8 @@ module Orb
             cursor: T.nilable(String),
             limit: Integer,
             timeframe_end: Time,
-            request_options: T.any(Orb::RequestOptions, Orb::Internal::AnyHash)
-          )
-            .returns(T.attached_class)
+            request_options: Orb::RequestOptions::OrHash
+          ).returns(T.attached_class)
         end
         def self.new(
           # The start of the timeframe, inclusive, in which to return event volume. All
@@ -63,20 +67,22 @@ module Orb
           # volumecount for the hour the time falls in.
           timeframe_end: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                timeframe_start: Time,
-                cursor: T.nilable(String),
-                limit: Integer,
-                timeframe_end: Time,
-                request_options: Orb::RequestOptions
-              }
-            )
+          override.returns(
+            {
+              timeframe_start: Time,
+              cursor: T.nilable(String),
+              limit: Integer,
+              timeframe_end: Time,
+              request_options: Orb::RequestOptions
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end