lithic 0.1.0.pre.alpha.22 → 0.1.0.pre.alpha.24

data/rbi/lithic/models/auth_rules/v2/backtest_results.rbi

@@ -5,108 +5,160 @@ module Lithic
     module AuthRules
       module V2
         class BacktestResults < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::AuthRules::V2::BacktestResults,
+                Lithic::Internal::AnyHash
+              )
+            end
+
           # Auth Rule Backtest Token
           sig { returns(String) }
           attr_accessor :backtest_token
 
-          sig { returns(Lithic::Models::AuthRules::V2::BacktestResults::Results) }
+          sig { returns(Lithic::AuthRules::V2::BacktestResults::Results) }
           attr_reader :results
 
           sig do
-            params(results: T.any(Lithic::Models::AuthRules::V2::BacktestResults::Results, Lithic::Internal::AnyHash))
-              .void
+            params(
+              results: Lithic::AuthRules::V2::BacktestResults::Results::OrHash
+            ).void
           end
           attr_writer :results
 
-          sig { returns(Lithic::Models::AuthRules::V2::BacktestResults::SimulationParameters) }
+          sig do
+            returns(
+              Lithic::AuthRules::V2::BacktestResults::SimulationParameters
+            )
+          end
           attr_reader :simulation_parameters
 
           sig do
             params(
-              simulation_parameters: T.any(Lithic::Models::AuthRules::V2::BacktestResults::SimulationParameters, Lithic::Internal::AnyHash)
-            )
-              .void
+              simulation_parameters:
+                Lithic::AuthRules::V2::BacktestResults::SimulationParameters::OrHash
+            ).void
           end
           attr_writer :simulation_parameters
 
           sig do
             params(
               backtest_token: String,
-              results: T.any(Lithic::Models::AuthRules::V2::BacktestResults::Results, Lithic::Internal::AnyHash),
-              simulation_parameters: T.any(Lithic::Models::AuthRules::V2::BacktestResults::SimulationParameters, Lithic::Internal::AnyHash)
-            )
-              .returns(T.attached_class)
+              results: Lithic::AuthRules::V2::BacktestResults::Results::OrHash,
+              simulation_parameters:
+                Lithic::AuthRules::V2::BacktestResults::SimulationParameters::OrHash
+            ).returns(T.attached_class)
           end
           def self.new(
             # Auth Rule Backtest Token
             backtest_token:,
             results:,
             simulation_parameters:
-          ); end
+          )
+          end
+
           sig do
-            override
-              .returns(
-                {
-                  backtest_token: String,
-                  results: Lithic::Models::AuthRules::V2::BacktestResults::Results,
-                  simulation_parameters: Lithic::Models::AuthRules::V2::BacktestResults::SimulationParameters
-                }
-              )
+            override.returns(
+              {
+                backtest_token: String,
+                results: Lithic::AuthRules::V2::BacktestResults::Results,
+                simulation_parameters:
+                  Lithic::AuthRules::V2::BacktestResults::SimulationParameters
+              }
+            )
+          end
+          def to_hash
           end
-          def to_hash; end
 
           class Results < Lithic::Internal::Type::BaseModel
-            sig { returns(T.nilable(Lithic::Models::AuthRules::V2::BacktestResults::Results::CurrentVersion)) }
-            attr_reader :current_version
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::AuthRules::V2::BacktestResults::Results,
+                  Lithic::Internal::AnyHash
+                )
+              end
 
             sig do
-              params(
-                current_version: T.nilable(
-                  T.any(Lithic::Models::AuthRules::V2::BacktestResults::Results::CurrentVersion, Lithic::Internal::AnyHash)
+              returns(
+                T.nilable(
+                  Lithic::AuthRules::V2::BacktestResults::Results::CurrentVersion
                 )
               )
-                .void
+            end
+            attr_reader :current_version
+
+            sig do
+              params(
+                current_version:
+                  T.nilable(
+                    Lithic::AuthRules::V2::BacktestResults::Results::CurrentVersion::OrHash
+                  )
+              ).void
             end
             attr_writer :current_version
 
-            sig { returns(T.nilable(Lithic::Models::AuthRules::V2::BacktestResults::Results::DraftVersion)) }
+            sig do
+              returns(
+                T.nilable(
+                  Lithic::AuthRules::V2::BacktestResults::Results::DraftVersion
+                )
+              )
+            end
             attr_reader :draft_version
 
             sig do
               params(
-                draft_version: T.nilable(
-                  T.any(Lithic::Models::AuthRules::V2::BacktestResults::Results::DraftVersion, Lithic::Internal::AnyHash)
-                )
-              )
-                .void
+                draft_version:
+                  T.nilable(
+                    Lithic::AuthRules::V2::BacktestResults::Results::DraftVersion::OrHash
+                  )
+              ).void
             end
             attr_writer :draft_version
 
             sig do
               params(
-                current_version: T.nilable(
-                  T.any(Lithic::Models::AuthRules::V2::BacktestResults::Results::CurrentVersion, Lithic::Internal::AnyHash)
-                ),
-                draft_version: T.nilable(
-                  T.any(Lithic::Models::AuthRules::V2::BacktestResults::Results::DraftVersion, Lithic::Internal::AnyHash)
-                )
-              )
-                .returns(T.attached_class)
+                current_version:
+                  T.nilable(
+                    Lithic::AuthRules::V2::BacktestResults::Results::CurrentVersion::OrHash
+                  ),
+                draft_version:
+                  T.nilable(
+                    Lithic::AuthRules::V2::BacktestResults::Results::DraftVersion::OrHash
+                  )
+              ).returns(T.attached_class)
+            end
+            def self.new(current_version: nil, draft_version: nil)
             end
