lithic 0.1.0.pre.alpha.22 → 0.1.0.pre.alpha.23

data/rbi/lithic/models/tokenization.rbi

@@ -3,6 +3,8 @@
 module Lithic
   module Models
     class Tokenization < Lithic::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
       # Globally unique identifier for a Tokenization
       sig { returns(String) }
       attr_accessor :token
@@ -24,12 +26,12 @@ module Lithic
       attr_accessor :dpan
 
       # The status of the tokenization request
-      sig { returns(Lithic::Models::Tokenization::Status::TaggedSymbol) }
+      sig { returns(Lithic::Tokenization::Status::TaggedSymbol) }
       attr_accessor :status
 
       # The entity that requested the tokenization. Represents a Digital Wallet or
       # merchant.
-      sig { returns(Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol) }
+      sig { returns(Lithic::Tokenization::TokenRequestorName::TaggedSymbol) }
       attr_accessor :token_requestor_name
 
       # The network's unique reference for the tokenization.
@@ -37,7 +39,7 @@ module Lithic
       attr_accessor :token_unique_reference
 
       # The channel through which the tokenization was made.
-      sig { returns(Lithic::Models::Tokenization::TokenizationChannel::TaggedSymbol) }
+      sig { returns(Lithic::Tokenization::TokenizationChannel::TaggedSymbol) }
       attr_accessor :tokenization_channel
 
       # Latest date and time when the tokenization was updated. UTC time zone.
@@ -55,10 +57,10 @@ module Lithic
       attr_writer :digital_card_art_token
 
       # A list of events related to the tokenization.
-      sig { returns(T.nilable(T::Array[Lithic::Models::Tokenization::Event])) }
+      sig { returns(T.nilable(T::Array[Lithic::Tokenization::Event])) }
       attr_reader :events
 
-      sig { params(events: T::Array[T.any(Lithic::Models::Tokenization::Event, Lithic::Internal::AnyHash)]).void }
+      sig { params(events: T::Array[Lithic::Tokenization::Event::OrHash]).void }
       attr_writer :events
 
       # The network's unique reference for the card that is tokenized.
@@ -72,16 +74,17 @@ module Lithic
           card_token: String,
           created_at: Time,
           dpan: T.nilable(String),
-          status: Lithic::Models::Tokenization::Status::OrSymbol,
-          token_requestor_name: Lithic::Models::Tokenization::TokenRequestorName::OrSymbol,
+          status: Lithic::Tokenization::Status::OrSymbol,
+          token_requestor_name:
+            Lithic::Tokenization::TokenRequestorName::OrSymbol,
           token_unique_reference: String,
-          tokenization_channel: Lithic::Models::Tokenization::TokenizationChannel::OrSymbol,
+          tokenization_channel:
+            Lithic::Tokenization::TokenizationChannel::OrSymbol,
           updated_at: Time,
           digital_card_art_token: String,
-          events: T::Array[T.any(Lithic::Models::Tokenization::Event, Lithic::Internal::AnyHash)],
+          events: T::Array[Lithic::Tokenization::Event::OrHash],
           payment_account_reference_id: T.nilable(String)
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # Globally unique identifier for a Tokenization
@@ -114,46 +117,57 @@ module Lithic
         events: nil,
         # The network's unique reference for the card that is tokenized.
         payment_account_reference_id: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              token: String,
