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

data/rbi/lithic/models/book_transfer_response.rbi

@@ -3,13 +3,18 @@
 module Lithic
   module Models
     class BookTransferResponse < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::BookTransferResponse, Lithic::Internal::AnyHash)
+        end
+
       # Customer-provided token that will serve as an idempotency token. This token will
       # become the transaction token.
       sig { returns(String) }
       attr_accessor :token
 
       # Category of the book transfer
-      sig { returns(Lithic::Models::BookTransferResponse::Category::TaggedSymbol) }
+      sig { returns(Lithic::BookTransferResponse::Category::TaggedSymbol) }
       attr_accessor :category
 
       # Date and time when the transfer occurred. UTC time zone.
@@ -22,7 +27,7 @@ module Lithic
       attr_accessor :currency
 
       # A list of all financial events that have modified this transfer.
-      sig { returns(T::Array[Lithic::Models::BookTransferResponse::Event]) }
+      sig { returns(T::Array[Lithic::BookTransferResponse::Event]) }
       attr_accessor :events
 
       # Globally unique identifier for the financial account or card that will send the
@@ -38,7 +43,7 @@ module Lithic
 
       # APPROVED transactions were successful while DECLINED transactions were declined
       # by user, Lithic, or the network.
-      sig { returns(Lithic::Models::BookTransferResponse::Result::TaggedSymbol) }
+      sig { returns(Lithic::BookTransferResponse::Result::TaggedSymbol) }
       attr_accessor :result
 
       # Amount of the transaction that has been settled in the currency's smallest unit
@@ -48,7 +53,7 @@ module Lithic
 
       # Status types: _ `DECLINED` - The transfer was declined. _ `REVERSED` - The
       # transfer was reversed \* `SETTLED` - The transfer is completed.
-      sig { returns(Lithic::Models::BookTransferResponse::Status::TaggedSymbol) }
+      sig { returns(Lithic::BookTransferResponse::Status::TaggedSymbol) }
       attr_accessor :status
 
       # Globally unique identifier for the financial account or card that will receive
@@ -63,19 +68,18 @@ module Lithic
       sig do
         params(
           token: String,
-          category: Lithic::Models::BookTransferResponse::Category::OrSymbol,
+          category: Lithic::BookTransferResponse::Category::OrSymbol,
           created: Time,
           currency: String,
-          events: T::Array[T.any(Lithic::Models::BookTransferResponse::Event, Lithic::Internal::AnyHash)],
+          events: T::Array[Lithic::BookTransferResponse::Event::OrHash],
           from_financial_account_token: String,
           pending_amount: Integer,
-          result: Lithic::Models::BookTransferResponse::Result::OrSymbol,
+          result: Lithic::BookTransferResponse::Result::OrSymbol,
           settled_amount: Integer,
-          status: Lithic::Models::BookTransferResponse::Status::OrSymbol,
+          status: Lithic::BookTransferResponse::Status::OrSymbol,
           to_financial_account_token: T.anything,
           updated: Time
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # Customer-provided token that will serve as an idempotency token. This token will
@@ -111,49 +115,79 @@ module Lithic
         to_financial_account_token:,
         # Date and time when the financial transaction was last updated. UTC time zone.
         updated:
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              token: String,
-              category: Lithic::Models::BookTransferResponse::Category::TaggedSymbol,
-              created: Time,
-              currency: String,
-              events: T::Array[Lithic::Models::BookTransferResponse::Event],
-              from_financial_account_token: String,
-              pending_amount: Integer,
-              result: Lithic::Models::BookTransferResponse::Result::TaggedSymbol,
-              settled_amount: Integer,
-              status: Lithic::Models::BookTransferResponse::Status::TaggedSymbol,
-              to_financial_account_token: T.anything,
-              updated: Time
-            }
-          )
+        override.returns(
+          {
+            token: String,
+            category: Lithic::BookTransferResponse::Category::TaggedSymbol,
+            created: Time,
+            currency: String,
+            events: T::Array[Lithic::BookTransferResponse::Event],
+            from_financial_account_token: String,
+            pending_amount: Integer,
+            result: Lithic::BookTransferResponse::Result::TaggedSymbol,
+            settled_amount: Integer,
+            status: Lithic::BookTransferResponse::Status::TaggedSymbol,
+            to_financial_account_token: T.anything,
+            updated: Time
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       # Category of the book transfer
       module Category
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::BookTransferResponse::Category) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::BookTransferResponse::Category) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        ADJUSTMENT = T.let(:ADJUSTMENT, Lithic::Models::BookTransferResponse::Category::TaggedSymbol)
+        ADJUSTMENT =
+          T.let(
+            :ADJUSTMENT,
+            Lithic::BookTransferResponse::Category::TaggedSymbol
+          )
         BALANCE_OR_FUNDING =