-            def self.new(current_version: nil, draft_version: nil); end
 
             sig do
-              override
-                .returns(
-                  {
-                    current_version: T.nilable(Lithic::Models::AuthRules::V2::BacktestResults::Results::CurrentVersion),
-                    draft_version: T.nilable(Lithic::Models::AuthRules::V2::BacktestResults::Results::DraftVersion)
-                  }
-                )
+              override.returns(
+                {
+                  current_version:
+                    T.nilable(
+                      Lithic::AuthRules::V2::BacktestResults::Results::CurrentVersion
+                    ),
+                  draft_version:
+                    T.nilable(
+                      Lithic::AuthRules::V2::BacktestResults::Results::DraftVersion
+                    )
+                }
+              )
+            end
+            def to_hash
             end
-            def to_hash; end
 
             class CurrentVersion < Lithic::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Lithic::AuthRules::V2::BacktestResults::Results::CurrentVersion,
+                    Lithic::Internal::AnyHash
+                  )
+                end
+
               # The total number of historical transactions approved by this rule during the
               # backtest period, or the number of transactions that would have been approved if
               # the rule was evaluated in shadow mode.
@@ -128,21 +180,22 @@ module Lithic
               # Example authorization request events that would have been approved or declined.
               sig do
                 returns(
-                  T.nilable(T::Array[Lithic::Models::AuthRules::V2::BacktestResults::Results::CurrentVersion::Example])
+                  T.nilable(
+                    T::Array[
+                      Lithic::AuthRules::V2::BacktestResults::Results::CurrentVersion::Example
+                    ]
+                  )
                 )
               end
               attr_reader :examples
 
               sig do
                 params(
-                  examples: T::Array[
-                    T.any(
-                      Lithic::Models::AuthRules::V2::BacktestResults::Results::CurrentVersion::Example,
-                      Lithic::Internal::AnyHash
-                    )
-                  ]
-                )
-                  .void
+                  examples:
+                    T::Array[
+                      Lithic::AuthRules::V2::BacktestResults::Results::CurrentVersion::Example::OrHash
+                    ]
+                ).void
               end
               attr_writer :examples
 
@@ -158,15 +211,12 @@ module Lithic
                 params(
                   approved: Integer,
                   declined: Integer,
-                  examples: T::Array[
-                    T.any(
-                      Lithic::Models::AuthRules::V2::BacktestResults::Results::CurrentVersion::Example,
-                      Lithic::Internal::AnyHash
-                    )
-                  ],
+                  examples:
+                    T::Array[
+                      Lithic::AuthRules::V2::BacktestResults::Results::CurrentVersion::Example::OrHash
+                    ],
                   version: Integer
-                )
-                  .returns(T.attached_class)
+                ).returns(T.attached_class)
               end
               def self.new(
                 # The total number of historical transactions approved by this rule during the
@@ -182,21 +232,34 @@ module Lithic
                 # The version of the rule, this is incremented whenever the rule's parameters
                 # change.
                 version: nil
-              ); end
+              )
+              end
+
               sig do
-                override
-                  .returns(
-                    {
-                      approved: Integer,
-                      declined: Integer,
-                      examples: T::Array[Lithic::Models::AuthRules::V2::BacktestResults::Results::CurrentVersion::Example],
-                      version: Integer
-                    }
-                  )
+                override.returns(
+                  {
+                    approved: Integer,
+                    declined: Integer,
+                    examples:
+                      T::Array[
+                        Lithic::AuthRules::V2::BacktestResults::Results::CurrentVersion::Example
+                      ],
+                    version: Integer
+                  }
+                )
+              end
+              def to_hash
               end
