orb-billing 0.3.1 → 0.3.2

data/rbi/orb/models/event_ingest_params.rbi

@@ -6,7 +6,9 @@ module Orb
       extend Orb::Internal::Type::RequestParameters::Converter
       include Orb::Internal::Type::RequestParameters
 
-      sig { returns(T::Array[Orb::Models::EventIngestParams::Event]) }
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
+      sig { returns(T::Array[Orb::EventIngestParams::Event]) }
       attr_accessor :events
 
       # If this ingestion request is part of a backfill, this parameter ties the
@@ -23,12 +25,11 @@ module Orb
 
       sig do
         params(
-          events: T::Array[T.any(Orb::Models::EventIngestParams::Event, Orb::Internal::AnyHash)],
+          events: T::Array[Orb::EventIngestParams::Event::OrHash],
           backfill_id: T.nilable(String),
           debug: T::Boolean,
-          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(
         events:,
@@ -38,21 +39,25 @@ module Orb
         # Flag to enable additional debug information in the endpoint response
         debug: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              events: T::Array[Orb::Models::EventIngestParams::Event],
-              backfill_id: T.nilable(String),
-              debug: T::Boolean,
-              request_options: Orb::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            events: T::Array[Orb::EventIngestParams::Event],
+            backfill_id: T.nilable(String),
+            debug: T::Boolean,
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class Event < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         # A name to meaningfully identify the action or event type.
         sig { returns(String) }
         attr_accessor :event_name
@@ -91,8 +96,7 @@ module Orb
             timestamp: Time,
             customer_id: T.nilable(String),
             external_customer_id: T.nilable(String)
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # A name to meaningfully identify the action or event type.
@@ -113,21 +117,23 @@ module Orb
           # An alias for the Orb customer, whose mapping is specified when creating the
           # customer
           external_customer_id: nil
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                event_name: String,
-                idempotency_key: String,
-                properties: T.anything,
-                timestamp: Time,
-                customer_id: T.nilable(String),
-                external_customer_id: T.nilable(String)
-              }
-            )
+          override.returns(
+            {
+              event_name: String,
+              idempotency_key: String,
+              properties: T.anything,
+              timestamp: Time,
+              customer_id: T.nilable(String),
+              external_customer_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end

data/rbi/orb/models/event_ingest_response.rbi

@@ -3,9 +3,13 @@
 module Orb
   module Models
     class EventIngestResponse < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # Contains all failing validation events. In the case of a 200, this array will
       # always be empty. This field will always be present.
-      sig { returns(T::Array[Orb::Models::EventIngestResponse::ValidationFailed]) }
+      sig do
+        returns(T::Array[Orb::Models::EventIngestResponse::ValidationFailed])
+      end
       attr_accessor :validation_failed
 
       # Optional debug information (only present when debug=true is passed to the
@@ -13,15 +17,21 @@ module Orb
       sig { returns(T.nilable(Orb::Models::EventIngestResponse::Debug)) }
       attr_reader :debug
 
-      sig { params(debug: T.nilable(T.any(Orb::Models::EventIngestResponse::Debug, Orb::Internal::AnyHash))).void }
+      sig do
+        params(
+          debug: T.nilable(Orb::Models::EventIngestResponse::Debug::OrHash)
+        ).void
+      end
       attr_writer :debug
 
       sig do
         params(
-          validation_failed: T::Array[T.any(Orb::Models::EventIngestResponse::ValidationFailed, Orb::Internal::AnyHash)],
-          debug: T.nilable(T.any(Orb::Models::EventIngestResponse::Debug, Orb::Internal::AnyHash))
-        )
-          .returns(T.attached_class)
+          validation_failed:
+            T::Array[
+              Orb::Models::EventIngestResponse::ValidationFailed::OrHash
+            ],
+          debug: T.nilable(Orb::Models::EventIngestResponse::Debug::OrHash)
+        ).returns(T.attached_class)
       end
       def self.new(
         # Contains all failing validation events. In the case of a 200, this array will
@@ -30,19 +40,24 @@ module Orb
         # Optional debug information (only present when debug=true is passed to the
         # endpoint). Contains ingested and duplicate event idempotency keys.
         debug: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              validation_failed: T::Array[Orb::Models::EventIngestResponse::ValidationFailed],
-              debug: T.nilable(Orb::Models::EventIngestResponse::Debug)
-            }
-          )
+        override.returns(
+          {
+            validation_failed:
+              T::Array[Orb::Models::EventIngestResponse::ValidationFailed],
+            debug: T.nilable(Orb::Models::EventIngestResponse::Debug)
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class ValidationFailed < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         # The passed idempotency_key corresponding to the validation_errors
         sig { returns(String) }
         attr_accessor :idempotency_key
@@ -52,19 +67,33 @@ module Orb
         sig { returns(T::Array[String]) }
         attr_accessor :validation_errors
 
-        sig { params(idempotency_key: String, validation_errors: T::Array[String]).returns(T.attached_class) }
+        sig do
+          params(
+            idempotency_key: String,
+            validation_errors: T::Array[String]
+          ).returns(T.attached_class)
+        end
         def self.new(
           # The passed idempotency_key corresponding to the validation_errors
           idempotency_key:,
           # An array of strings corresponding to validation failures for this
           # idempotency_key.
           validation_errors:
-        ); end
-        sig { override.returns({idempotency_key: String, validation_errors: T::Array[String]}) }
-        def to_hash; end
+        )
+        end
+
+        sig do
+          override.returns(
+            { idempotency_key: String, validation_errors: T::Array[String] }
+          )
+        end
+        def to_hash
+        end
       end
 
       class Debug < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         sig { returns(T::Array[String]) }
         attr_accessor :duplicate
 
@@ -73,11 +102,22 @@ module Orb
 
         # Optional debug information (only present when debug=true is passed to the
         # endpoint). Contains ingested and duplicate event idempotency keys.
-        sig { params(duplicate: T::Array[String], ingested: T::Array[String]).returns(T.attached_class) }
-        def self.new(duplicate:, ingested:); end
+        sig do
+          params(
+            duplicate: T::Array[String],
+            ingested: T::Array[String]
+          ).returns(T.attached_class)
+        end
+        def self.new(duplicate:, ingested:)
+        end
 
-        sig { override.returns({duplicate: T::Array[String], ingested: T::Array[String]}) }
-        def to_hash; end
+        sig do
+          override.returns(
+            { duplicate: T::Array[String], ingested: T::Array[String] }
+          )
+        end
+        def to_hash
+        end
       end
     end
   end

data/rbi/orb/models/event_search_params.rbi

@@ -6,6 +6,8 @@ module Orb
       extend Orb::Internal::Type::RequestParameters::Converter
       include Orb::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # This is an explicit array of IDs to filter by. Note that an event's ID is the
       # idempotency_key that was originally used for ingestion, and this only supports
       # events that have not been amended. Values in this array will be treated case
@@ -28,9 +30,8 @@ module Orb
           event_ids: T::Array[String],
           timeframe_end: T.nilable(Time),
           timeframe_start: T.nilable(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(
         # This is an explicit array of IDs to filter by. Note that an event's ID is the
@@ -45,19 +46,21 @@ module Orb
         # specified, the one week ago is used.
         timeframe_start: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              event_ids: T::Array[String],
-              timeframe_end: T.nilable(Time),
-              timeframe_start: T.nilable(Time),
-              request_options: Orb::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            event_ids: T::Array[String],
+            timeframe_end: T.nilable(Time),
+            timeframe_start: T.nilable(Time),
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
     end
   end
 end

data/rbi/orb/models/event_search_response.rbi

@@ -3,19 +3,30 @@
 module Orb
   module Models
     class EventSearchResponse < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       sig { returns(T::Array[Orb::Models::EventSearchResponse::Data]) }
       attr_accessor :data
 
       sig do
-        params(data: T::Array[T.any(Orb::Models::EventSearchResponse::Data, Orb::Internal::AnyHash)])
-          .returns(T.attached_class)
+        params(
+          data: T::Array[Orb::Models::EventSearchResponse::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::EventSearchResponse::Data]}) }
-      def to_hash; end
+      sig do
+        override.returns(
+          { data: T::Array[Orb::Models::EventSearchResponse::Data] }
+        )
+      end
+      def to_hash
+      end
 
       class Data < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         # A unique value, generated by the client, that is used to de-duplicate events.
         # Exactly one event with a given idempotency key will be ingested, which allows
         # for safe request retries.
@@ -62,8 +73,7 @@ module Orb
             external_customer_id: T.nilable(String),
             properties: T.anything,
             timestamp: Time
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # A unique value, generated by the client, that is used to de-duplicate events.
@@ -86,22 +96,24 @@ module Orb
           # represent the time that usage was recorded, and is particularly important to
           # attribute usage to a given billing period.
           timestamp:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                id: String,
-                customer_id: T.nilable(String),
-                deprecated: T::Boolean,
-                event_name: String,
-                external_customer_id: T.nilable(String),
-                properties: T.anything,
-                timestamp: Time
-              }
-            )
+          override.returns(
+            {
+              id: String,
+              customer_id: T.nilable(String),
+              deprecated: T::Boolean,
+              event_name: String,
+              external_customer_id: T.nilable(String),
+              properties: T.anything,
+              timestamp: Time
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end

data/rbi/orb/models/event_update_params.rbi

@@ -6,6 +6,8 @@ module Orb
       extend Orb::Internal::Type::RequestParameters::Converter
       include Orb::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # A name to meaningfully identify the action or event type.
       sig { returns(String) }
       attr_accessor :event_name
@@ -37,9 +39,8 @@ module Orb
           timestamp: Time,
           customer_id: T.nilable(String),
           external_customer_id: T.nilable(String),
-          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(
         # A name to meaningfully identify the action or event type.
@@ -57,21 +58,23 @@ module Orb
         # customer
         external_customer_id: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              event_name: String,
-              properties: T.anything,
-              timestamp: Time,
-              customer_id: T.nilable(String),
-              external_customer_id: T.nilable(String),
-              request_options: Orb::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            event_name: String,
+            properties: T.anything,
+            timestamp: Time,
+            customer_id: T.nilable(String),
+            external_customer_id: T.nilable(String),
+            request_options: Orb::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
     end
   end
 end

data/rbi/orb/models/event_update_response.rbi

@@ -3,6 +3,8 @@
 module Orb
   module Models
     class EventUpdateResponse < Orb::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
       # event_id of the amended event, if successfully ingested
       sig { returns(String) }
       attr_accessor :amended
@@ -11,9 +13,12 @@ module Orb
       def self.new(
         # event_id of the amended event, if successfully ingested
         amended:
-      ); end
-      sig { override.returns({amended: String}) }
-      def to_hash; end
+      )
+      end
+
+      sig { override.returns({ amended: String }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/orb/models/events/backfill_close_params.rbi

@@ -7,18 +7,19 @@ module Orb
         extend Orb::Internal::Type::RequestParameters::Converter
         include Orb::Internal::Type::RequestParameters
 
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         sig do
-          params(
-            request_options: T.any(
-              Orb::RequestOptions,
-              Orb::Internal::AnyHash
-            )
-          ).returns(T.attached_class)
+          params(request_options: Orb::RequestOptions::OrHash).returns(
+            T.attached_class
+          )
+        end
+        def self.new(request_options: {})
         end
-        def self.new(request_options: {}); end
 
-        sig { override.returns({request_options: Orb::RequestOptions}) }
-        def to_hash; end
+        sig { override.returns({ request_options: Orb::RequestOptions }) }
+        def to_hash
+        end
       end
     end
   end

data/rbi/orb/models/events/backfill_close_response.rbi

@@ -4,6 +4,8 @@ module Orb
   module Models
     module Events
       class BackfillCloseResponse < Orb::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Orb::Internal::AnyHash) }
+
         sig { returns(String) }
         attr_accessor :id
 
@@ -35,7 +37,11 @@ module Orb
         attr_accessor :reverted_at
 
         # The status of the backfill.
-        sig { returns(Orb::Models::Events::BackfillCloseResponse::Status::TaggedSymbol) }
+        sig do
+          returns(
+            Orb::Models::Events::BackfillCloseResponse::Status::TaggedSymbol
+          )
+        end
         attr_accessor :status
 
         sig { returns(Time) }
@@ -61,12 +67,12 @@ module Orb
             events_ingested: Integer,
             replace_existing_events: T::Boolean,
             reverted_at: T.nilable(Time),
-            status: Orb::Models::Events::BackfillCloseResponse::Status::OrSymbol,
+            status:
+              Orb::Models::Events::BackfillCloseResponse::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,41 +99,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::BackfillCloseResponse::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::BackfillCloseResponse::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::BackfillCloseResponse::Status) }
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Orb::Models::Events::BackfillCloseResponse::Status)
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          PENDING = T.let(:pending, Orb::Models::Events::BackfillCloseResponse::Status::TaggedSymbol)
-          REFLECTED = T.let(:reflected, Orb::Models::Events::BackfillCloseResponse::Status::TaggedSymbol)
-          PENDING_REVERT = T.let(:pending_revert, Orb::Models::Events::BackfillCloseResponse::Status::TaggedSymbol)
-          REVERTED = T.let(:reverted, Orb::Models::Events::BackfillCloseResponse::Status::TaggedSymbol)
+          PENDING =
+            T.let(
+              :pending,
+              Orb::Models::Events::BackfillCloseResponse::Status::TaggedSymbol
+            )
+          REFLECTED =
+            T.let(
+              :reflected,
+              Orb::Models::Events::BackfillCloseResponse::Status::TaggedSymbol
+            )
+          PENDING_REVERT =
+            T.let(
+              :pending_revert,
+              Orb::Models::Events::BackfillCloseResponse::Status::TaggedSymbol
+            )
+          REVERTED =
+            T.let(
+              :reverted,
+              Orb::Models::Events::BackfillCloseResponse::Status::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Orb::Models::Events::BackfillCloseResponse::Status::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[
+                Orb::Models::Events::BackfillCloseResponse::Status::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
         end
       end
     end