modern_treasury 0.1.0.pre.alpha.15 → 0.1.0.pre.alpha.17

data/rbi/lib/modern_treasury/models/counterparty.rbi

@@ -2,118 +2,61 @@
 
 module ModernTreasury
   module Models
-    class Counterparty < ModernTreasury::BaseModel
+    class Counterparty < ModernTreasury::Internal::Type::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
+      # The accounts for this counterparty.
       sig { returns(T::Array[ModernTreasury::Models::Counterparty::Account]) }
-      def accounts
-      end
-
-      sig do
-        params(_: T::Array[ModernTreasury::Models::Counterparty::Account])
-          .returns(T::Array[ModernTreasury::Models::Counterparty::Account])
-      end
-      def accounts=(_)
-      end
+      attr_accessor :accounts
 
       sig { returns(Time) }
-      def created_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
+      attr_accessor :created_at
 
       sig { returns(T.nilable(Time)) }
-      def discarded_at
-      end
-
-      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-      def discarded_at=(_)
-      end
+      attr_accessor :discarded_at
 
+      # The counterparty's email.
       sig { returns(T.nilable(String)) }
-      def email
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def email=(_)
-      end
+      attr_accessor :email
 
+      # The id of the legal entity.
       sig { returns(T.nilable(String)) }
-      def legal_entity_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def legal_entity_id=(_)
-      end
+      attr_accessor :legal_entity_id
 
+      # This field will be true if this object exists in the live environment or false
+      # if it exists in the test environment.
       sig { returns(T::Boolean) }
-      def live_mode
-      end
-
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def live_mode=(_)
-      end
+      attr_accessor :live_mode
 
+      # Additional data represented as key-value pairs. Both the key and value must be
+      # strings.
       sig { returns(T::Hash[Symbol, String]) }
-      def metadata
-      end
-
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def metadata=(_)
-      end
+      attr_accessor :metadata
 
+      # A human friendly name for this counterparty.
       sig { returns(T.nilable(String)) }
-      def name
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def name=(_)
-      end
+      attr_accessor :name
 
       sig { returns(String) }
-      def object
-      end
-
-      sig { params(_: String).returns(String) }
-      def object=(_)
-      end
+      attr_accessor :object
 
+      # Send an email to the counterparty whenever an associated payment order is sent
+      # to the bank.
       sig { returns(T::Boolean) }
-      def send_remittance_advice
-      end
-
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def send_remittance_advice=(_)
-      end
+      attr_accessor :send_remittance_advice
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      attr_accessor :updated_at
 