-              account_token: String,
-              card_token: String,
-              created_at: Time,
-              dpan: T.nilable(String),
-              status: Lithic::Models::Tokenization::Status::TaggedSymbol,
-              token_requestor_name: Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol,
-              token_unique_reference: String,
-              tokenization_channel: Lithic::Models::Tokenization::TokenizationChannel::TaggedSymbol,
-              updated_at: Time,
-              digital_card_art_token: String,
-              events: T::Array[Lithic::Models::Tokenization::Event],
-              payment_account_reference_id: T.nilable(String)
-            }
-          )
+        override.returns(
+          {
+            token: String,
+            account_token: String,
+            card_token: String,
+            created_at: Time,
+            dpan: T.nilable(String),
+            status: Lithic::Tokenization::Status::TaggedSymbol,
+            token_requestor_name:
+              Lithic::Tokenization::TokenRequestorName::TaggedSymbol,
+            token_unique_reference: String,
+            tokenization_channel:
+              Lithic::Tokenization::TokenizationChannel::TaggedSymbol,
+            updated_at: Time,
+            digital_card_art_token: String,
+            events: T::Array[Lithic::Tokenization::Event],
+            payment_account_reference_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       # The status of the tokenization request
       module Status
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::Tokenization::Status) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::Tokenization::Status) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        ACTIVE = T.let(:ACTIVE, Lithic::Models::Tokenization::Status::TaggedSymbol)
-        DEACTIVATED = T.let(:DEACTIVATED, Lithic::Models::Tokenization::Status::TaggedSymbol)
-        INACTIVE = T.let(:INACTIVE, Lithic::Models::Tokenization::Status::TaggedSymbol)
-        PAUSED = T.let(:PAUSED, Lithic::Models::Tokenization::Status::TaggedSymbol)
-        PENDING_2_FA = T.let(:PENDING_2FA, Lithic::Models::Tokenization::Status::TaggedSymbol)
-        PENDING_ACTIVATION = T.let(:PENDING_ACTIVATION, Lithic::Models::Tokenization::Status::TaggedSymbol)
-        UNKNOWN = T.let(:UNKNOWN, Lithic::Models::Tokenization::Status::TaggedSymbol)
+        ACTIVE = T.let(:ACTIVE, Lithic::Tokenization::Status::TaggedSymbol)
+        DEACTIVATED =
+          T.let(:DEACTIVATED, Lithic::Tokenization::Status::TaggedSymbol)
+        INACTIVE = T.let(:INACTIVE, Lithic::Tokenization::Status::TaggedSymbol)
+        PAUSED = T.let(:PAUSED, Lithic::Tokenization::Status::TaggedSymbol)
+        PENDING_2_FA =
+          T.let(:PENDING_2FA, Lithic::Tokenization::Status::TaggedSymbol)
+        PENDING_ACTIVATION =
+          T.let(:PENDING_ACTIVATION, Lithic::Tokenization::Status::TaggedSymbol)
+        UNKNOWN = T.let(:UNKNOWN, Lithic::Tokenization::Status::TaggedSymbol)
 
