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

data/rbi/lithic/models/auth_rules/auth_rule_condition.rbi

@@ -6,6 +6,14 @@ module Lithic
 
     module AuthRules
       class AuthRuleCondition < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::AuthRules::AuthRuleCondition,
+              Lithic::Internal::AnyHash
+            )
+          end
+
         # The attribute to target.
         #
         # The following attributes may be targeted:
@@ -53,17 +61,31 @@ module Lithic
         # - `WALLET_TYPE`: For transactions using a digital wallet token, indicates the
         #   source of the token. Valid values are `APPLE_PAY`, `GOOGLE_PAY`,
         #   `SAMSUNG_PAY`, `MASTERPASS`, `MERCHANT`, `OTHER`, `NONE`.
-        sig { returns(T.nilable(Lithic::Models::AuthRules::ConditionalAttribute::OrSymbol)) }
+        sig do
+          returns(T.nilable(Lithic::AuthRules::ConditionalAttribute::OrSymbol))
+        end
         attr_reader :attribute
 
-        sig { params(attribute: Lithic::Models::AuthRules::ConditionalAttribute::OrSymbol).void }
+        sig do
+          params(
+            attribute: Lithic::AuthRules::ConditionalAttribute::OrSymbol
+          ).void
+        end
         attr_writer :attribute
 
         # The operation to apply to the attribute
-        sig { returns(T.nilable(Lithic::Models::AuthRules::AuthRuleCondition::Operation::OrSymbol)) }
+        sig do
+          returns(
+            T.nilable(Lithic::AuthRules::AuthRuleCondition::Operation::OrSymbol)
+          )
+        end
         attr_reader :operation
 
-        sig { params(operation: Lithic::Models::AuthRules::AuthRuleCondition::Operation::OrSymbol).void }
+        sig do
+          params(
+            operation: Lithic::AuthRules::AuthRuleCondition::Operation::OrSymbol
+          ).void
+        end
         attr_writer :operation
 
         # A regex string, to be used with `MATCHES` or `DOES_NOT_MATCH`
@@ -75,11 +97,11 @@ module Lithic
 
         sig do
           params(
-            attribute: Lithic::Models::AuthRules::ConditionalAttribute::OrSymbol,
-            operation: Lithic::Models::AuthRules::AuthRuleCondition::Operation::OrSymbol,
+            attribute: Lithic::AuthRules::ConditionalAttribute::OrSymbol,
+            operation:
+              Lithic::AuthRules::AuthRuleCondition::Operation::OrSymbol,
             value: T.any(String, Integer, T::Array[String])
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # The attribute to target.
@@ -134,49 +156,93 @@ module Lithic
           operation: nil,
           # A regex string, to be used with `MATCHES` or `DOES_NOT_MATCH`
           value: nil
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                attribute: Lithic::Models::AuthRules::ConditionalAttribute::OrSymbol,
-                operation: Lithic::Models::AuthRules::AuthRuleCondition::Operation::OrSymbol,
-                value: T.any(String, Integer, T::Array[String])
-              }
-            )
+          override.returns(
+            {
+              attribute: Lithic::AuthRules::ConditionalAttribute::OrSymbol,
+              operation:
+                Lithic::AuthRules::AuthRuleCondition::Operation::OrSymbol,
+              value: T.any(String, Integer, T::Array[String])
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         # The operation to apply to the attribute
         module Operation
           extend Lithic::Internal::Type::Enum
 
-          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::AuthRuleCondition::Operation) }
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Lithic::AuthRules::AuthRuleCondition::Operation)
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          IS_ONE_OF = T.let(:IS_ONE_OF, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol)
+          IS_ONE_OF =
+            T.let(
+              :IS_ONE_OF,
+              Lithic::AuthRules::AuthRuleCondition::Operation::TaggedSymbol
+            )
           IS_NOT_ONE_OF =