-      sig { returns(Symbol) }
-      def verification_status
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def verification_status=(_)
-      end
+      # The verification status of the counterparty.
+      sig { returns(ModernTreasury::Models::Counterparty::VerificationStatus::TaggedSymbol) }
+      attr_accessor :verification_status
 
       sig do
         params(
           id: String,
-          accounts: T::Array[ModernTreasury::Models::Counterparty::Account],
+          accounts: T::Array[T.any(ModernTreasury::Models::Counterparty::Account, ModernTreasury::Internal::AnyHash)],
           created_at: Time,
           discarded_at: T.nilable(Time),
           email: T.nilable(String),
@@ -124,11 +67,11 @@ module ModernTreasury
           object: String,
           send_remittance_advice: T::Boolean,
           updated_at: Time,
-          verification_status: Symbol
+          verification_status: ModernTreasury::Models::Counterparty::VerificationStatus::OrSymbol
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         accounts:,
         created_at:,
@@ -142,9 +85,7 @@ module ModernTreasury
         send_remittance_advice:,
         updated_at:,
         verification_status:
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -161,176 +102,149 @@ module ModernTreasury
               object: String,
               send_remittance_advice: T::Boolean,
               updated_at: Time,
-              verification_status: Symbol
+              verification_status: ModernTreasury::Models::Counterparty::VerificationStatus::TaggedSymbol
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
 
-      class Account < ModernTreasury::BaseModel
+      class Account < ModernTreasury::Internal::Type::BaseModel
         sig { returns(T.nilable(String)) }
-        def id
-        end
+        attr_reader :id
 
-        sig { params(_: String).returns(String) }
-        def id=(_)
-        end
+        sig { params(id: String).void }
+        attr_writer :id
 
         sig { returns(T.nilable(T::Array[ModernTreasury::Models::AccountDetail])) }
-        def account_details
-        end
+        attr_reader :account_details
 
         sig do
-          params(_: T::Array[ModernTreasury::Models::AccountDetail])
-            .returns(T::Array[ModernTreasury::Models::AccountDetail])
-        end
-        def account_details=(_)
+          params(
+            account_details: T::Array[T.any(ModernTreasury::Models::AccountDetail, ModernTreasury::Internal::AnyHash)]
+          )
+            .void
         end
+        attr_writer :account_details
 
-        sig { returns(T.nilable(Symbol)) }
-        def account_type
-        end
+        # Can be `checking`, `savings` or `other`.
+        sig { returns(T.nilable(ModernTreasury::Models::ExternalAccountType::TaggedSymbol)) }
+        attr_reader :account_type
 
-        sig { params(_: Symbol).returns(Symbol) }
-        def account_type=(_)
-        end
+        sig { params(account_type: ModernTreasury::Models::ExternalAccountType::OrSymbol).void }
+        attr_writer :account_type
 
         sig { returns(T.nilable(T::Array[ModernTreasury::Models::Counterparty::Account::ContactDetail])) }
-        def contact_details
-        end
+        attr_reader :contact_details
 
         sig do
-          params(_: T::Array[ModernTreasury::Models::Counterparty::Account::ContactDetail])
-            .returns(T::Array[ModernTreasury::Models::Counterparty::Account::ContactDetail])
-        end
-        def contact_details=(_)
+          params(
+            contact_details: T::Array[T.any(ModernTreasury::Models::Counterparty::Account::ContactDetail, ModernTreasury::Internal::AnyHash)]
+          )
+            .void
         end
+        attr_writer :contact_details
 
         sig { returns(T.nilable(Time)) }
-        def created_at
-        end
+        attr_reader :created_at
 
-        sig { params(_: Time).returns(Time) }
-        def created_at=(_)
-        end
+        sig { params(created_at: Time).void }
+        attr_writer :created_at
 
         sig { returns(T.nilable(Time)) }
-        def discarded_at
-        end
-
-        sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-        def discarded_at=(_)
-        end
+        attr_accessor :discarded_at
 
+        # If the external account links to a ledger account in Modern Treasury, the id of
+        # the ledger account will be populated here.
         sig { returns(T.nilable(String)) }
-        def ledger_account_id
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def ledger_account_id=(_)
-        end
+        attr_accessor :ledger_account_id
 
+        # This field will be true if this object exists in the live environment or false
+        # if it exists in the test environment.
         sig { returns(T.nilable(T::Boolean)) }
-        def live_mode
-        end
+        attr_reader :live_mode
 
-        sig { params(_: T::Boolean).returns(T::Boolean) }
-        def live_mode=(_)
-        end
+        sig { params(live_mode: T::Boolean).void }
+        attr_writer :live_mode
 
+        # Additional data represented as key-value pairs. Both the key and value must be
+        # strings.
         sig { returns(T.nilable(T::Hash[Symbol, String])) }
-        def metadata
-        end
+        attr_reader :metadata
 
-        sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-        def metadata=(_)
-        end
+        sig { params(metadata: T::Hash[Symbol, String]).void }
+        attr_writer :metadata
 
+        # A nickname for the external account. This is only for internal usage and won't
+        # affect any payments
         sig { returns(T.nilable(String)) }
-        def name
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def name=(_)
-        end
+        attr_accessor :name
 
         sig { returns(T.nilable(String)) }
-        def object
-        end
+        attr_reader :object
 
-        sig { params(_: String).returns(String) }
-        def object=(_)
-        end
+        sig { params(object: String).void }
+        attr_writer :object
 
+        # The address associated with the owner or `null`.
         sig { returns(T.nilable(ModernTreasury::Models::Counterparty::Account::PartyAddress)) }
-        def party_address
-        end
+        attr_reader :party_address
 
         sig do
-          params(_: T.nilable(ModernTreasury::Models::Counterparty::Account::PartyAddress))
-            .returns(T.nilable(ModernTreasury::Models::Counterparty::Account::PartyAddress))
-        end
-        def party_address=(_)
+          params(
+            party_address: T.nilable(
+              T.any(ModernTreasury::Models::Counterparty::Account::PartyAddress, ModernTreasury::Internal::AnyHash)
+            )
+          )
+            .void
         end
+        attr_writer :party_address
 
+        # The legal name of the entity which owns the account.
         sig { returns(T.nilable(String)) }
-        def party_name
-        end
-
-        sig { params(_: String).returns(String) }
-        def party_name=(_)
-        end
+        attr_reader :party_name
 
-        sig { returns(T.nilable(Symbol)) }
-        def party_type
-        end
+        sig { params(party_name: String).void }
+        attr_writer :party_name
 
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def party_type=(_)
-        end
+        # Either `individual` or `business`.
+        sig { returns(T.nilable(ModernTreasury::Models::Counterparty::Account::PartyType::TaggedSymbol)) }
+        attr_accessor :party_type
 
         sig { returns(T.nilable(T::Array[ModernTreasury::Models::RoutingDetail])) }
-        def routing_details
-        end
+        attr_reader :routing_details
 
         sig do
-          params(_: T::Array[ModernTreasury::Models::RoutingDetail])
-            .returns(T::Array[ModernTreasury::Models::RoutingDetail])
-        end
-        def routing_details=(_)
+          params(
+            routing_details: T::Array[T.any(ModernTreasury::Models::RoutingDetail, ModernTreasury::Internal::AnyHash)]
+          )
+            .void
         end
+        attr_writer :routing_details
 
         sig { returns(T.nilable(Time)) }
-        def updated_at
-        end
+        attr_reader :updated_at
 
-        sig { params(_: Time).returns(Time) }
-        def updated_at=(_)
-        end
-
-        sig { returns(T.nilable(Symbol)) }
-        def verification_source
-        end
+        sig { params(updated_at: Time).void }
+        attr_writer :updated_at
 
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def verification_source=(_)
-        end
+        sig { returns(T.nilable(ModernTreasury::Models::Counterparty::Account::VerificationSource::TaggedSymbol)) }
+        attr_accessor :verification_source
 
-        sig { returns(T.nilable(Symbol)) }
-        def verification_status
-        end
+        sig { returns(T.nilable(ModernTreasury::Models::Counterparty::Account::VerificationStatus::TaggedSymbol)) }
+        attr_reader :verification_status
 
-        sig { params(_: Symbol).returns(Symbol) }
-        def verification_status=(_)
+        sig do
+          params(verification_status: ModernTreasury::Models::Counterparty::Account::VerificationStatus::OrSymbol)
+            .void
         end
+        attr_writer :verification_status
 
         sig do
           params(
             id: String,
-            account_details: T::Array[ModernTreasury::Models::AccountDetail],
-            account_type: Symbol,
-            contact_details: T::Array[ModernTreasury::Models::Counterparty::Account::ContactDetail],
+            account_details: T::Array[T.any(ModernTreasury::Models::AccountDetail, ModernTreasury::Internal::AnyHash)],
+            account_type: ModernTreasury::Models::ExternalAccountType::OrSymbol,
+            contact_details: T::Array[T.any(ModernTreasury::Models::Counterparty::Account::ContactDetail, ModernTreasury::Internal::AnyHash)],
             created_at: Time,
             discarded_at: T.nilable(Time),
             ledger_account_id: T.nilable(String),
@@ -338,17 +252,19 @@ module ModernTreasury
             metadata: T::Hash[Symbol, String],
             name: T.nilable(String),
             object: String,
-            party_address: T.nilable(ModernTreasury::Models::Counterparty::Account::PartyAddress),
+            party_address: T.nilable(
+              T.any(ModernTreasury::Models::Counterparty::Account::PartyAddress, ModernTreasury::Internal::AnyHash)
+            ),
             party_name: String,
-            party_type: T.nilable(Symbol),
-            routing_details: T::Array[ModernTreasury::Models::RoutingDetail],
+            party_type: T.nilable(ModernTreasury::Models::Counterparty::Account::PartyType::OrSymbol),
+            routing_details: T::Array[T.any(ModernTreasury::Models::RoutingDetail, ModernTreasury::Internal::AnyHash)],
             updated_at: Time,
-            verification_source: T.nilable(Symbol),
-            verification_status: Symbol
+            verification_source: T.nilable(ModernTreasury::Models::Counterparty::Account::VerificationSource::OrSymbol),
+            verification_status: ModernTreasury::Models::Counterparty::Account::VerificationStatus::OrSymbol
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           id: nil,
           account_details: nil,
           account_type: nil,
@@ -367,16 +283,14 @@ module ModernTreasury
           updated_at: nil,
           verification_source: nil,
           verification_status: nil
-        )
-        end
-
+        ); end
         sig do
           override
             .returns(
               {
                 id: String,
                 account_details: T::Array[ModernTreasury::Models::AccountDetail],
-                account_type: Symbol,
+                account_type: ModernTreasury::Models::ExternalAccountType::TaggedSymbol,
                 contact_details: T::Array[ModernTreasury::Models::Counterparty::Account::ContactDetail],
                 created_at: Time,
                 discarded_at: T.nilable(Time),
@@ -387,96 +301,57 @@ module ModernTreasury
                 object: String,
                 party_address: T.nilable(ModernTreasury::Models::Counterparty::Account::PartyAddress),
                 party_name: String,
-                party_type: T.nilable(Symbol),
+                party_type: T.nilable(ModernTreasury::Models::Counterparty::Account::PartyType::TaggedSymbol),
                 routing_details: T::Array[ModernTreasury::Models::RoutingDetail],
                 updated_at: Time,
-                verification_source: T.nilable(Symbol),
-                verification_status: Symbol
+                verification_source: T.nilable(ModernTreasury::Models::Counterparty::Account::VerificationSource::TaggedSymbol),
+                verification_status: ModernTreasury::Models::Counterparty::Account::VerificationStatus::TaggedSymbol
               }
             )
         end