-              def to_hash; end
 
               class Example < Lithic::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Lithic::AuthRules::V2::BacktestResults::Results::CurrentVersion::Example,
+                      Lithic::Internal::AnyHash
+                    )
+                  end
+
                 # Whether the rule would have approved the authorization request.
                 sig { returns(T.nilable(T::Boolean)) }
                 attr_reader :approved
@@ -219,7 +282,11 @@ module Lithic
                 attr_writer :timestamp
 
                 sig do
-                  params(approved: T::Boolean, event_token: String, timestamp: Time).returns(T.attached_class)
+                  params(
+                    approved: T::Boolean,
+                    event_token: String,
+                    timestamp: Time
+                  ).returns(T.attached_class)
                 end
                 def self.new(
                   # Whether the rule would have approved the authorization request.
@@ -228,13 +295,32 @@ module Lithic
                   event_token: nil,
                   # The timestamp of the authorization request event.
                   timestamp: nil
-                ); end
-                sig { override.returns({approved: T::Boolean, event_token: String, timestamp: Time}) }
-                def to_hash; end
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      approved: T::Boolean,
+                      event_token: String,
+                      timestamp: Time
+                    }
+                  )
+                end
+                def to_hash
+                end
               end
             end
 
             class DraftVersion < Lithic::Internal::Type::BaseModel
+              OrHash =
+                T.type_alias do
+                  T.any(
+                    Lithic::AuthRules::V2::BacktestResults::Results::DraftVersion,
+                    Lithic::Internal::AnyHash
+                  )
+                end
+
               # The total number of historical transactions approved by this rule during the
               # backtest period, or the number of transactions that would have been approved if
               # the rule was evaluated in shadow mode.
@@ -256,21 +342,22 @@ module Lithic
               # Example authorization request events that would have been approved or declined.
               sig do
                 returns(
-                  T.nilable(T::Array[Lithic::Models::AuthRules::V2::BacktestResults::Results::DraftVersion::Example])
+                  T.nilable(
+                    T::Array[
+                      Lithic::AuthRules::V2::BacktestResults::Results::DraftVersion::Example
+                    ]
+                  )
                 )
               end
               attr_reader :examples
 
               sig do
                 params(
-                  examples: T::Array[
-                    T.any(
-                      Lithic::Models::AuthRules::V2::BacktestResults::Results::DraftVersion::Example,
-                      Lithic::Internal::AnyHash
-                    )
-                  ]
-                )
-                  .void
+                  examples:
+                    T::Array[
+                      Lithic::AuthRules::V2::BacktestResults::Results::DraftVersion::Example::OrHash
+                    ]
+                ).void
               end
               attr_writer :examples
 
@@ -286,15 +373,12 @@ module Lithic
                 params(
                   approved: Integer,
                   declined: Integer,
-                  examples: T::Array[
-                    T.any(
-                      Lithic::Models::AuthRules::V2::BacktestResults::Results::DraftVersion::Example,
-                      Lithic::Internal::AnyHash
-                    )
-                  ],
+                  examples:
+                    T::Array[
+                      Lithic::AuthRules::V2::BacktestResults::Results::DraftVersion::Example::OrHash
+                    ],
                   version: Integer
-                )
-                  .returns(T.attached_class)
+                ).returns(T.attached_class)
               end
               def self.new(
                 # The total number of historical transactions approved by this rule during the
@@ -310,21 +394,34 @@ module Lithic
                 # The version of the rule, this is incremented whenever the rule's parameters
                 # change.
                 version: nil
-              ); end
+              )
+              end
+
               sig do
-                override
-                  .returns(
-                    {
-                      approved: Integer,
-                      declined: Integer,
-                      examples: T::Array[Lithic::Models::AuthRules::V2::BacktestResults::Results::DraftVersion::Example],
-                      version: Integer
-                    }
-                  )
+                override.returns(
+                  {
+                    approved: Integer,
+                    declined: Integer,
+                    examples:
+                      T::Array[
+                        Lithic::AuthRules::V2::BacktestResults::Results::DraftVersion::Example
+                      ],
+                    version: Integer
+                  }
+                )
+              end
+              def to_hash
               end
-              def to_hash; end
 
               class Example < Lithic::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      Lithic::AuthRules::V2::BacktestResults::Results::DraftVersion::Example,
+                      Lithic::Internal::AnyHash
+                    )
+                  end
+
                 # Whether the rule would have approved the authorization request.
                 sig { returns(T.nilable(T::Boolean)) }
                 attr_reader :approved
