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

data/rbi/lithic/models/management_operation_transaction.rbi

@@ -3,10 +3,20 @@
 module Lithic
   module Models
     class ManagementOperationTransaction < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::ManagementOperationTransaction,
+            Lithic::Internal::AnyHash
+          )
+        end
+
       sig { returns(String) }
       attr_accessor :token
 
-      sig { returns(Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol) }
+      sig do
+        returns(Lithic::ManagementOperationTransaction::Category::TaggedSymbol)
+      end
       attr_accessor :category
 
       sig { returns(Time) }
@@ -15,10 +25,12 @@ module Lithic
       sig { returns(String) }
       attr_accessor :currency
 
-      sig { returns(Lithic::Models::ManagementOperationTransaction::Direction::TaggedSymbol) }
+      sig do
+        returns(Lithic::ManagementOperationTransaction::Direction::TaggedSymbol)
+      end
       attr_accessor :direction
 
-      sig { returns(T::Array[Lithic::Models::ManagementOperationTransaction::Event]) }
+      sig { returns(T::Array[Lithic::ManagementOperationTransaction::Event]) }
       attr_accessor :events
 
       sig { returns(String) }
@@ -27,25 +39,33 @@ module Lithic
       sig { returns(Integer) }
       attr_accessor :pending_amount
 
-      sig { returns(Lithic::Models::ManagementOperationTransaction::Result::TaggedSymbol) }
+      sig do
+        returns(Lithic::ManagementOperationTransaction::Result::TaggedSymbol)
+      end
       attr_accessor :result
 
       sig { returns(Integer) }
       attr_accessor :settled_amount
 
-      sig { returns(Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol) }
+      sig do
+        returns(Lithic::ManagementOperationTransaction::Status::TaggedSymbol)
+      end
       attr_accessor :status
 
-      sig { returns(T.nilable(Lithic::Models::ManagementOperationTransaction::TransactionSeries)) }
+      sig do
+        returns(
+          T.nilable(Lithic::ManagementOperationTransaction::TransactionSeries)
+        )
+      end
       attr_reader :transaction_series
 
       sig do
         params(
-          transaction_series: T.nilable(
-            T.any(Lithic::Models::ManagementOperationTransaction::TransactionSeries, Lithic::Internal::AnyHash)
-          )
-        )
-          .void
+          transaction_series:
+            T.nilable(
+              Lithic::ManagementOperationTransaction::TransactionSeries::OrHash
+            )
+        ).void
       end
       attr_writer :transaction_series
 
@@ -61,23 +81,25 @@ module Lithic
       sig do
         params(
           token: String,
-          category: Lithic::Models::ManagementOperationTransaction::Category::OrSymbol,
+          category: Lithic::ManagementOperationTransaction::Category::OrSymbol,
           created: Time,
           currency: String,
-          direction: Lithic::Models::ManagementOperationTransaction::Direction::OrSymbol,
-          events: T::Array[T.any(Lithic::Models::ManagementOperationTransaction::Event, Lithic::Internal::AnyHash)],
+          direction:
+            Lithic::ManagementOperationTransaction::Direction::OrSymbol,
+          events:
+            T::Array[Lithic::ManagementOperationTransaction::Event::OrHash],
           financial_account_token: String,
           pending_amount: Integer,
-          result: Lithic::Models::ManagementOperationTransaction::Result::OrSymbol,
+          result: Lithic::ManagementOperationTransaction::Result::OrSymbol,
           settled_amount: Integer,
-          status: Lithic::Models::ManagementOperationTransaction::Status::OrSymbol,
-          transaction_series: T.nilable(
-            T.any(Lithic::Models::ManagementOperationTransaction::TransactionSeries, Lithic::Internal::AnyHash)
-          ),
+          status: Lithic::ManagementOperationTransaction::Status::OrSymbol,
+          transaction_series:
+            T.nilable(
+              Lithic::ManagementOperationTransaction::TransactionSeries::OrHash
+            ),
           updated: Time,
           user_defined_id: String
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         token:,
@@ -94,65 +116,125 @@ module Lithic
         transaction_series:,
         updated:,
         user_defined_id: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              token: String,
-              category: Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol,
-              created: Time,
-              currency: String,
-              direction: Lithic::Models::ManagementOperationTransaction::Direction::TaggedSymbol,
-              events: T::Array[Lithic::Models::ManagementOperationTransaction::Event],
-              financial_account_token: String,
-              pending_amount: Integer,
-              result: Lithic::Models::ManagementOperationTransaction::Result::TaggedSymbol,
-              settled_amount: Integer,
-              status: Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol,
-              transaction_series: T.nilable(Lithic::Models::ManagementOperationTransaction::TransactionSeries),
-              updated: Time,
-              user_defined_id: String
-            }
-          )
+        override.returns(
+          {
+            token: String,
+            category:
+              Lithic::ManagementOperationTransaction::Category::TaggedSymbol,
+            created: Time,
+            currency: String,
+            direction:
+              Lithic::ManagementOperationTransaction::Direction::TaggedSymbol,
+            events: T::Array[Lithic::ManagementOperationTransaction::Event],
+            financial_account_token: String,
+            pending_amount: Integer,
+            result:
+              Lithic::ManagementOperationTransaction::Result::TaggedSymbol,
+            settled_amount: Integer,
+            status:
+              Lithic::ManagementOperationTransaction::Status::TaggedSymbol,
+            transaction_series:
+              T.nilable(
+                Lithic::ManagementOperationTransaction::TransactionSeries
+              ),
+            updated: Time,
+            user_defined_id: String
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       module Category
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Category) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::ManagementOperationTransaction::Category)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         MANAGEMENT_FEE =
-          T.let(:MANAGEMENT_FEE, Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol)
+          T.let(
+            :MANAGEMENT_FEE,
+            Lithic::ManagementOperationTransaction::Category::TaggedSymbol
+          )
         MANAGEMENT_DISPUTE =