-        def to_hash
-        end
+        def to_hash; end
 
-        class ContactDetail < ModernTreasury::BaseModel
+        class ContactDetail < ModernTreasury::Internal::Type::BaseModel
           sig { returns(String) }
-          def id
-          end
-
-          sig { params(_: String).returns(String) }
-          def id=(_)
-          end
+          attr_accessor :id
 
           sig { returns(String) }
-          def contact_identifier
-          end
+          attr_accessor :contact_identifier
 
-          sig { params(_: String).returns(String) }
-          def contact_identifier=(_)
-          end
-
-          sig { returns(Symbol) }
-          def contact_identifier_type
-          end
-
-          sig { params(_: Symbol).returns(Symbol) }
-          def contact_identifier_type=(_)
-          end
+          sig { returns(ModernTreasury::Models::Counterparty::Account::ContactDetail::ContactIdentifierType::TaggedSymbol) }
+          attr_accessor :contact_identifier_type
 
           sig { returns(Time) }
-          def created_at
-          end
-
-          sig { params(_: Time).returns(Time) }
-          def created_at=(_)
-          end
+          attr_accessor :created_at
 
           sig { returns(T.nilable(Time)) }
-          def discarded_at
-          end
-
-          sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-          def discarded_at=(_)
-          end
+          attr_accessor :discarded_at
 