-            T.let(:IS_NOT_ONE_OF, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol)
-          MATCHES = T.let(:MATCHES, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol)
+            T.let(
+              :IS_NOT_ONE_OF,
+              Lithic::AuthRules::AuthRuleCondition::Operation::TaggedSymbol
+            )
+          MATCHES =
+            T.let(
+              :MATCHES,
+              Lithic::AuthRules::AuthRuleCondition::Operation::TaggedSymbol
+            )
           DOES_NOT_MATCH =
-            T.let(:DOES_NOT_MATCH, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol)
+            T.let(
+              :DOES_NOT_MATCH,
+              Lithic::AuthRules::AuthRuleCondition::Operation::TaggedSymbol
+            )
           IS_GREATER_THAN =
-            T.let(:IS_GREATER_THAN, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol)
+            T.let(
+              :IS_GREATER_THAN,
+              Lithic::AuthRules::AuthRuleCondition::Operation::TaggedSymbol
+            )
           IS_LESS_THAN =
-            T.let(:IS_LESS_THAN, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol)
+            T.let(
+              :IS_LESS_THAN,
+              Lithic::AuthRules::AuthRuleCondition::Operation::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::AuthRules::AuthRuleCondition::Operation::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
         end
 
         # A regex string, to be used with `MATCHES` or `DOES_NOT_MATCH`
         module Value
           extend Lithic::Internal::Type::Union
 
-          sig { override.returns([String, Integer, T::Array[String]]) }
-          def self.variants; end
+          Variants = T.type_alias { T.any(String, Integer, T::Array[String]) }
 
-          StringArray = T.let(Lithic::Internal::Type::ArrayOf[String], Lithic::Internal::Type::Converter)
+          sig do
+            override.returns(
+              T::Array[Lithic::AuthRules::AuthRuleCondition::Value::Variants]
+            )
+          end
+          def self.variants
+          end
+
+          StringArray =
+            T.let(
+              Lithic::Internal::Type::ArrayOf[String],
+              Lithic::Internal::Type::Converter
+            )
         end
       end
     end

data/rbi/lithic/models/auth_rules/conditional_attribute.rbi

@@ -53,32 +53,93 @@ module Lithic
       module ConditionalAttribute
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::ConditionalAttribute) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::AuthRules::ConditionalAttribute)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        MCC = T.let(:MCC, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
-        COUNTRY = T.let(:COUNTRY, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
-        CURRENCY = T.let(:CURRENCY, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
-        MERCHANT_ID = T.let(:MERCHANT_ID, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
-        DESCRIPTOR = T.let(:DESCRIPTOR, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
-        LIABILITY_SHIFT = T.let(:LIABILITY_SHIFT, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
-        PAN_ENTRY_MODE = T.let(:PAN_ENTRY_MODE, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        MCC = T.let(:MCC, Lithic::AuthRules::ConditionalAttribute::TaggedSymbol)
+        COUNTRY =
+          T.let(:COUNTRY, Lithic::AuthRules::ConditionalAttribute::TaggedSymbol)
+        CURRENCY =
+          T.let(
+            :CURRENCY,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
+        MERCHANT_ID =
+          T.let(
+            :MERCHANT_ID,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
+        DESCRIPTOR =
+          T.let(
+            :DESCRIPTOR,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
+        LIABILITY_SHIFT =
+          T.let(
+            :LIABILITY_SHIFT,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
+        PAN_ENTRY_MODE =
+          T.let(
+            :PAN_ENTRY_MODE,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
         TRANSACTION_AMOUNT =
-          T.let(:TRANSACTION_AMOUNT, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
-        RISK_SCORE = T.let(:RISK_SCORE, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+          T.let(
+            :TRANSACTION_AMOUNT,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
+        RISK_SCORE =
+          T.let(
+            :RISK_SCORE,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
         CARD_TRANSACTION_COUNT_15_M =
-          T.let(:CARD_TRANSACTION_COUNT_15M, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+          T.let(
+            :CARD_TRANSACTION_COUNT_15M,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
         CARD_TRANSACTION_COUNT_1_H =
-          T.let(:CARD_TRANSACTION_COUNT_1H, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+          T.let(
+            :CARD_TRANSACTION_COUNT_1H,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
         CARD_TRANSACTION_COUNT_24_H =
-          T.let(:CARD_TRANSACTION_COUNT_24H, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
-        CARD_STATE = T.let(:CARD_STATE, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
-        PIN_ENTERED = T.let(:PIN_ENTERED, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
-        PIN_STATUS = T.let(:PIN_STATUS, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
-        WALLET_TYPE = T.let(:WALLET_TYPE, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+          T.let(
+            :CARD_TRANSACTION_COUNT_24H,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
+        CARD_STATE =
+          T.let(
+            :CARD_STATE,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
+        PIN_ENTERED =
+          T.let(
+            :PIN_ENTERED,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
+        PIN_STATUS =
+          T.let(
+            :PIN_STATUS,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
+        WALLET_TYPE =
+          T.let(
+            :WALLET_TYPE,
+            Lithic::AuthRules::ConditionalAttribute::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Lithic::AuthRules::ConditionalAttribute::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
     end
   end

data/rbi/lithic/models/auth_rules/conditional_block_parameters.rbi

@@ -4,19 +4,32 @@ module Lithic
   module Models
     module AuthRules
       class ConditionalBlockParameters < Lithic::Internal::Type::BaseModel
-        sig { returns(T::Array[Lithic::Models::AuthRules::AuthRuleCondition]) }
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::AuthRules::ConditionalBlockParameters,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T::Array[Lithic::AuthRules::AuthRuleCondition]) }
         attr_accessor :conditions
 
         sig do
           params(
-            conditions: T::Array[T.any(Lithic::Models::AuthRules::AuthRuleCondition, Lithic::Internal::AnyHash)]
-          )
-            .returns(T.attached_class)
+            conditions: T::Array[Lithic::AuthRules::AuthRuleCondition::OrHash]
+          ).returns(T.attached_class)
+        end
+        def self.new(conditions:)
         end
-        def self.new(conditions:); end
 
-        sig { override.returns({conditions: T::Array[Lithic::Models::AuthRules::AuthRuleCondition]}) }
-        def to_hash; end
+        sig do
+          override.returns(
+            { conditions: T::Array[Lithic::AuthRules::AuthRuleCondition] }
+          )
+        end
+        def to_hash
+        end
       end
     end
   end

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

@@ -8,6 +8,14 @@ module Lithic
           extend Lithic::Internal::Type::RequestParameters::Converter
           include Lithic::Internal::Type::RequestParameters
 
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::AuthRules::V2::BacktestCreateParams,
+                Lithic::Internal::AnyHash
+              )
+            end
+
           # The end time of the backtest.
           sig { returns(T.nilable(Time)) }
           attr_reader :end_
@@ -26,12 +34,8 @@ module Lithic
             params(
               end_: Time,
               start: Time,
-              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(
             # The end time of the backtest.
@@ -39,9 +43,20 @@ module Lithic
             # The start time of the backtest.
             start: nil,
             request_options: {}
-          ); end
-          sig { override.returns({end_: Time, start: Time, request_options: Lithic::RequestOptions}) }
-          def to_hash; end
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                end_: Time,
+                start: Time,
+                request_options: Lithic::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
         end
       end
     end

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

@@ -5,6 +5,14 @@ module Lithic
     module AuthRules
       module V2
         class BacktestCreateResponse < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::Models::AuthRules::V2::BacktestCreateResponse,
+                Lithic::Internal::AnyHash
+              )
+            end
+
           # Auth Rule Backtest Token
           sig { returns(T.nilable(String)) }
           attr_reader :backtest_token
@@ -16,9 +24,12 @@ module Lithic
           def self.new(
             # Auth Rule Backtest Token
             backtest_token: nil
-          ); end
-          sig { override.returns({backtest_token: String}) }
-          def to_hash; end
+          )
+          end
+
+          sig { override.returns({ backtest_token: String }) }
+          def to_hash
+          end
         end
       end
     end