@@ -347,7 +444,11 @@ module Lithic
                 attr_writer :timestamp
 
                 sig do
-                  params(approved: T::Boolean, event_token: String, timestamp: Time).returns(T.attached_class)
+                  params(
+                    approved: T::Boolean,
+                    event_token: String,
+                    timestamp: Time
+                  ).returns(T.attached_class)
                 end
                 def self.new(
                   # Whether the rule would have approved the authorization request.
@@ -356,14 +457,33 @@ module Lithic
                   event_token: nil,
                   # The timestamp of the authorization request event.
                   timestamp: nil
-                ); end
-                sig { override.returns({approved: T::Boolean, event_token: String, timestamp: Time}) }
-                def to_hash; end
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      approved: T::Boolean,
+                      event_token: String,
+                      timestamp: Time
+                    }
+                  )
+                end
+                def to_hash
+                end
               end
             end
           end
 
           class SimulationParameters < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::AuthRules::V2::BacktestResults::SimulationParameters,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
             # Auth Rule Token
             sig { returns(T.nilable(String)) }
             attr_reader :auth_rule_token
@@ -385,7 +505,11 @@ module Lithic
             sig { params(start: Time).void }
             attr_writer :start
 
-            sig { params(auth_rule_token: String, end_: Time, start: Time).returns(T.attached_class) }
+            sig do
+              params(auth_rule_token: String, end_: Time, start: Time).returns(
+                T.attached_class
+              )
+            end
             def self.new(
               # Auth Rule Token
               auth_rule_token: nil,
@@ -393,9 +517,16 @@ module Lithic
               end_: nil,
               # The start time of the simulation.
               start: nil
-            ); end
-            sig { override.returns({auth_rule_token: String, end_: Time, start: Time}) }
-            def to_hash; end
+            )
+            end
+
+            sig do
+              override.returns(
+                { auth_rule_token: String, end_: Time, start: Time }
+              )
+            end
+            def to_hash
+            end
           end
         end
       end

data/rbi/lithic/models/auth_rules/v2/backtest_retrieve_params.rbi

@@ -8,23 +8,36 @@ module Lithic
           extend Lithic::Internal::Type::RequestParameters::Converter
           include Lithic::Internal::Type::RequestParameters
 
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::AuthRules::V2::BacktestRetrieveParams,
+                Lithic::Internal::AnyHash
+              )
+            end
+
           sig { returns(String) }
           attr_accessor :auth_rule_token
 
           sig do
             params(
               auth_rule_token: String,
-              request_options: T.any(
-                Lithic::RequestOptions,
-                Lithic::Internal::AnyHash
-              )
-            )
-              .returns(T.attached_class)
+              request_options: Lithic::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(auth_rule_token:, request_options: {})
           end
-          def self.new(auth_rule_token:, request_options: {}); end
 
-          sig { override.returns({auth_rule_token: String, request_options: Lithic::RequestOptions}) }
-          def to_hash; end
+          sig do
+            override.returns(
+              {
+                auth_rule_token: String,
+                request_options: Lithic::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
         end
       end
     end

data/rbi/lithic/models/auth_rules/v2_apply_params.rbi

@@ -7,6 +7,11 @@ module Lithic
         extend Lithic::Internal::Type::RequestParameters::Converter
         include Lithic::Internal::Type::RequestParameters
 
+        OrHash =
+          T.type_alias do
+            T.any(Lithic::AuthRules::V2ApplyParams, Lithic::Internal::AnyHash)
+          end
+
         # Account tokens to which the Auth Rule applies.
         sig { returns(T::Array[String]) }
         attr_accessor :account_tokens
@@ -32,9 +37,8 @@ module Lithic
             card_tokens: T::Array[String],
             program_level: T::Boolean,
             excluded_card_tokens: T::Array[String],
-            request_options: T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash)
-          )
-            .returns(T.attached_class)
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(T.attached_class)
         end
         def self.new(
           # Account tokens to which the Auth Rule applies.
@@ -46,20 +50,22 @@ module Lithic
           # Card tokens to which the Auth Rule does not apply.
           excluded_card_tokens: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                account_tokens: T::Array[String],
-                card_tokens: T::Array[String],
-                program_level: T::Boolean,
-                excluded_card_tokens: T::Array[String],
-                request_options: Lithic::RequestOptions
-              }
-            )
+          override.returns(
+            {
+              account_tokens: T::Array[String],
+              card_tokens: T::Array[String],
+              program_level: T::Boolean,
+              excluded_card_tokens: T::Array[String],
+              request_options: Lithic::RequestOptions
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end