+          # This field will be true if this object exists in the live environment or false
+          # if it exists in the test environment.
           sig { returns(T::Boolean) }
-          def live_mode
-          end
-
-          sig { params(_: T::Boolean).returns(T::Boolean) }
-          def live_mode=(_)
-          end
+          attr_accessor :live_mode
 
           sig { returns(String) }
-          def object
-          end
-
-          sig { params(_: String).returns(String) }
-          def object=(_)
-          end
+          attr_accessor :object
 
           sig { returns(Time) }
-          def updated_at
-          end
-
-          sig { params(_: Time).returns(Time) }
-          def updated_at=(_)
-          end
+          attr_accessor :updated_at
 
           sig do
             params(
               id: String,
               contact_identifier: String,
-              contact_identifier_type: Symbol,
+              contact_identifier_type: ModernTreasury::Models::Counterparty::Account::ContactDetail::ContactIdentifierType::OrSymbol,
               created_at: Time,
               discarded_at: T.nilable(Time),
               live_mode: T::Boolean,
               object: String,
               updated_at: Time
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(
+          def self.new(
             id:,
             contact_identifier:,
             contact_identifier_type:,
@@ -485,16 +360,14 @@ module ModernTreasury
             live_mode:,
             object:,
             updated_at:
-          )
-          end
-
+          ); end
           sig do
             override
               .returns(
                 {
                   id: String,
                   contact_identifier: String,
-                  contact_identifier_type: Symbol,
+                  contact_identifier_type: ModernTreasury::Models::Counterparty::Account::ContactDetail::ContactIdentifierType::TaggedSymbol,
                   created_at: Time,
                   discarded_at: T.nilable(Time),
                   live_mode: T::Boolean,
@@ -503,111 +376,89 @@ module ModernTreasury
                 }
               )
           end
-          def to_hash
-          end
-
-          class ContactIdentifierType < ModernTreasury::Enum
-            abstract!
-
-            EMAIL = :email
-            PHONE_NUMBER = :phone_number
-            WEBSITE = :website
+          def to_hash; end
+
+          module ContactIdentifierType
+            extend ModernTreasury::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, ModernTreasury::Models::Counterparty::Account::ContactDetail::ContactIdentifierType) }
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  String,
+                  ModernTreasury::Models::Counterparty::Account::ContactDetail::ContactIdentifierType::TaggedSymbol
+                )
+              end
+
+            EMAIL =
+              T.let(
+                :email,
+                ModernTreasury::Models::Counterparty::Account::ContactDetail::ContactIdentifierType::TaggedSymbol
+              )
+            PHONE_NUMBER =
+              T.let(
+                :phone_number,
+                ModernTreasury::Models::Counterparty::Account::ContactDetail::ContactIdentifierType::TaggedSymbol
+              )
+            WEBSITE =
+              T.let(
+                :website,
+                ModernTreasury::Models::Counterparty::Account::ContactDetail::ContactIdentifierType::TaggedSymbol
+              )
 
