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

data/rbi/lithic/models/kyc.rbi

@@ -3,12 +3,14 @@
 module Lithic
   module Models
     class KYC < Lithic::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Lithic::KYC, Lithic::Internal::AnyHash) }
+
       # Information on individual for whom the account is being opened and KYC is being
       # run.
-      sig { returns(Lithic::Models::KYC::Individual) }
+      sig { returns(Lithic::KYC::Individual) }
       attr_reader :individual
 
-      sig { params(individual: T.any(Lithic::Models::KYC::Individual, Lithic::Internal::AnyHash)).void }
+      sig { params(individual: Lithic::KYC::Individual::OrHash).void }
       attr_writer :individual
 
       # An RFC 3339 timestamp indicating when the account holder accepted the applicable
@@ -18,7 +20,7 @@ module Lithic
       attr_accessor :tos_timestamp
 
       # Specifies the type of KYC workflow to run.
-      sig { returns(Lithic::Models::KYC::Workflow::OrSymbol) }
+      sig { returns(Lithic::KYC::Workflow::OrSymbol) }
       attr_accessor :workflow
 
       # A user provided id that can be used to link an account holder with an external
@@ -41,13 +43,12 @@ module Lithic
 
       sig do
         params(
-          individual: T.any(Lithic::Models::KYC::Individual, Lithic::Internal::AnyHash),
+          individual: Lithic::KYC::Individual::OrHash,
           tos_timestamp: String,
-          workflow: Lithic::Models::KYC::Workflow::OrSymbol,
+          workflow: Lithic::KYC::Workflow::OrSymbol,
           external_id: String,
           kyc_passed_timestamp: String
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # Information on individual for whom the account is being opened and KYC is being
@@ -67,28 +68,35 @@ module Lithic
         #
         # This field is required only if workflow type is `KYC_BYO`.
         kyc_passed_timestamp: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              individual: Lithic::Models::KYC::Individual,
-              tos_timestamp: String,
-              workflow: Lithic::Models::KYC::Workflow::OrSymbol,
-              external_id: String,
-              kyc_passed_timestamp: String
-            }
-          )
+        override.returns(
+          {
+            individual: Lithic::KYC::Individual,
+            tos_timestamp: String,
+            workflow: Lithic::KYC::Workflow::OrSymbol,
+            external_id: String,
+            kyc_passed_timestamp: String
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class Individual < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Lithic::KYC::Individual, Lithic::Internal::AnyHash)
+          end
+
         # Individual's current address - PO boxes, UPS drops, and FedEx drops are not
         # acceptable; APO/FPO are acceptable. Only USA addresses are currently supported.
-        sig { returns(Lithic::Models::Address) }
+        sig { returns(Lithic::Address) }
         attr_reader :address
 
-        sig { params(address: T.any(Lithic::Models::Address, Lithic::Internal::AnyHash)).void }
+        sig { params(address: Lithic::Address::OrHash).void }
         attr_writer :address
 
         # Individual's date of birth, as an RFC 3339 date.
@@ -123,15 +131,14 @@ module Lithic
         # run.
         sig do
           params(
-            address: T.any(Lithic::Models::Address, Lithic::Internal::AnyHash),
+            address: Lithic::Address::OrHash,
             dob: String,
             email: String,
             first_name: String,
             government_id: String,
             last_name: String,
             phone_number: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # Individual's current address - PO boxes, UPS drops, and FedEx drops are not
@@ -153,36 +160,39 @@ module Lithic
           last_name:,
           # Individual's phone number, entered in E.164 format.
           phone_number:
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                address: Lithic::Models::Address,
-                dob: String,
-                email: String,
-                first_name: String,
-                government_id: String,
-                last_name: String,
-                phone_number: String
-              }
-            )
+          override.returns(
+            {
+              address: Lithic::Address,
+              dob: String,
+              email: String,
+              first_name: String,
+              government_id: String,
+              last_name: String,
+              phone_number: String
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
 
       # Specifies the type of KYC workflow to run.
       module Workflow
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::KYC::Workflow) }
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::KYC::Workflow) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        KYC_BASIC = T.let(:KYC_BASIC, Lithic::Models::KYC::Workflow::TaggedSymbol)
-        KYC_BYO = T.let(:KYC_BYO, Lithic::Models::KYC::Workflow::TaggedSymbol)
+        KYC_BASIC = T.let(:KYC_BASIC, Lithic::KYC::Workflow::TaggedSymbol)
+        KYC_BYO = T.let(:KYC_BYO, Lithic::KYC::Workflow::TaggedSymbol)
 