-        sig { override.returns(T::Array[Lithic::Models::Tokenization::Status::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(T::Array[Lithic::Tokenization::Status::TaggedSymbol])
+        end
+        def self.values
+        end
       end
 
       # The entity that requested the tokenization. Represents a Digital Wallet or
@@ -161,40 +175,110 @@ module Lithic
       module TokenRequestorName
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::Tokenization::TokenRequestorName) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::Tokenization::TokenRequestorName)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        AMAZON_ONE = T.let(:AMAZON_ONE, Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol)
-        ANDROID_PAY = T.let(:ANDROID_PAY, Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol)
-        APPLE_PAY = T.let(:APPLE_PAY, Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol)
-        FACEBOOK = T.let(:FACEBOOK, Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol)
-        FITBIT_PAY = T.let(:FITBIT_PAY, Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol)
-        GARMIN_PAY = T.let(:GARMIN_PAY, Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol)
-        MICROSOFT_PAY = T.let(:MICROSOFT_PAY, Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol)
-        NETFLIX = T.let(:NETFLIX, Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol)
-        SAMSUNG_PAY = T.let(:SAMSUNG_PAY, Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol)
-        UNKNOWN = T.let(:UNKNOWN, Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol)
-        VISA_CHECKOUT = T.let(:VISA_CHECKOUT, Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol)
-
-        sig { override.returns(T::Array[Lithic::Models::Tokenization::TokenRequestorName::TaggedSymbol]) }
-        def self.values; end
+        AMAZON_ONE =
+          T.let(
+            :AMAZON_ONE,
+            Lithic::Tokenization::TokenRequestorName::TaggedSymbol
+          )
+        ANDROID_PAY =
+          T.let(
+            :ANDROID_PAY,
+            Lithic::Tokenization::TokenRequestorName::TaggedSymbol
+          )
+        APPLE_PAY =
+          T.let(
+            :APPLE_PAY,
+            Lithic::Tokenization::TokenRequestorName::TaggedSymbol
+          )
+        FACEBOOK =
+          T.let(
+            :FACEBOOK,
+            Lithic::Tokenization::TokenRequestorName::TaggedSymbol
+          )
+        FITBIT_PAY =
+          T.let(
+            :FITBIT_PAY,
+            Lithic::Tokenization::TokenRequestorName::TaggedSymbol
+          )
+        GARMIN_PAY =
+          T.let(
+            :GARMIN_PAY,
+            Lithic::Tokenization::TokenRequestorName::TaggedSymbol
+          )
+        MICROSOFT_PAY =
+          T.let(
+            :MICROSOFT_PAY,
+            Lithic::Tokenization::TokenRequestorName::TaggedSymbol
+          )
+        NETFLIX =
+          T.let(
+            :NETFLIX,
+            Lithic::Tokenization::TokenRequestorName::TaggedSymbol
+          )
+        SAMSUNG_PAY =
+          T.let(
+            :SAMSUNG_PAY,
+            Lithic::Tokenization::TokenRequestorName::TaggedSymbol
+          )
+        UNKNOWN =
+          T.let(
+            :UNKNOWN,
+            Lithic::Tokenization::TokenRequestorName::TaggedSymbol
+          )
+        VISA_CHECKOUT =
+          T.let(
+            :VISA_CHECKOUT,
+            Lithic::Tokenization::TokenRequestorName::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Lithic::Tokenization::TokenRequestorName::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
 
       # The channel through which the tokenization was made.
       module TokenizationChannel
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::Tokenization::TokenizationChannel) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::Tokenization::TokenizationChannel)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        DIGITAL_WALLET = T.let(:DIGITAL_WALLET, Lithic::Models::Tokenization::TokenizationChannel::TaggedSymbol)
-        MERCHANT = T.let(:MERCHANT, Lithic::Models::Tokenization::TokenizationChannel::TaggedSymbol)
+        DIGITAL_WALLET =
+          T.let(
+            :DIGITAL_WALLET,
+            Lithic::Tokenization::TokenizationChannel::TaggedSymbol
+          )
+        MERCHANT =
+          T.let(
+            :MERCHANT,
+            Lithic::Tokenization::TokenizationChannel::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::Tokenization::TokenizationChannel::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Lithic::Tokenization::TokenizationChannel::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
 
       class Event < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # Globally unique identifier for a Tokenization Event
         sig { returns(T.nilable(String)) }
         attr_reader :token
@@ -210,27 +294,32 @@ module Lithic
         attr_writer :created_at
 
         # Enum representing the result of the tokenization event
-        sig { returns(T.nilable(Lithic::Models::Tokenization::Event::Result::TaggedSymbol)) }
+        sig do
+          returns(T.nilable(Lithic::Tokenization::Event::Result::TaggedSymbol))
+        end
         attr_reader :result
 
-        sig { params(result: Lithic::Models::Tokenization::Event::Result::OrSymbol).void }
+        sig do
+          params(result: Lithic::Tokenization::Event::Result::OrSymbol).void
+        end
         attr_writer :result
 
         # Enum representing the type of tokenization event that occurred
-        sig { returns(T.nilable(Lithic::Models::Tokenization::Event::Type::TaggedSymbol)) }
+        sig do
+          returns(T.nilable(Lithic::Tokenization::Event::Type::TaggedSymbol))
+        end
         attr_reader :type
 
-        sig { params(type: Lithic::Models::Tokenization::Event::Type::OrSymbol).void }
+        sig { params(type: Lithic::Tokenization::Event::Type::OrSymbol).void }
         attr_writer :type
 
         sig do
           params(
             token: String,
             created_at: Time,
-            result: Lithic::Models::Tokenization::Event::Result::OrSymbol,
-            type: Lithic::Models::Tokenization::Event::Type::OrSymbol
-          )
-            .returns(T.attached_class)
+            result: Lithic::Tokenization::Event::Result::OrSymbol,
+            type: Lithic::Tokenization::Event::Type::OrSymbol
+          ).returns(T.attached_class)
         end
         def self.new(
           # Globally unique identifier for a Tokenization Event
@@ -241,65 +330,130 @@ module Lithic
           result: nil,
           # Enum representing the type of tokenization event that occurred
           type: nil
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                token: String,
-                created_at: Time,
-                result: Lithic::Models::Tokenization::Event::Result::TaggedSymbol,
-                type: Lithic::Models::Tokenization::Event::Type::TaggedSymbol
-              }
-            )
+          override.returns(
+            {
+              token: String,
+              created_at: Time,
+              result: Lithic::Tokenization::Event::Result::TaggedSymbol,
+              type: Lithic::Tokenization::Event::Type::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         # Enum representing the result of the tokenization event
         module Result
           extend Lithic::Internal::Type::Enum
 
-          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::Tokenization::Event::Result) }
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Lithic::Tokenization::Event::Result) }
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          APPROVED = T.let(:APPROVED, Lithic::Models::Tokenization::Event::Result::TaggedSymbol)
-          DECLINED = T.let(:DECLINED, Lithic::Models::Tokenization::Event::Result::TaggedSymbol)
+          APPROVED =
+            T.let(:APPROVED, Lithic::Tokenization::Event::Result::TaggedSymbol)
+          DECLINED =
+            T.let(:DECLINED, Lithic::Tokenization::Event::Result::TaggedSymbol)
           NOTIFICATION_DELIVERED =