-          T.let(:BALANCE_OR_FUNDING, Lithic::Models::BookTransferResponse::Category::TaggedSymbol)
-        DERECOGNITION = T.let(:DERECOGNITION, Lithic::Models::BookTransferResponse::Category::TaggedSymbol)
-        DISPUTE = T.let(:DISPUTE, Lithic::Models::BookTransferResponse::Category::TaggedSymbol)
-        FEE = T.let(:FEE, Lithic::Models::BookTransferResponse::Category::TaggedSymbol)
-        REWARD = T.let(:REWARD, Lithic::Models::BookTransferResponse::Category::TaggedSymbol)
-        TRANSFER = T.let(:TRANSFER, Lithic::Models::BookTransferResponse::Category::TaggedSymbol)
-
-        sig { override.returns(T::Array[Lithic::Models::BookTransferResponse::Category::TaggedSymbol]) }
-        def self.values; end
+          T.let(
+            :BALANCE_OR_FUNDING,
+            Lithic::BookTransferResponse::Category::TaggedSymbol
+          )
+        DERECOGNITION =
+          T.let(
+            :DERECOGNITION,
+            Lithic::BookTransferResponse::Category::TaggedSymbol
+          )
+        DISPUTE =
+          T.let(:DISPUTE, Lithic::BookTransferResponse::Category::TaggedSymbol)
+        FEE = T.let(:FEE, Lithic::BookTransferResponse::Category::TaggedSymbol)
+        REWARD =
+          T.let(:REWARD, Lithic::BookTransferResponse::Category::TaggedSymbol)
+        TRANSFER =
+          T.let(:TRANSFER, Lithic::BookTransferResponse::Category::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Lithic::BookTransferResponse::Category::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
 
       class Event < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::BookTransferResponse::Event,
+              Lithic::Internal::AnyHash
+            )
+          end
+
         # Globally unique identifier.
         sig { returns(String) }
         attr_accessor :token
@@ -168,7 +202,13 @@ module Lithic
         attr_accessor :created
 
         # Detailed Results
-        sig { returns(T::Array[Lithic::Models::BookTransferResponse::Event::DetailedResult::TaggedSymbol]) }
+        sig do
+          returns(
+            T::Array[
+              Lithic::BookTransferResponse::Event::DetailedResult::TaggedSymbol
+            ]
+          )
+        end
         attr_accessor :detailed_results
 
         # Memo for the transfer.
@@ -177,7 +217,9 @@ module Lithic
 
         # APPROVED financial events were successful while DECLINED financial events were
         # declined by user, Lithic, or the network.
-        sig { returns(Lithic::Models::BookTransferResponse::Event::Result::TaggedSymbol) }
+        sig do
+          returns(Lithic::BookTransferResponse::Event::Result::TaggedSymbol)
+        end
         attr_accessor :result
 
         # The program specific subtype code for the specified category/type.
@@ -193,13 +235,15 @@ module Lithic
             token: String,
             amount: Integer,
             created: Time,