-          T.let(:MANAGEMENT_DISPUTE, Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol)
+          T.let(
+            :MANAGEMENT_DISPUTE,
+            Lithic::ManagementOperationTransaction::Category::TaggedSymbol
+          )
         MANAGEMENT_REWARD =
-          T.let(:MANAGEMENT_REWARD, Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol)
+          T.let(
+            :MANAGEMENT_REWARD,
+            Lithic::ManagementOperationTransaction::Category::TaggedSymbol
+          )
         MANAGEMENT_ADJUSTMENT =
-          T.let(:MANAGEMENT_ADJUSTMENT, Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol)
+          T.let(
+            :MANAGEMENT_ADJUSTMENT,
+            Lithic::ManagementOperationTransaction::Category::TaggedSymbol
+          )
         MANAGEMENT_DISBURSEMENT =
-          T.let(:MANAGEMENT_DISBURSEMENT, Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol)
+          T.let(
+            :MANAGEMENT_DISBURSEMENT,
+            Lithic::ManagementOperationTransaction::Category::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::ManagementOperationTransaction::Category::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::ManagementOperationTransaction::Category::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
 
       module Direction
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Direction) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::ManagementOperationTransaction::Direction)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        CREDIT = T.let(:CREDIT, Lithic::Models::ManagementOperationTransaction::Direction::TaggedSymbol)
-        DEBIT = T.let(:DEBIT, Lithic::Models::ManagementOperationTransaction::Direction::TaggedSymbol)
+        CREDIT =
+          T.let(
+            :CREDIT,
+            Lithic::ManagementOperationTransaction::Direction::TaggedSymbol
+          )
+        DEBIT =
+          T.let(
+            :DEBIT,
+            Lithic::ManagementOperationTransaction::Direction::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::ManagementOperationTransaction::Direction::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::ManagementOperationTransaction::Direction::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
 
       class Event < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::ManagementOperationTransaction::Event,
+              Lithic::Internal::AnyHash
+            )
+          end
+
         sig { returns(String) }
         attr_accessor :token
 
@@ -162,7 +244,13 @@ module Lithic
         sig { returns(Time) }
         attr_accessor :created
 
-        sig { returns(T::Array[Lithic::Models::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol]) }
+        sig do
+          returns(
+            T::Array[
+              Lithic::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol
+            ]
+          )
+        end
         attr_accessor :detailed_results
 
         sig { returns(Date) }
@@ -171,10 +259,18 @@ module Lithic
         sig { returns(String) }
         attr_accessor :memo
 
-        sig { returns(Lithic::Models::ManagementOperationTransaction::Event::Result::TaggedSymbol) }
+        sig do
+          returns(
+            Lithic::ManagementOperationTransaction::Event::Result::TaggedSymbol
+          )
+        end
         attr_accessor :result
 