-        sig { override.returns(T::Array[Lithic::Models::KYC::Workflow::TaggedSymbol]) }
-        def self.values; end
+        sig { override.returns(T::Array[Lithic::KYC::Workflow::TaggedSymbol]) }
+        def self.values
+        end
       end
     end
   end

data/rbi/lithic/models/kyc_exempt.rbi

@@ -3,12 +3,15 @@
 module Lithic
   module Models
     class KYCExempt < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Lithic::KYCExempt, Lithic::Internal::AnyHash) }
+
       # KYC Exempt user's current address - PO boxes, UPS drops, and FedEx drops are not
       # acceptable; APO/FPO are acceptable.
-      sig { returns(Lithic::Models::Address) }
+      sig { returns(Lithic::Address) }
       attr_reader :address
 
-      sig { params(address: T.any(Lithic::Models::Address, Lithic::Internal::AnyHash)).void }
+      sig { params(address: Lithic::Address::OrHash).void }
       attr_writer :address
 
       # The KYC Exempt user's email
@@ -20,7 +23,7 @@ module Lithic
       attr_accessor :first_name
 
       # Specifies the type of KYC Exempt user
-      sig { returns(Lithic::Models::KYCExempt::KYCExemptionType::OrSymbol) }
+      sig { returns(Lithic::KYCExempt::KYCExemptionType::OrSymbol) }
       attr_accessor :kyc_exemption_type
 
       # The KYC Exempt user's last name
@@ -32,7 +35,7 @@ module Lithic
       attr_accessor :phone_number
 
       # Specifies the workflow type. This must be 'KYC_EXEMPT'
-      sig { returns(Lithic::Models::KYCExempt::Workflow::OrSymbol) }
+      sig { returns(Lithic::KYCExempt::Workflow::OrSymbol) }
       attr_accessor :workflow
 
       # Only applicable for customers using the KYC-Exempt workflow to enroll authorized
@@ -54,17 +57,16 @@ module Lithic
 
       sig do
         params(
-          address: T.any(Lithic::Models::Address, Lithic::Internal::AnyHash),
+          address: Lithic::Address::OrHash,
           email: String,
           first_name: String,
-          kyc_exemption_type: Lithic::Models::KYCExempt::KYCExemptionType::OrSymbol,
+          kyc_exemption_type: Lithic::KYCExempt::KYCExemptionType::OrSymbol,
           last_name: String,
           phone_number: String,
-          workflow: Lithic::Models::KYCExempt::Workflow::OrSymbol,
+          workflow: Lithic::KYCExempt::Workflow::OrSymbol,
           business_account_token: String,
           external_id: String
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # KYC Exempt user's current address - PO boxes, UPS drops, and FedEx drops are not
@@ -89,50 +91,71 @@ module Lithic
         # A user provided id that can be used to link an account holder with an external
         # system
         external_id: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              address: Lithic::Models::Address,
-              email: String,
-              first_name: String,
-              kyc_exemption_type: Lithic::Models::KYCExempt::KYCExemptionType::OrSymbol,
-              last_name: String,
-              phone_number: String,
-              workflow: Lithic::Models::KYCExempt::Workflow::OrSymbol,
-              business_account_token: String,
-              external_id: String
-            }
-          )
+        override.returns(
+          {
+            address: Lithic::Address,
+            email: String,
+            first_name: String,
+            kyc_exemption_type: Lithic::KYCExempt::KYCExemptionType::OrSymbol,
+            last_name: String,
+            phone_number: String,
+            workflow: Lithic::KYCExempt::Workflow::OrSymbol,
+            business_account_token: String,
+            external_id: String
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       # Specifies the type of KYC Exempt user
       module KYCExemptionType
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::KYCExempt::KYCExemptionType) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::KYCExempt::KYCExemptionType) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        AUTHORIZED_USER = T.let(:AUTHORIZED_USER, Lithic::Models::KYCExempt::KYCExemptionType::TaggedSymbol)
-        PREPAID_CARD_USER = T.let(:PREPAID_CARD_USER, Lithic::Models::KYCExempt::KYCExemptionType::TaggedSymbol)
+        AUTHORIZED_USER =
+          T.let(
+            :AUTHORIZED_USER,
+            Lithic::KYCExempt::KYCExemptionType::TaggedSymbol
+          )
+        PREPAID_CARD_USER =
+          T.let(
+            :PREPAID_CARD_USER,
+            Lithic::KYCExempt::KYCExemptionType::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::KYCExempt::KYCExemptionType::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Lithic::KYCExempt::KYCExemptionType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
 
       # Specifies the workflow type. This must be 'KYC_EXEMPT'
       module Workflow
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::KYCExempt::Workflow) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::KYCExempt::Workflow) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        KYC_EXEMPT = T.let(:KYC_EXEMPT, Lithic::Models::KYCExempt::Workflow::TaggedSymbol)
+        KYC_EXEMPT =
+          T.let(:KYC_EXEMPT, Lithic::KYCExempt::Workflow::TaggedSymbol)
 