-            T.let(:NOTIFICATION_DELIVERED, Lithic::Models::Tokenization::Event::Result::TaggedSymbol)
+            T.let(
+              :NOTIFICATION_DELIVERED,
+              Lithic::Tokenization::Event::Result::TaggedSymbol
+            )
           REQUIRE_ADDITIONAL_AUTHENTICATION =
-            T.let(:REQUIRE_ADDITIONAL_AUTHENTICATION, Lithic::Models::Tokenization::Event::Result::TaggedSymbol)
-          TOKEN_ACTIVATED = T.let(:TOKEN_ACTIVATED, Lithic::Models::Tokenization::Event::Result::TaggedSymbol)
-          TOKEN_CREATED = T.let(:TOKEN_CREATED, Lithic::Models::Tokenization::Event::Result::TaggedSymbol)
-          TOKEN_DEACTIVATED = T.let(:TOKEN_DEACTIVATED, Lithic::Models::Tokenization::Event::Result::TaggedSymbol)
-          TOKEN_INACTIVE = T.let(:TOKEN_INACTIVE, Lithic::Models::Tokenization::Event::Result::TaggedSymbol)
+            T.let(
+              :REQUIRE_ADDITIONAL_AUTHENTICATION,
+              Lithic::Tokenization::Event::Result::TaggedSymbol
+            )
+          TOKEN_ACTIVATED =
+            T.let(
+              :TOKEN_ACTIVATED,
+              Lithic::Tokenization::Event::Result::TaggedSymbol
+            )
+          TOKEN_CREATED =
+            T.let(
+              :TOKEN_CREATED,
+              Lithic::Tokenization::Event::Result::TaggedSymbol
+            )
+          TOKEN_DEACTIVATED =
+            T.let(
+              :TOKEN_DEACTIVATED,
+              Lithic::Tokenization::Event::Result::TaggedSymbol
+            )
+          TOKEN_INACTIVE =
+            T.let(
+              :TOKEN_INACTIVE,
+              Lithic::Tokenization::Event::Result::TaggedSymbol
+            )
           TOKEN_STATE_UNKNOWN =