-        sig { returns(Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol) }
+        sig do
+          returns(
+            Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+          )
+        end
         attr_accessor :type
 
         sig { returns(T.nilable(String)) }
@@ -188,14 +284,17 @@ module Lithic
             token: String,
             amount: Integer,
             created: Time,
-            detailed_results: T::Array[Lithic::Models::ManagementOperationTransaction::Event::DetailedResult::OrSymbol],
+            detailed_results:
+              T::Array[
+                Lithic::ManagementOperationTransaction::Event::DetailedResult::OrSymbol
+              ],
             effective_date: Date,
             memo: String,
-            result: Lithic::Models::ManagementOperationTransaction::Event::Result::OrSymbol,
-            type: Lithic::Models::ManagementOperationTransaction::Event::Type::OrSymbol,
+            result:
+              Lithic::ManagementOperationTransaction::Event::Result::OrSymbol,
+            type: Lithic::ManagementOperationTransaction::Event::Type::OrSymbol,
             subtype: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           token:,
@@ -211,141 +310,294 @@ module Lithic
         end
 
         sig do
-          override
-            .returns(
-              {
-                token: String,
-                amount: Integer,
-                created: Time,
-                detailed_results: T::Array[Lithic::Models::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol],
-                effective_date: Date,
-                memo: String,
-                result: Lithic::Models::ManagementOperationTransaction::Event::Result::TaggedSymbol,
-                type: Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol,
-                subtype: String
-              }
-            )
+          override.returns(
+            {
+              token: String,
+              amount: Integer,
+              created: Time,
+              detailed_results:
+                T::Array[
+                  Lithic::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol
+                ],
+              effective_date: Date,
+              memo: String,
+              result:
+                Lithic::ManagementOperationTransaction::Event::Result::TaggedSymbol,
+              type:
+                Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol,
+              subtype: 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::ManagementOperationTransaction::Event::DetailedResult) }
+            T.type_alias do
+              T.all(
+                Symbol,
+                Lithic::ManagementOperationTransaction::Event::DetailedResult
+              )
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
           APPROVED =
-            T.let(:APPROVED, Lithic::Models::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol)
+            T.let(
+              :APPROVED,
+              Lithic::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol
+            )
 
           sig do
-            override
-              .returns(T::Array[Lithic::Models::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol])
+            override.returns(
+              T::Array[
+                Lithic::ManagementOperationTransaction::Event::DetailedResult::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
           end
-          def self.values; end
         end
 
         module Result
           extend Lithic::Internal::Type::Enum
 
           TaggedSymbol =
-            T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Event::Result) }
+            T.type_alias do
+              T.all(
+                Symbol,
+                Lithic::ManagementOperationTransaction::Event::Result
+              )
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          APPROVED = T.let(:APPROVED, Lithic::Models::ManagementOperationTransaction::Event::Result::TaggedSymbol)
-          DECLINED = T.let(:DECLINED, Lithic::Models::ManagementOperationTransaction::Event::Result::TaggedSymbol)
+          APPROVED =
+            T.let(
+              :APPROVED,
+              Lithic::ManagementOperationTransaction::Event::Result::TaggedSymbol
+            )
+          DECLINED =
+            T.let(
+              :DECLINED,
+              Lithic::ManagementOperationTransaction::Event::Result::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Lithic::Models::ManagementOperationTransaction::Event::Result::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::ManagementOperationTransaction::Event::Result::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
         end
 
         module Type
           extend Lithic::Internal::Type::Enum
 
           TaggedSymbol =
-            T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Event::Type) }
+            T.type_alias do
+              T.all(Symbol, Lithic::ManagementOperationTransaction::Event::Type)
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
           LOSS_WRITE_OFF =
