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

data/rbi/lithic/models/tokenization_list_params.rbi

@@ -6,6 +6,11 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::TokenizationListParams, Lithic::Internal::AnyHash)
+        end
+
       # Filters for tokenizations associated with a specific account.
       sig { returns(T.nilable(String)) }
       attr_reader :account_token
@@ -59,10 +64,21 @@ module Lithic
 
       # Filter for tokenizations by tokenization channel. If this is not specified, only
       # DIGITAL_WALLET tokenizations will be returned.
-      sig { returns(T.nilable(Lithic::Models::TokenizationListParams::TokenizationChannel::OrSymbol)) }
+      sig do
+        returns(
+          T.nilable(
+            Lithic::TokenizationListParams::TokenizationChannel::OrSymbol
+          )
+        )
+      end
       attr_reader :tokenization_channel
 
-      sig { params(tokenization_channel: Lithic::Models::TokenizationListParams::TokenizationChannel::OrSymbol).void }
+      sig do
+        params(
+          tokenization_channel:
+            Lithic::TokenizationListParams::TokenizationChannel::OrSymbol
+        ).void
+      end
       attr_writer :tokenization_channel
 
       sig do
@@ -74,10 +90,10 @@ module Lithic
           ending_before: String,
           page_size: Integer,
           starting_after: String,
-          tokenization_channel: Lithic::Models::TokenizationListParams::TokenizationChannel::OrSymbol,
-          request_options: T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          tokenization_channel:
+            Lithic::TokenizationListParams::TokenizationChannel::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # Filters for tokenizations associated with a specific account.
@@ -100,24 +116,27 @@ module Lithic
         # DIGITAL_WALLET tokenizations will be returned.
         tokenization_channel: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              account_token: String,
-              begin_: Date,
-              card_token: String,
-              end_: Date,
-              ending_before: String,
-              page_size: Integer,
-              starting_after: String,
-              tokenization_channel: Lithic::Models::TokenizationListParams::TokenizationChannel::OrSymbol,
-              request_options: Lithic::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            account_token: String,
+            begin_: Date,
+            card_token: String,
+            end_: Date,
+            ending_before: String,
+            page_size: Integer,
+            starting_after: String,
+            tokenization_channel:
+              Lithic::TokenizationListParams::TokenizationChannel::OrSymbol,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       # Filter for tokenizations by tokenization channel. If this is not specified, only
       # DIGITAL_WALLET tokenizations will be returned.
@@ -125,16 +144,36 @@ module Lithic
         extend Lithic::Internal::Type::Enum
 
         TaggedSymbol =
-          T.type_alias { T.all(Symbol, Lithic::Models::TokenizationListParams::TokenizationChannel) }
+          T.type_alias do
+            T.all(Symbol, Lithic::TokenizationListParams::TokenizationChannel)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         DIGITAL_WALLET =
-          T.let(:DIGITAL_WALLET, Lithic::Models::TokenizationListParams::TokenizationChannel::TaggedSymbol)
-        MERCHANT = T.let(:MERCHANT, Lithic::Models::TokenizationListParams::TokenizationChannel::TaggedSymbol)
-        ALL = T.let(:ALL, Lithic::Models::TokenizationListParams::TokenizationChannel::TaggedSymbol)
+          T.let(
+            :DIGITAL_WALLET,
+            Lithic::TokenizationListParams::TokenizationChannel::TaggedSymbol
+          )
+        MERCHANT =
+          T.let(
+            :MERCHANT,
+            Lithic::TokenizationListParams::TokenizationChannel::TaggedSymbol
+          )
+        ALL =
+          T.let(
+            :ALL,
+            Lithic::TokenizationListParams::TokenizationChannel::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::TokenizationListParams::TokenizationChannel::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::TokenizationListParams::TokenizationChannel::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
     end
   end

data/rbi/lithic/models/tokenization_pause_params.rbi

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

data/rbi/lithic/models/tokenization_resend_activation_code_params.rbi

@@ -6,26 +6,40 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::TokenizationResendActivationCodeParams,
+            Lithic::Internal::AnyHash
+          )
+        end
+
       # The communication method that the user has selected to use to receive the
       # authentication code. Supported Values: Sms = "TEXT_TO_CARDHOLDER_NUMBER". Email
       # = "EMAIL_TO_CARDHOLDER_ADDRESS"