-            T.let(:TOKEN_STATE_UNKNOWN, Lithic::Models::Tokenization::Event::Result::TaggedSymbol)
-          TOKEN_SUSPENDED = T.let(:TOKEN_SUSPENDED, Lithic::Models::Tokenization::Event::Result::TaggedSymbol)
-          TOKEN_UPDATED = T.let(:TOKEN_UPDATED, Lithic::Models::Tokenization::Event::Result::TaggedSymbol)
+            T.let(
+              :TOKEN_STATE_UNKNOWN,
+              Lithic::Tokenization::Event::Result::TaggedSymbol
+            )
+          TOKEN_SUSPENDED =
+            T.let(
+              :TOKEN_SUSPENDED,
+              Lithic::Tokenization::Event::Result::TaggedSymbol
+            )
+          TOKEN_UPDATED =
+            T.let(
+              :TOKEN_UPDATED,
+              Lithic::Tokenization::Event::Result::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Lithic::Models::Tokenization::Event::Result::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[Lithic::Tokenization::Event::Result::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
         end
 
         # Enum representing the type of tokenization event that occurred
         module Type
           extend Lithic::Internal::Type::Enum
 
-          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::Tokenization::Event::Type) }
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Lithic::Tokenization::Event::Type) }
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          TOKENIZATION_2_FA = T.let(:TOKENIZATION_2FA, Lithic::Models::Tokenization::Event::Type::TaggedSymbol)
+          TOKENIZATION_2_FA =
+            T.let(
+              :TOKENIZATION_2FA,
+              Lithic::Tokenization::Event::Type::TaggedSymbol
+            )
           TOKENIZATION_AUTHORIZATION =
-            T.let(:TOKENIZATION_AUTHORIZATION, Lithic::Models::Tokenization::Event::Type::TaggedSymbol)
+            T.let(
+              :TOKENIZATION_AUTHORIZATION,
+              Lithic::Tokenization::Event::Type::TaggedSymbol
+            )
           TOKENIZATION_DECISIONING =
-            T.let(:TOKENIZATION_DECISIONING, Lithic::Models::Tokenization::Event::Type::TaggedSymbol)
+            T.let(
+              :TOKENIZATION_DECISIONING,
+              Lithic::Tokenization::Event::Type::TaggedSymbol
+            )
           TOKENIZATION_ELIGIBILITY_CHECK =
-            T.let(:TOKENIZATION_ELIGIBILITY_CHECK, Lithic::Models::Tokenization::Event::Type::TaggedSymbol)
+            T.let(
+              :TOKENIZATION_ELIGIBILITY_CHECK,
+              Lithic::Tokenization::Event::Type::TaggedSymbol
+            )
           TOKENIZATION_UPDATED =
-            T.let(:TOKENIZATION_UPDATED, Lithic::Models::Tokenization::Event::Type::TaggedSymbol)
+            T.let(
+              :TOKENIZATION_UPDATED,
+              Lithic::Tokenization::Event::Type::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Lithic::Models::Tokenization::Event::Type::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[Lithic::Tokenization::Event::Type::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
         end
       end
     end

data/rbi/lithic/models/tokenization_activate_params.rbi

@@ -6,18 +6,19 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
       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_deactivate_params.rbi

@@ -6,18 +6,19 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
       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_decisioning_retrieve_secret_params.rbi

@@ -6,18 +6,19 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
       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_decisioning_rotate_secret_params.rbi

@@ -6,18 +6,19 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
       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_decisioning_rotate_secret_response.rbi

@@ -3,6 +3,8 @@
 module Lithic
   module Models
     class TokenizationDecisioningRotateSecretResponse < Lithic::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
       # The new Tokenization Decisioning HMAC secret
       sig { returns(T.nilable(String)) }
       attr_reader :secret
@@ -14,9 +16,12 @@ module Lithic
       def self.new(
         # The new 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