-            sig { override.returns(T::Array[Symbol]) }
-            def self.values
+            sig do
+              override
+                .returns(
+                  T::Array[ModernTreasury::Models::Counterparty::Account::ContactDetail::ContactIdentifierType::TaggedSymbol]
+                )
             end
+            def self.values; end
           end
         end
 
-        class PartyAddress < ModernTreasury::BaseModel
+        class PartyAddress < ModernTreasury::Internal::Type::BaseModel
           sig { returns(String) }
-          def id
-          end
-
-          sig { params(_: String).returns(String) }
-          def id=(_)
-          end
+          attr_accessor :id
 
+          # Country code conforms to [ISO 3166-1 alpha-2]
           sig { returns(T.nilable(String)) }
-          def country
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def country=(_)
-          end
+          attr_accessor :country
 
           sig { returns(Time) }
-          def created_at
-          end
-
-          sig { params(_: Time).returns(Time) }
-          def created_at=(_)
-          end
+          attr_accessor :created_at
 
           sig { returns(T.nilable(String)) }
-          def line1
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def line1=(_)
-          end
+          attr_accessor :line1
 
           sig { returns(T.nilable(String)) }
-          def line2
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def line2=(_)
-          end
+          attr_accessor :line2
 
+          # This field will be true if this object exists in the live environment or false
+          # if it exists in the test environment.
           sig { returns(T::Boolean) }
-          def live_mode
-          end
-
-          sig { params(_: T::Boolean).returns(T::Boolean) }
-          def live_mode=(_)
-          end
+          attr_accessor :live_mode
 
+          # Locality or City.
           sig { returns(T.nilable(String)) }
-          def locality
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def locality=(_)
-          end
+          attr_accessor :locality
 
           sig { returns(String) }
-          def object
-          end
-
-          sig { params(_: String).returns(String) }
-          def object=(_)
-          end
+          attr_accessor :object
 
+          # The postal code of the address.
           sig { returns(T.nilable(String)) }
-          def postal_code
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def postal_code=(_)
-          end
+          attr_accessor :postal_code
 
+          # Region or State.
           sig { returns(T.nilable(String)) }
-          def region
-          end
-
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def region=(_)
-          end
+          attr_accessor :region
 
           sig { returns(Time) }
-          def updated_at
-          end
-
-          sig { params(_: Time).returns(Time) }
-          def updated_at=(_)
-          end
+          attr_accessor :updated_at
 
+          # The address associated with the owner or `null`.
           sig do
             params(
               id: String,
@@ -622,9 +473,9 @@ module ModernTreasury
               region: T.nilable(String),
               updated_at: Time
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(
+          def self.new(
             id:,
             country:,
             created_at:,
@@ -636,9 +487,7 @@ module ModernTreasury
             postal_code:,
             region:,
             updated_at:
-          )
-          end
-
+          ); end
           sig do
             override
               .returns(
@@ -657,57 +506,85 @@ module ModernTreasury
                 }
               )
           end
-          def to_hash
-          end
+          def to_hash; end
         end
 
-        class PartyType < ModernTreasury::Enum
-          abstract!
+        # Either `individual` or `business`.
+        module PartyType
+          extend ModernTreasury::Internal::Type::Enum
 