-      sig { returns(T.nilable(Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol)) }
+      sig do
+        returns(
+          T.nilable(
+            Lithic::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol
+          )
+        )
+      end
       attr_reader :activation_method_type
 
       sig do
         params(
-          activation_method_type: Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol
-        )
-          .void
+          activation_method_type:
+            Lithic::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol
+        ).void
       end
       attr_writer :activation_method_type
 
       sig do
         params(
-          activation_method_type: Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol,
-          request_options: T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          activation_method_type:
+            Lithic::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # The communication method that the user has selected to use to receive the
@@ -33,17 +47,20 @@ module Lithic
         # = "EMAIL_TO_CARDHOLDER_ADDRESS"
         activation_method_type: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              activation_method_type: Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol,
-              request_options: Lithic::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            activation_method_type:
+              Lithic::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       # The communication method that the user has selected to use to receive the
       # authentication code. Supported Values: Sms = "TEXT_TO_CARDHOLDER_NUMBER". Email
@@ -52,27 +69,34 @@ module Lithic
         extend Lithic::Internal::Type::Enum
 
         TaggedSymbol =
-          T.type_alias { T.all(Symbol, Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType) }
+          T.type_alias do
+            T.all(
+              Symbol,
+              Lithic::TokenizationResendActivationCodeParams::ActivationMethodType
+            )
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         EMAIL_TO_CARDHOLDER_ADDRESS =
           T.let(
             :EMAIL_TO_CARDHOLDER_ADDRESS,
-            Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::TaggedSymbol
+            Lithic::TokenizationResendActivationCodeParams::ActivationMethodType::TaggedSymbol
           )
         TEXT_TO_CARDHOLDER_NUMBER =
           T.let(
             :TEXT_TO_CARDHOLDER_NUMBER,
-            Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::TaggedSymbol
+            Lithic::TokenizationResendActivationCodeParams::ActivationMethodType::TaggedSymbol
           )
 
         sig do
-          override
-            .returns(
-              T::Array[Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::TaggedSymbol]
-            )
+          override.returns(
+            T::Array[
+              Lithic::TokenizationResendActivationCodeParams::ActivationMethodType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
         end
-        def self.values; end
       end
     end
   end

data/rbi/lithic/models/tokenization_retrieve_params.rbi

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

data/rbi/lithic/models/tokenization_retrieve_response.rbi

@@ -3,17 +3,29 @@
 module Lithic
   module Models
     class TokenizationRetrieveResponse < Lithic::Internal::Type::BaseModel
-      sig { returns(T.nilable(Lithic::Models::Tokenization)) }
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::Models::TokenizationRetrieveResponse,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(Lithic::Tokenization)) }
       attr_reader :data
 
-      sig { params(data: T.any(Lithic::Models::Tokenization, Lithic::Internal::AnyHash)).void }
+      sig { params(data: Lithic::Tokenization::OrHash).void }
       attr_writer :data
 
-      sig { params(data: T.any(Lithic::Models::Tokenization, Lithic::Internal::AnyHash)).returns(T.attached_class) }
-      def self.new(data: nil); end
+      sig do
+        params(data: Lithic::Tokenization::OrHash).returns(T.attached_class)
+      end
+      def self.new(data: nil)
+      end
 
-      sig { override.returns({data: Lithic::Models::Tokenization}) }
-      def to_hash; end
+      sig { override.returns({ data: Lithic::Tokenization }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/lithic/models/tokenization_secret.rbi

@@ -3,6 +3,11 @@
 module Lithic
   module Models
     class TokenizationSecret < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::TokenizationSecret, Lithic::Internal::AnyHash)
+        end
+
       # The Tokenization Decisioning HMAC secret
       sig { returns(T.nilable(String)) }
       attr_reader :secret
@@ -14,9 +19,12 @@ module Lithic
       def self.new(
         # The Tokenization Decisioning HMAC secret
         secret: nil
-      ); end
-      sig { override.returns({secret: String}) }
-      def to_hash; end
+      )
+      end
+
+      sig { override.returns({ secret: String }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/lithic/models/tokenization_simulate_params.rbi

@@ -6,6 +6,11 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::TokenizationSimulateParams, Lithic::Internal::AnyHash)
+        end
+
       # The three digit cvv for the card.
       sig { returns(String) }
       attr_accessor :cvv
@@ -19,7 +24,11 @@ module Lithic
       attr_accessor :pan
 
       # The source of the tokenization request.
-      sig { returns(Lithic::Models::TokenizationSimulateParams::TokenizationSource::OrSymbol) }
+      sig do
+        returns(
+          Lithic::TokenizationSimulateParams::TokenizationSource::OrSymbol
+        )
+      end
       attr_accessor :tokenization_source
 
       # The account score (1-5) that represents how the Digital Wallet's view on how
@@ -47,14 +56,20 @@ module Lithic
       attr_writer :entity
 
       # The decision that the Digital Wallet's recommend
-      sig { returns(T.nilable(Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol)) }
+      sig do
+        returns(
+          T.nilable(
+            Lithic::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol
+          )
+        )
+      end
       attr_reader :wallet_recommended_decision
 
       sig do
         params(
-          wallet_recommended_decision: Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol
-        )
-          .void
+          wallet_recommended_decision:
+            Lithic::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol
+        ).void
       end
       attr_writer :wallet_recommended_decision
 
@@ -63,14 +78,15 @@ module Lithic
           cvv: String,
           expiration_date: String,
           pan: String,
-          tokenization_source: Lithic::Models::TokenizationSimulateParams::TokenizationSource::OrSymbol,
+          tokenization_source:
+            Lithic::TokenizationSimulateParams::TokenizationSource::OrSymbol,
           account_score: Integer,
           device_score: Integer,
           entity: String,
-          wallet_recommended_decision: Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol,
-          request_options: T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          wallet_recommended_decision:
+            Lithic::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # The three digit cvv for the card.
@@ -93,42 +109,72 @@ module Lithic
         # The decision that the Digital Wallet's recommend
         wallet_recommended_decision: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              cvv: String,
-              expiration_date: String,
-              pan: String,
-              tokenization_source: Lithic::Models::TokenizationSimulateParams::TokenizationSource::OrSymbol,
-              account_score: Integer,
-              device_score: Integer,
-              entity: String,
-              wallet_recommended_decision: Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol,
-              request_options: Lithic::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            cvv: String,
+            expiration_date: String,
+            pan: String,
+            tokenization_source:
+              Lithic::TokenizationSimulateParams::TokenizationSource::OrSymbol,
+            account_score: Integer,
+            device_score: Integer,
+            entity: String,
+            wallet_recommended_decision:
+              Lithic::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       # The source of the tokenization request.
       module TokenizationSource
         extend Lithic::Internal::Type::Enum
 
         TaggedSymbol =
-          T.type_alias { T.all(Symbol, Lithic::Models::TokenizationSimulateParams::TokenizationSource) }
+          T.type_alias do
+            T.all(
+              Symbol,
+              Lithic::TokenizationSimulateParams::TokenizationSource
+            )
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         APPLE_PAY =
-          T.let(:APPLE_PAY, Lithic::Models::TokenizationSimulateParams::TokenizationSource::TaggedSymbol)
-        GOOGLE = T.let(:GOOGLE, Lithic::Models::TokenizationSimulateParams::TokenizationSource::TaggedSymbol)
+          T.let(
+            :APPLE_PAY,
+            Lithic::TokenizationSimulateParams::TokenizationSource::TaggedSymbol
+          )
+        GOOGLE =
+          T.let(
+            :GOOGLE,
+            Lithic::TokenizationSimulateParams::TokenizationSource::TaggedSymbol
+          )
         SAMSUNG_PAY =
-          T.let(:SAMSUNG_PAY, Lithic::Models::TokenizationSimulateParams::TokenizationSource::TaggedSymbol)
-        MERCHANT = T.let(:MERCHANT, Lithic::Models::TokenizationSimulateParams::TokenizationSource::TaggedSymbol)
+          T.let(
+            :SAMSUNG_PAY,
+            Lithic::TokenizationSimulateParams::TokenizationSource::TaggedSymbol
+          )
+        MERCHANT =
+          T.let(
+            :MERCHANT,
+            Lithic::TokenizationSimulateParams::TokenizationSource::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::TokenizationSimulateParams::TokenizationSource::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::TokenizationSimulateParams::TokenizationSource::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
 
       # The decision that the Digital Wallet's recommend
@@ -136,24 +182,39 @@ module Lithic
         extend Lithic::Internal::Type::Enum
 
         TaggedSymbol =
-          T.type_alias { T.all(Symbol, Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision) }
+          T.type_alias do
+            T.all(
+              Symbol,
+              Lithic::TokenizationSimulateParams::WalletRecommendedDecision
+            )
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         APPROVED =
-          T.let(:APPROVED, Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol)
+          T.let(
+            :APPROVED,
+            Lithic::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol
+          )
         DECLINED =
-          T.let(:DECLINED, Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol)
+          T.let(
+            :DECLINED,
+            Lithic::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol
+          )
         REQUIRE_ADDITIONAL_AUTHENTICATION =
           T.let(
             :REQUIRE_ADDITIONAL_AUTHENTICATION,
-            Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol
+            Lithic::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol
           )
 
         sig do
-          override
-            .returns(T::Array[Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol])
+          override.returns(
+            T::Array[
+              Lithic::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
         end
-        def self.values; end
       end
     end
   end

data/rbi/lithic/models/tokenization_simulate_response.rbi

@@ -3,20 +3,31 @@
 module Lithic
   module Models
     class TokenizationSimulateResponse < Lithic::Internal::Type::BaseModel
-      sig { returns(T.nilable(T::Array[Lithic::Models::Tokenization])) }
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::Models::TokenizationSimulateResponse,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T.nilable(T::Array[Lithic::Tokenization])) }
       attr_reader :data
 
-      sig { params(data: T::Array[T.any(Lithic::Models::Tokenization, Lithic::Internal::AnyHash)]).void }
+      sig { params(data: T::Array[Lithic::Tokenization::OrHash]).void }
       attr_writer :data
 
       sig do
-        params(data: T::Array[T.any(Lithic::Models::Tokenization, Lithic::Internal::AnyHash)])
-          .returns(T.attached_class)
+        params(data: T::Array[Lithic::Tokenization::OrHash]).returns(
+          T.attached_class
+        )
+      end
+      def self.new(data: nil)
       end
-      def self.new(data: nil); end
 
-      sig { override.returns({data: T::Array[Lithic::Models::Tokenization]}) }
-      def to_hash; end
+      sig { override.returns({ data: T::Array[Lithic::Tokenization] }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/lithic/models/tokenization_unpause_params.rbi

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