-            T.let(:LOSS_WRITE_OFF, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
-          CASH_BACK = T.let(:CASH_BACK, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :LOSS_WRITE_OFF,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
+          CASH_BACK =
+            T.let(
+              :CASH_BACK,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
           CASH_BACK_REVERSAL =
-            T.let(:CASH_BACK_REVERSAL, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :CASH_BACK_REVERSAL,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
           CURRENCY_CONVERSION =
-            T.let(:CURRENCY_CONVERSION, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :CURRENCY_CONVERSION,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
           CURRENCY_CONVERSION_REVERSAL =
             T.let(
               :CURRENCY_CONVERSION_REVERSAL,
-              Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
+          INTEREST =
+            T.let(
+              :INTEREST,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
             )
-          INTEREST = T.let(:INTEREST, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
           INTEREST_REVERSAL =
-            T.let(:INTEREST_REVERSAL, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :INTEREST_REVERSAL,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
           LATE_PAYMENT =
-            T.let(:LATE_PAYMENT, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :LATE_PAYMENT,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
           LATE_PAYMENT_REVERSAL =
-            T.let(:LATE_PAYMENT_REVERSAL, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :LATE_PAYMENT_REVERSAL,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
           BILLING_ERROR =
-            T.let(:BILLING_ERROR, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :BILLING_ERROR,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
           BILLING_ERROR_REVERSAL =
-            T.let(:BILLING_ERROR_REVERSAL, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :BILLING_ERROR_REVERSAL,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
           PROVISIONAL_CREDIT =
-            T.let(:PROVISIONAL_CREDIT, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :PROVISIONAL_CREDIT,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
           PROVISIONAL_CREDIT_REVERSAL =
             T.let(
               :PROVISIONAL_CREDIT_REVERSAL,
-              Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
             )
           RETURNED_PAYMENT =
-            T.let(:RETURNED_PAYMENT, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :RETURNED_PAYMENT,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
           RETURNED_PAYMENT_REVERSAL =
             T.let(
               :RETURNED_PAYMENT_REVERSAL,
-              Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
             )
           DISPUTE_WON =
-            T.let(:DISPUTE_WON, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :DISPUTE_WON,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
           DISPUTE_WON_REVERSAL =
-            T.let(:DISPUTE_WON_REVERSAL, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
-          DISBURSE = T.let(:DISBURSE, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :DISPUTE_WON_REVERSAL,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
+          DISBURSE =
+            T.let(
+              :DISBURSE,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
           DISBURSE_REVERSAL =
-            T.let(:DISBURSE_REVERSAL, Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol)
+            T.let(
+              :DISBURSE_REVERSAL,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Lithic::Models::ManagementOperationTransaction::Event::Type::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
         end
       end
 
       module Result
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Result) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::ManagementOperationTransaction::Result)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        APPROVED = T.let(:APPROVED, Lithic::Models::ManagementOperationTransaction::Result::TaggedSymbol)
-        DECLINED = T.let(:DECLINED, Lithic::Models::ManagementOperationTransaction::Result::TaggedSymbol)
+        APPROVED =
+          T.let(
+            :APPROVED,
+            Lithic::ManagementOperationTransaction::Result::TaggedSymbol
+          )
+        DECLINED =
+          T.let(
+            :DECLINED,
+            Lithic::ManagementOperationTransaction::Result::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::ManagementOperationTransaction::Result::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::ManagementOperationTransaction::Result::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
 
       module Status
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationTransaction::Status) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::ManagementOperationTransaction::Status)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        PENDING = T.let(:PENDING, Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol)
-        SETTLED = T.let(:SETTLED, Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol)
-        DECLINED = T.let(:DECLINED, Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol)
-        REVERSED = T.let(:REVERSED, Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol)
-        CANCELED = T.let(:CANCELED, Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol)
+        PENDING =
+          T.let(
+            :PENDING,
+            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+          )
+        SETTLED =
+          T.let(
+            :SETTLED,
+            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+          )
+        DECLINED =
+          T.let(
+            :DECLINED,
+            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+          )
+        REVERSED =
+          T.let(
+            :REVERSED,
+            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+          )
+        CANCELED =
+          T.let(
+            :CANCELED,
+            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::ManagementOperationTransaction::Status::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
 
       class TransactionSeries < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::ManagementOperationTransaction::TransactionSeries,
+              Lithic::Internal::AnyHash
+            )
+          end
+
         sig { returns(T.nilable(String)) }
         attr_accessor :related_transaction_event_token
 
@@ -360,22 +612,26 @@ module Lithic
             related_transaction_event_token: T.nilable(String),
             related_transaction_token: T.nilable(String),
             type: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          related_transaction_event_token:,
+          related_transaction_token:,
+          type:
+        )
         end
-        def self.new(related_transaction_event_token:, related_transaction_token:, type:); end
 
         sig do
-          override
-            .returns(
-              {
-                related_transaction_event_token: T.nilable(String),
-                related_transaction_token: T.nilable(String),
-                type: String
-              }
-            )
+          override.returns(
+            {
+              related_transaction_event_token: T.nilable(String),
+              related_transaction_token: T.nilable(String),
+              type: String
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end