-            detailed_results: T::Array[Lithic::Models::BookTransferResponse::Event::DetailedResult::OrSymbol],
+            detailed_results:
+              T::Array[
+                Lithic::BookTransferResponse::Event::DetailedResult::OrSymbol
+              ],
             memo: String,
-            result: Lithic::Models::BookTransferResponse::Event::Result::OrSymbol,
+            result: Lithic::BookTransferResponse::Event::Result::OrSymbol,
             subtype: String,
             type: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # Globally unique identifier.
@@ -220,37 +264,58 @@ module Lithic
           subtype:,
           # Type of the book transfer
           type:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                token: String,
-                amount: Integer,
-                created: Time,
-                detailed_results: T::Array[Lithic::Models::BookTransferResponse::Event::DetailedResult::TaggedSymbol],
-                memo: String,
-                result: Lithic::Models::BookTransferResponse::Event::Result::TaggedSymbol,
-                subtype: String,
-                type: String
-              }
-            )
+          override.returns(
+            {
+              token: String,
+              amount: Integer,
+              created: Time,
+              detailed_results:
+                T::Array[
+                  Lithic::BookTransferResponse::Event::DetailedResult::TaggedSymbol
+                ],
+              memo: String,
+              result: Lithic::BookTransferResponse::Event::Result::TaggedSymbol,
+              subtype: String,
+              type: String
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         module DetailedResult
           extend Lithic::Internal::Type::Enum
 
           TaggedSymbol =
-            T.type_alias { T.all(Symbol, Lithic::Models::BookTransferResponse::Event::DetailedResult) }
+            T.type_alias do
+              T.all(Symbol, Lithic::BookTransferResponse::Event::DetailedResult)
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          APPROVED = T.let(:APPROVED, Lithic::Models::BookTransferResponse::Event::DetailedResult::TaggedSymbol)
+          APPROVED =
+            T.let(
+              :APPROVED,
+              Lithic::BookTransferResponse::Event::DetailedResult::TaggedSymbol
+            )
           FUNDS_INSUFFICIENT =
-            T.let(:FUNDS_INSUFFICIENT, Lithic::Models::BookTransferResponse::Event::DetailedResult::TaggedSymbol)
+            T.let(
+              :FUNDS_INSUFFICIENT,
+              Lithic::BookTransferResponse::Event::DetailedResult::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Lithic::Models::BookTransferResponse::Event::DetailedResult::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::BookTransferResponse::Event::DetailedResult::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
         end
 
         # APPROVED financial events were successful while DECLINED financial events were
@@ -258,14 +323,32 @@ module Lithic
         module Result
           extend Lithic::Internal::Type::Enum
 
-          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::BookTransferResponse::Event::Result) }
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Lithic::BookTransferResponse::Event::Result)
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          APPROVED = T.let(:APPROVED, Lithic::Models::BookTransferResponse::Event::Result::TaggedSymbol)
-          DECLINED = T.let(:DECLINED, Lithic::Models::BookTransferResponse::Event::Result::TaggedSymbol)
+          APPROVED =
+            T.let(
+              :APPROVED,
+              Lithic::BookTransferResponse::Event::Result::TaggedSymbol
+            )
+          DECLINED =
+            T.let(
+              :DECLINED,
+              Lithic::BookTransferResponse::Event::Result::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Lithic::Models::BookTransferResponse::Event::Result::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::BookTransferResponse::Event::Result::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
         end
       end
 
@@ -274,14 +357,22 @@ module Lithic
       module Result
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::BookTransferResponse::Result) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::BookTransferResponse::Result) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        APPROVED = T.let(:APPROVED, Lithic::Models::BookTransferResponse::Result::TaggedSymbol)
-        DECLINED = T.let(:DECLINED, Lithic::Models::BookTransferResponse::Result::TaggedSymbol)
+        APPROVED =
+          T.let(:APPROVED, Lithic::BookTransferResponse::Result::TaggedSymbol)
+        DECLINED =
+          T.let(:DECLINED, Lithic::BookTransferResponse::Result::TaggedSymbol)
 