-          BUSINESS = T.let(:business, T.nilable(Symbol))
-          INDIVIDUAL = T.let(:individual, T.nilable(Symbol))
+          TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::Counterparty::Account::PartyType) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, String, ModernTreasury::Models::Counterparty::Account::PartyType::TaggedSymbol) }
 
-          sig { override.returns(T::Array[Symbol]) }
-          def self.values
-          end
+          BUSINESS = T.let(:business, ModernTreasury::Models::Counterparty::Account::PartyType::TaggedSymbol)
+          INDIVIDUAL = T.let(:individual, ModernTreasury::Models::Counterparty::Account::PartyType::TaggedSymbol)
+
+          sig { override.returns(T::Array[ModernTreasury::Models::Counterparty::Account::PartyType::TaggedSymbol]) }
+          def self.values; end
         end
 
-        class VerificationSource < ModernTreasury::Enum
-          abstract!
+        module VerificationSource
+          extend ModernTreasury::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, ModernTreasury::Models::Counterparty::Account::VerificationSource) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, String, ModernTreasury::Models::Counterparty::Account::VerificationSource::TaggedSymbol) }
 
-          ACH_PRENOTE = T.let(:ach_prenote, T.nilable(Symbol))
-          MICRODEPOSITS = T.let(:microdeposits, T.nilable(Symbol))
-          PLAID = T.let(:plaid, T.nilable(Symbol))
+          ACH_PRENOTE =
+            T.let(:ach_prenote, ModernTreasury::Models::Counterparty::Account::VerificationSource::TaggedSymbol)
+          MICRODEPOSITS =
+            T.let(:microdeposits, ModernTreasury::Models::Counterparty::Account::VerificationSource::TaggedSymbol)
+          PLAID = T.let(:plaid, ModernTreasury::Models::Counterparty::Account::VerificationSource::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
-          def self.values
+          sig do
+            override.returns(T::Array[ModernTreasury::Models::Counterparty::Account::VerificationSource::TaggedSymbol])
           end
+          def self.values; end
         end
 
-        class VerificationStatus < ModernTreasury::Enum
-          abstract!
+        module VerificationStatus
+          extend ModernTreasury::Internal::Type::Enum
 
-          PENDING_VERIFICATION = :pending_verification
-          UNVERIFIED = :unverified
-          VERIFIED = :verified
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, ModernTreasury::Models::Counterparty::Account::VerificationStatus) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, String, ModernTreasury::Models::Counterparty::Account::VerificationStatus::TaggedSymbol) }
 
-          sig { override.returns(T::Array[Symbol]) }
-          def self.values
+          PENDING_VERIFICATION =
+            T.let(
+              :pending_verification,
+              ModernTreasury::Models::Counterparty::Account::VerificationStatus::TaggedSymbol
+            )
+          UNVERIFIED =
+            T.let(:unverified, ModernTreasury::Models::Counterparty::Account::VerificationStatus::TaggedSymbol)
+          VERIFIED =
+            T.let(:verified, ModernTreasury::Models::Counterparty::Account::VerificationStatus::TaggedSymbol)
+
+          sig do
+            override.returns(T::Array[ModernTreasury::Models::Counterparty::Account::VerificationStatus::TaggedSymbol])
           end
+          def self.values; end
         end
       end
 
-      class VerificationStatus < ModernTreasury::Enum
-        abstract!
+      # The verification status of the counterparty.
+      module VerificationStatus
+        extend ModernTreasury::Internal::Type::Enum
 
-        DENIED = :denied
-        NEEDS_APPROVAL = :needs_approval
-        UNVERIFIED = :unverified
-        VERIFIED = :verified
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::Counterparty::VerificationStatus) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::Counterparty::VerificationStatus::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        DENIED = T.let(:denied, ModernTreasury::Models::Counterparty::VerificationStatus::TaggedSymbol)
+        NEEDS_APPROVAL =
+          T.let(:needs_approval, ModernTreasury::Models::Counterparty::VerificationStatus::TaggedSymbol)
+        UNVERIFIED = T.let(:unverified, ModernTreasury::Models::Counterparty::VerificationStatus::TaggedSymbol)
+        VERIFIED = T.let(:verified, ModernTreasury::Models::Counterparty::VerificationStatus::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::Counterparty::VerificationStatus::TaggedSymbol]) }
+        def self.values; end
       end
     end
   end