-        sig { override.returns(T::Array[Lithic::Models::KYCExempt::Workflow::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(T::Array[Lithic::KYCExempt::Workflow::TaggedSymbol])
+        end
+        def self.values
+        end
       end
     end
   end

data/rbi/lithic/models/management_operation_create_params.rbi

@@ -6,19 +6,33 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::ManagementOperationCreateParams,
+            Lithic::Internal::AnyHash
+          )
+        end
+
       sig { returns(Integer) }
       attr_accessor :amount
 
-      sig { returns(Lithic::Models::ManagementOperationCreateParams::Category::OrSymbol) }
+      sig do
+        returns(Lithic::ManagementOperationCreateParams::Category::OrSymbol)
+      end
       attr_accessor :category
 
-      sig { returns(Lithic::Models::ManagementOperationCreateParams::Direction::OrSymbol) }
+      sig do
+        returns(Lithic::ManagementOperationCreateParams::Direction::OrSymbol)
+      end
       attr_accessor :direction
 
       sig { returns(Date) }
       attr_accessor :effective_date
 
-      sig { returns(Lithic::Models::ManagementOperationCreateParams::EventType::OrSymbol) }
+      sig do
+        returns(Lithic::ManagementOperationCreateParams::EventType::OrSymbol)
+      end
       attr_accessor :event_type
 
       sig { returns(String) }
@@ -51,18 +65,19 @@ module Lithic
       sig do
         params(
           amount: Integer,
-          category: Lithic::Models::ManagementOperationCreateParams::Category::OrSymbol,
-          direction: Lithic::Models::ManagementOperationCreateParams::Direction::OrSymbol,
+          category: Lithic::ManagementOperationCreateParams::Category::OrSymbol,
+          direction:
+            Lithic::ManagementOperationCreateParams::Direction::OrSymbol,
           effective_date: Date,
-          event_type: Lithic::Models::ManagementOperationCreateParams::EventType::OrSymbol,
+          event_type:
+            Lithic::ManagementOperationCreateParams::EventType::OrSymbol,
           financial_account_token: String,
           token: String,
           memo: String,
           subtype: String,
           user_defined_id: String,
-          request_options: T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         amount:,
@@ -76,114 +91,223 @@ module Lithic
         subtype: nil,
         user_defined_id: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              amount: Integer,
-              category: Lithic::Models::ManagementOperationCreateParams::Category::OrSymbol,
-              direction: Lithic::Models::ManagementOperationCreateParams::Direction::OrSymbol,
-              effective_date: Date,
-              event_type: Lithic::Models::ManagementOperationCreateParams::EventType::OrSymbol,
-              financial_account_token: String,
-              token: String,
-              memo: String,
-              subtype: String,
-              user_defined_id: String,
-              request_options: Lithic::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            amount: Integer,
+            category:
+              Lithic::ManagementOperationCreateParams::Category::OrSymbol,
+            direction:
+              Lithic::ManagementOperationCreateParams::Direction::OrSymbol,
+            effective_date: Date,
+            event_type:
+              Lithic::ManagementOperationCreateParams::EventType::OrSymbol,
+            financial_account_token: String,
+            token: String,
+            memo: String,
+            subtype: String,
+            user_defined_id: String,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      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::ManagementOperationCreateParams::Category) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::ManagementOperationCreateParams::Category)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         MANAGEMENT_FEE =
-          T.let(:MANAGEMENT_FEE, Lithic::Models::ManagementOperationCreateParams::Category::TaggedSymbol)
+          T.let(
+            :MANAGEMENT_FEE,
+            Lithic::ManagementOperationCreateParams::Category::TaggedSymbol
+          )
         MANAGEMENT_DISPUTE =
-          T.let(:MANAGEMENT_DISPUTE, Lithic::Models::ManagementOperationCreateParams::Category::TaggedSymbol)
+          T.let(
+            :MANAGEMENT_DISPUTE,
+            Lithic::ManagementOperationCreateParams::Category::TaggedSymbol
+          )
         MANAGEMENT_REWARD =
-          T.let(:MANAGEMENT_REWARD, Lithic::Models::ManagementOperationCreateParams::Category::TaggedSymbol)
+          T.let(
+            :MANAGEMENT_REWARD,
+            Lithic::ManagementOperationCreateParams::Category::TaggedSymbol
+          )
         MANAGEMENT_ADJUSTMENT =
-          T.let(:MANAGEMENT_ADJUSTMENT, Lithic::Models::ManagementOperationCreateParams::Category::TaggedSymbol)
+          T.let(
+            :MANAGEMENT_ADJUSTMENT,
+            Lithic::ManagementOperationCreateParams::Category::TaggedSymbol
+          )
         MANAGEMENT_DISBURSEMENT =
-          T.let(:MANAGEMENT_DISBURSEMENT, Lithic::Models::ManagementOperationCreateParams::Category::TaggedSymbol)
+          T.let(
+            :MANAGEMENT_DISBURSEMENT,
+            Lithic::ManagementOperationCreateParams::Category::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::ManagementOperationCreateParams::Category::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::ManagementOperationCreateParams::Category::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
 
       module Direction
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationCreateParams::Direction) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::ManagementOperationCreateParams::Direction)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        CREDIT = T.let(:CREDIT, Lithic::Models::ManagementOperationCreateParams::Direction::TaggedSymbol)
-        DEBIT = T.let(:DEBIT, Lithic::Models::ManagementOperationCreateParams::Direction::TaggedSymbol)
+        CREDIT =
+          T.let(
+            :CREDIT,
+            Lithic::ManagementOperationCreateParams::Direction::TaggedSymbol
+          )
+        DEBIT =
+          T.let(
+            :DEBIT,
+            Lithic::ManagementOperationCreateParams::Direction::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::ManagementOperationCreateParams::Direction::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::ManagementOperationCreateParams::Direction::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
 
       module EventType
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationCreateParams::EventType) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::ManagementOperationCreateParams::EventType)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         LOSS_WRITE_OFF =
-          T.let(:LOSS_WRITE_OFF, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
-        CASH_BACK = T.let(:CASH_BACK, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :LOSS_WRITE_OFF,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
+        CASH_BACK =
+          T.let(
+            :CASH_BACK,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
         CASH_BACK_REVERSAL =
-          T.let(:CASH_BACK_REVERSAL, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :CASH_BACK_REVERSAL,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
         CURRENCY_CONVERSION =
-          T.let(:CURRENCY_CONVERSION, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :CURRENCY_CONVERSION,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
         CURRENCY_CONVERSION_REVERSAL =
           T.let(
             :CURRENCY_CONVERSION_REVERSAL,
-            Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
+        INTEREST =
+          T.let(
+            :INTEREST,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
           )
-        INTEREST = T.let(:INTEREST, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
         INTEREST_REVERSAL =
-          T.let(:INTEREST_REVERSAL, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :INTEREST_REVERSAL,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
         LATE_PAYMENT =
-          T.let(:LATE_PAYMENT, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :LATE_PAYMENT,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
         LATE_PAYMENT_REVERSAL =
-          T.let(:LATE_PAYMENT_REVERSAL, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :LATE_PAYMENT_REVERSAL,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
         BILLING_ERROR =
-          T.let(:BILLING_ERROR, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :BILLING_ERROR,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
         BILLING_ERROR_REVERSAL =
-          T.let(:BILLING_ERROR_REVERSAL, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :BILLING_ERROR_REVERSAL,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
         PROVISIONAL_CREDIT =
-          T.let(:PROVISIONAL_CREDIT, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :PROVISIONAL_CREDIT,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
         PROVISIONAL_CREDIT_REVERSAL =
           T.let(
             :PROVISIONAL_CREDIT_REVERSAL,
-            Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
           )
         RETURNED_PAYMENT =
-          T.let(:RETURNED_PAYMENT, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :RETURNED_PAYMENT,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
         RETURNED_PAYMENT_REVERSAL =
           T.let(
             :RETURNED_PAYMENT_REVERSAL,
-            Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
           )
         DISPUTE_WON =
-          T.let(:DISPUTE_WON, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :DISPUTE_WON,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
         DISPUTE_WON_REVERSAL =
-          T.let(:DISPUTE_WON_REVERSAL, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
-        DISBURSE = T.let(:DISBURSE, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :DISPUTE_WON_REVERSAL,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
+        DISBURSE =
+          T.let(
+            :DISBURSE,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
         DISBURSE_REVERSAL =
-          T.let(:DISBURSE_REVERSAL, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+          T.let(
+            :DISBURSE_REVERSAL,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
     end
   end