-        sig { override.returns(T::Array[Lithic::Models::BookTransferResponse::Result::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Lithic::BookTransferResponse::Result::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
 
       # Status types: _ `DECLINED` - The transfer was declined. _ `REVERSED` - The
@@ -289,15 +380,24 @@ module Lithic
       module Status
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::BookTransferResponse::Status) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::BookTransferResponse::Status) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        DECLINED = T.let(:DECLINED, Lithic::Models::BookTransferResponse::Status::TaggedSymbol)
-        REVERSED = T.let(:REVERSED, Lithic::Models::BookTransferResponse::Status::TaggedSymbol)
-        SETTLED = T.let(:SETTLED, Lithic::Models::BookTransferResponse::Status::TaggedSymbol)
+        DECLINED =
+          T.let(:DECLINED, Lithic::BookTransferResponse::Status::TaggedSymbol)
+        REVERSED =
+          T.let(:REVERSED, Lithic::BookTransferResponse::Status::TaggedSymbol)
+        SETTLED =
+          T.let(:SETTLED, Lithic::BookTransferResponse::Status::TaggedSymbol)
 
-        sig { override.returns(T::Array[Lithic::Models::BookTransferResponse::Status::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Lithic::BookTransferResponse::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
     end
   end

data/rbi/lithic/models/book_transfer_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::BookTransferRetrieveParams, 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/book_transfer_reverse_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::BookTransferReverseParams, Lithic::Internal::AnyHash)
+        end
+
       # Optional descriptor for the reversal.
       sig { returns(T.nilable(String)) }
       attr_reader :memo
@@ -14,16 +19,25 @@ module Lithic
       attr_writer :memo
 
       sig do
-        params(memo: String, request_options: T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash))
-          .returns(T.attached_class)
+        params(
+          memo: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # Optional descriptor for the reversal.
         memo: nil,
         request_options: {}
-      ); end
-      sig { override.returns({memo: String, request_options: Lithic::RequestOptions}) }
-      def to_hash; end
+      )
+      end
+
+      sig do
+        override.returns(
+          { memo: String, request_options: Lithic::RequestOptions }
+        )
+      end
+      def to_hash
+      end
     end
   end
 end

data/rbi/lithic/models/card.rbi

@@ -3,6 +3,8 @@
 module Lithic
   module Models
     class Card < Lithic::Models::NonPCICard
+      OrHash = T.type_alias { T.any(Lithic::Card, Lithic::Internal::AnyHash) }
+
       # Three digit cvv printed on the back of the card.
       sig { returns(T.nilable(String)) }
       attr_reader :cvv
@@ -28,9 +30,12 @@ module Lithic
         # compliant to have PAN returned as a field in production. Please contact
         # support@lithic.com for questions.
         pan: nil
-      ); end
-      sig { override.returns({cvv: String, pan: String}) }
-      def to_hash; end
+      )
+      end
+
+      sig { override.returns({ cvv: String, pan: String }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/lithic/models/card_convert_physical_params.rbi

@@ -6,18 +6,23 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::CardConvertPhysicalParams, Lithic::Internal::AnyHash)
+        end
+
       # The shipping address this card will be sent to.
-      sig { returns(Lithic::Models::ShippingAddress) }
+      sig { returns(Lithic::ShippingAddress) }
       attr_reader :shipping_address
 
-      sig { params(shipping_address: T.any(Lithic::Models::ShippingAddress, Lithic::Internal::AnyHash)).void }
+      sig { params(shipping_address: Lithic::ShippingAddress::OrHash).void }
       attr_writer :shipping_address
 
       # If omitted, the previous carrier will be used.
-      sig { returns(T.nilable(Lithic::Models::Carrier)) }
+      sig { returns(T.nilable(Lithic::Carrier)) }
       attr_reader :carrier
 
-      sig { params(carrier: T.any(Lithic::Models::Carrier, Lithic::Internal::AnyHash)).void }
+      sig { params(carrier: Lithic::Carrier::OrHash).void }
       attr_writer :carrier
 
       # Specifies the configuration (e.g. physical card art) that the card should be
@@ -41,21 +46,30 @@ module Lithic
       # - `2_DAY` - FedEx 2-day shipping, with tracking
       # - `EXPEDITED` - FedEx Standard Overnight or similar international option, with
       #   tracking
-      sig { returns(T.nilable(Lithic::Models::CardConvertPhysicalParams::ShippingMethod::OrSymbol)) }
+      sig do
+        returns(
+          T.nilable(Lithic::CardConvertPhysicalParams::ShippingMethod::OrSymbol)
+        )
+      end
       attr_reader :shipping_method
 
-      sig { params(shipping_method: Lithic::Models::CardConvertPhysicalParams::ShippingMethod::OrSymbol).void }
+      sig do
+        params(
+          shipping_method:
+            Lithic::CardConvertPhysicalParams::ShippingMethod::OrSymbol
+        ).void
+      end
       attr_writer :shipping_method
 
       sig do
         params(
-          shipping_address: T.any(Lithic::Models::ShippingAddress, Lithic::Internal::AnyHash),
-          carrier: T.any(Lithic::Models::Carrier, Lithic::Internal::AnyHash),
+          shipping_address: Lithic::ShippingAddress::OrHash,
+          carrier: Lithic::Carrier::OrHash,
           product_id: String,
-          shipping_method: Lithic::Models::CardConvertPhysicalParams::ShippingMethod::OrSymbol,
-          request_options: T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          shipping_method:
+            Lithic::CardConvertPhysicalParams::ShippingMethod::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # The shipping address this card will be sent to.
@@ -80,20 +94,23 @@ module Lithic
         #   tracking
         shipping_method: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              shipping_address: Lithic::Models::ShippingAddress,
-              carrier: Lithic::Models::Carrier,
-              product_id: String,
-              shipping_method: Lithic::Models::CardConvertPhysicalParams::ShippingMethod::OrSymbol,
-              request_options: Lithic::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            shipping_address: Lithic::ShippingAddress,
+            carrier: Lithic::Carrier,
+            product_id: String,
+            shipping_method:
+              Lithic::CardConvertPhysicalParams::ShippingMethod::OrSymbol,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       # Shipping method for the card. Only applies to cards of type PHYSICAL. Use of
       # options besides `STANDARD` require additional permissions.
@@ -110,20 +127,52 @@ module Lithic
       module ShippingMethod
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::CardConvertPhysicalParams::ShippingMethod) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::CardConvertPhysicalParams::ShippingMethod)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         SHIPPING_METHOD_2_DAY =
-          T.let(:"2_DAY", Lithic::Models::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol)
-        EXPEDITED = T.let(:EXPEDITED, Lithic::Models::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol)
-        EXPRESS = T.let(:EXPRESS, Lithic::Models::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol)
-        PRIORITY = T.let(:PRIORITY, Lithic::Models::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol)
-        STANDARD = T.let(:STANDARD, Lithic::Models::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol)
+          T.let(
+            :"2_DAY",
+            Lithic::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol
+          )
+        EXPEDITED =
+          T.let(
+            :EXPEDITED,
+            Lithic::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol
+          )
+        EXPRESS =
+          T.let(
+            :EXPRESS,
+            Lithic::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol
+          )
+        PRIORITY =
+          T.let(
+            :PRIORITY,
+            Lithic::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol
+          )
+        STANDARD =
+          T.let(
+            :STANDARD,
+            Lithic::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol
+          )
         STANDARD_WITH_TRACKING =
-          T.let(:STANDARD_WITH_TRACKING, Lithic::Models::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol)
+          T.let(
+            :STANDARD_WITH_TRACKING,
+            Lithic::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::CardConvertPhysicalParams::ShippingMethod::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
     end
   end