modern_treasury 0.1.0.pre.alpha.15 → 0.1.0.pre.alpha.16

data/rbi/lib/modern_treasury/models/external_account_delete_params.rbi

@@ -6,8 +6,11 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { params(request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])).void }
-      def initialize(request_options: {})
+      sig do
+        params(request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
+          .returns(T.attached_class)
+      end
+      def self.new(request_options: {})
       end
 
       sig { override.returns({request_options: ModernTreasury::RequestOptions}) }

data/rbi/lib/modern_treasury/models/external_account_list_params.rbi

@@ -7,44 +7,35 @@ module ModernTreasury
       include ModernTreasury::RequestParameters
 
       sig { returns(T.nilable(String)) }
-      def after_cursor
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def after_cursor=(_)
-      end
+      attr_accessor :after_cursor
 
       sig { returns(T.nilable(String)) }
-      def counterparty_id
-      end
+      attr_reader :counterparty_id
 
-      sig { params(_: String).returns(String) }
-      def counterparty_id=(_)
-      end
+      sig { params(counterparty_id: String).void }
+      attr_writer :counterparty_id
 
+      # For example, if you want to query for records with metadata key `Type` and value
+      #   `Loan`, the query would be `metadata%5BType%5D=Loan`. This encodes the query
+      #   parameters.
       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
 
+      # Searches the ExternalAccount's party_name AND the Counterparty's party_name
       sig { returns(T.nilable(String)) }
-      def party_name
-      end
+      attr_reader :party_name
 
-      sig { params(_: String).returns(String) }
-      def party_name=(_)
-      end
+      sig { params(party_name: String).void }
+      attr_writer :party_name
 
       sig { returns(T.nilable(Integer)) }
-      def per_page
-      end
+      attr_reader :per_page
 
-      sig { params(_: Integer).returns(Integer) }
-      def per_page=(_)
-      end
+      sig { params(per_page: Integer).void }
+      attr_writer :per_page
 
       sig do
         params(
@@ -53,11 +44,11 @@ module ModernTreasury
           metadata: T::Hash[Symbol, String],
           party_name: String,
           per_page: Integer,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         after_cursor: nil,
         counterparty_id: nil,
         metadata: nil,

data/rbi/lib/modern_treasury/models/external_account_retrieve_params.rbi

@@ -6,8 +6,11 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { params(request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])).void }
-      def initialize(request_options: {})
+      sig do
+        params(request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
+          .returns(T.attached_class)
+      end
+      def self.new(request_options: {})
       end
 
       sig { override.returns({request_options: ModernTreasury::RequestOptions}) }

data/rbi/lib/modern_treasury/models/external_account_type.rbi

@@ -2,19 +2,23 @@
 
 module ModernTreasury
   module Models
-    class ExternalAccountType < ModernTreasury::Enum
-      abstract!
+    # Can be `checking`, `savings` or `other`.
+    module ExternalAccountType
+      extend ModernTreasury::Enum
 
-      CASH = :cash
-      CHECKING = :checking
-      GENERAL_LEDGER = :general_ledger
-      LOAN = :loan
-      NON_RESIDENT = :non_resident
-      OTHER = :other
-      OVERDRAFT = :overdraft
-      SAVINGS = :savings
+      TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::ExternalAccountType) }
+      OrSymbol = T.type_alias { T.any(Symbol, ModernTreasury::Models::ExternalAccountType::TaggedSymbol) }
 
-      sig { override.returns(T::Array[Symbol]) }
+      CASH = T.let(:cash, ModernTreasury::Models::ExternalAccountType::TaggedSymbol)
+      CHECKING = T.let(:checking, ModernTreasury::Models::ExternalAccountType::TaggedSymbol)
+      GENERAL_LEDGER = T.let(:general_ledger, ModernTreasury::Models::ExternalAccountType::TaggedSymbol)
+      LOAN = T.let(:loan, ModernTreasury::Models::ExternalAccountType::TaggedSymbol)
+      NON_RESIDENT = T.let(:non_resident, ModernTreasury::Models::ExternalAccountType::TaggedSymbol)
+      OTHER = T.let(:other, ModernTreasury::Models::ExternalAccountType::TaggedSymbol)
+      OVERDRAFT = T.let(:overdraft, ModernTreasury::Models::ExternalAccountType::TaggedSymbol)
+      SAVINGS = T.let(:savings, ModernTreasury::Models::ExternalAccountType::TaggedSymbol)
+
+      sig { override.returns(T::Array[ModernTreasury::Models::ExternalAccountType::TaggedSymbol]) }
       def self.values
       end
     end

data/rbi/lib/modern_treasury/models/external_account_update_params.rbi

@@ -6,79 +6,65 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { returns(T.nilable(Symbol)) }
-      def account_type
-      end
+      # Can be `checking`, `savings` or `other`.
+      sig { returns(T.nilable(ModernTreasury::Models::ExternalAccountType::OrSymbol)) }
+      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(String)) }
-      def counterparty_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def counterparty_id=(_)
-      end
+      attr_accessor :counterparty_id
 
+      # Additional data in the form of key-value pairs. Pairs can be removed by passing
+      #   an empty string or `null` as the value.
       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(ModernTreasury::Models::ExternalAccountUpdateParams::PartyAddress)) }
-      def party_address
-      end
+      attr_reader :party_address
 
       sig do
-        params(_: ModernTreasury::Models::ExternalAccountUpdateParams::PartyAddress)
-          .returns(ModernTreasury::Models::ExternalAccountUpdateParams::PartyAddress)
-      end
-      def party_address=(_)
+        params(
+          party_address: T.any(ModernTreasury::Models::ExternalAccountUpdateParams::PartyAddress, ModernTreasury::Util::AnyHash)
+        )
+          .void
       end
+      attr_writer :party_address
 
+      # If this value isn't provided, it will be inherited from the counterparty's name.
       sig { returns(T.nilable(String)) }
-      def party_name
-      end
+      attr_reader :party_name
 
-      sig { params(_: String).returns(String) }
-      def party_name=(_)
-      end
+      sig { params(party_name: String).void }
+      attr_writer :party_name
 
-      sig { returns(T.nilable(Symbol)) }
-      def party_type
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def party_type=(_)
-      end
+      # Either `individual` or `business`.
+      sig { returns(T.nilable(ModernTreasury::Models::ExternalAccountUpdateParams::PartyType::OrSymbol)) }
+      attr_accessor :party_type
 
       sig do
         params(
-          account_type: Symbol,
+          account_type: ModernTreasury::Models::ExternalAccountType::OrSymbol,
           counterparty_id: T.nilable(String),
           metadata: T::Hash[Symbol, String],
           name: T.nilable(String),
-          party_address: ModernTreasury::Models::ExternalAccountUpdateParams::PartyAddress,
+          party_address: T.any(ModernTreasury::Models::ExternalAccountUpdateParams::PartyAddress, ModernTreasury::Util::AnyHash),
           party_name: String,
-          party_type: T.nilable(Symbol),
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          party_type: T.nilable(ModernTreasury::Models::ExternalAccountUpdateParams::PartyType::OrSymbol),
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         account_type: nil,
         counterparty_id: nil,
         metadata: nil,
@@ -94,13 +80,13 @@ module ModernTreasury
         override
           .returns(
             {
-              account_type: Symbol,
+              account_type: ModernTreasury::Models::ExternalAccountType::OrSymbol,
               counterparty_id: T.nilable(String),
               metadata: T::Hash[Symbol, String],
               name: T.nilable(String),
               party_address: ModernTreasury::Models::ExternalAccountUpdateParams::PartyAddress,
               party_name: String,
-              party_type: T.nilable(Symbol),
+              party_type: T.nilable(ModernTreasury::Models::ExternalAccountUpdateParams::PartyType::OrSymbol),
               request_options: ModernTreasury::RequestOptions
             }
           )
@@ -109,53 +95,27 @@ module ModernTreasury
       end
 
       class PartyAddress < ModernTreasury::BaseModel
+        # 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(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
 
+        # 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
 
+        # 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 do
           params(
@@ -166,9 +126,9 @@ module ModernTreasury
             postal_code: T.nilable(String),
             region: T.nilable(String)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(country: nil, line1: nil, line2: nil, locality: nil, postal_code: nil, region: nil)
+        def self.new(country: nil, line1: nil, line2: nil, locality: nil, postal_code: nil, region: nil)
         end
 
         sig do
@@ -188,13 +148,20 @@ module ModernTreasury
         end
       end
 
-      class PartyType < ModernTreasury::Enum
-        abstract!
+      # Either `individual` or `business`.
+      module PartyType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::ExternalAccountUpdateParams::PartyType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::ExternalAccountUpdateParams::PartyType::TaggedSymbol) }
 
-        BUSINESS = T.let(:business, T.nilable(Symbol))
-        INDIVIDUAL = T.let(:individual, T.nilable(Symbol))
+        BUSINESS = T.let(:business, ModernTreasury::Models::ExternalAccountUpdateParams::PartyType::TaggedSymbol)
+        INDIVIDUAL =
+          T.let(:individual, ModernTreasury::Models::ExternalAccountUpdateParams::PartyType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::ExternalAccountUpdateParams::PartyType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/external_account_verify_params.rbi

@@ -6,58 +6,51 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # The ID of the internal account where the micro-deposits originate from. Both
+      #   credit and debit capabilities must be enabled.
       sig { returns(String) }
-      def originating_account_id
-      end
+      attr_accessor :originating_account_id
 
-      sig { params(_: String).returns(String) }
-      def originating_account_id=(_)
-      end
+      # Can be `ach`, `eft`, or `rtp`.
+      sig { returns(ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::OrSymbol) }
+      attr_accessor :payment_type
 
-      sig { returns(Symbol) }
-      def payment_type
-      end
+      # Defaults to the currency of the originating account.
+      sig { returns(T.nilable(ModernTreasury::Models::Currency::OrSymbol)) }
+      attr_reader :currency
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def payment_type=(_)
-      end
+      sig { params(currency: ModernTreasury::Models::Currency::OrSymbol).void }
+      attr_writer :currency
 
-      sig { returns(T.nilable(Symbol)) }
-      def currency
-      end
+      # A payment type to fallback to if the original type is not valid for the
+      #   receiving account. Currently, this only supports falling back from RTP to ACH
+      #   (payment_type=rtp and fallback_type=ach)
+      sig { returns(T.nilable(ModernTreasury::Models::ExternalAccountVerifyParams::FallbackType::OrSymbol)) }
+      attr_reader :fallback_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def currency=(_)
-      end
+      sig { params(fallback_type: ModernTreasury::Models::ExternalAccountVerifyParams::FallbackType::OrSymbol).void }
+      attr_writer :fallback_type
 
-      sig { returns(T.nilable(Symbol)) }
-      def fallback_type
-      end
+      # Either `normal` or `high`. For ACH payments, `high` represents a same-day ACH
+      #   transfer. This will apply to both `payment_type` and `fallback_type`.
+      sig { returns(T.nilable(ModernTreasury::Models::ExternalAccountVerifyParams::Priority::OrSymbol)) }
+      attr_reader :priority
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def fallback_type=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def priority
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def priority=(_)
-      end
+      sig { params(priority: ModernTreasury::Models::ExternalAccountVerifyParams::Priority::OrSymbol).void }
+      attr_writer :priority
 
       sig do
         params(
           originating_account_id: String,
-          payment_type: Symbol,
-          currency: Symbol,
-          fallback_type: Symbol,
-          priority: Symbol,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          payment_type: ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::OrSymbol,
+          currency: ModernTreasury::Models::Currency::OrSymbol,
+          fallback_type: ModernTreasury::Models::ExternalAccountVerifyParams::FallbackType::OrSymbol,
+          priority: ModernTreasury::Models::ExternalAccountVerifyParams::Priority::OrSymbol,
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         originating_account_id:,
         payment_type:,
         currency: nil,
@@ -72,10 +65,10 @@ module ModernTreasury
           .returns(
             {
               originating_account_id: String,
-              payment_type: Symbol,
-              currency: Symbol,
-              fallback_type: Symbol,
-              priority: Symbol,
+              payment_type: ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::OrSymbol,
+              currency: ModernTreasury::Models::Currency::OrSymbol,
+              fallback_type: ModernTreasury::Models::ExternalAccountVerifyParams::FallbackType::OrSymbol,
+              priority: ModernTreasury::Models::ExternalAccountVerifyParams::Priority::OrSymbol,
               request_options: ModernTreasury::RequestOptions
             }
           )
@@ -83,62 +76,89 @@ module ModernTreasury
       def to_hash
       end
 
-      class PaymentType < ModernTreasury::Enum
-        abstract!
-
-        ACH = :ach
-        AU_BECS = :au_becs
-        BACS = :bacs
-        BOOK = :book
-        CARD = :card
-        CHATS = :chats
-        CHECK = :check
-        CROSS_BORDER = :cross_border
-        DK_NETS = :dk_nets
-        EFT = :eft
-        HU_ICS = :hu_ics
-        INTERAC = :interac
-        MASAV = :masav
-        MX_CCEN = :mx_ccen
-        NEFT = :neft
-        NICS = :nics
-        NZ_BECS = :nz_becs
-        PL_ELIXIR = :pl_elixir
-        PROVXCHANGE = :provxchange
-        RO_SENT = :ro_sent
-        RTP = :rtp
-        SE_BANKGIROT = :se_bankgirot
-        SEN = :sen
-        SEPA = :sepa
-        SG_GIRO = :sg_giro
-        SIC = :sic
-        SIGNET = :signet
-        SKNBI = :sknbi
-        WIRE = :wire
-        ZENGIN = :zengin
-
-        sig { override.returns(T::Array[Symbol]) }
+      # Can be `ach`, `eft`, or `rtp`.
+      module PaymentType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol) }
+
+        ACH = T.let(:ach, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        AU_BECS = T.let(:au_becs, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        BACS = T.let(:bacs, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        BOOK = T.let(:book, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        CARD = T.let(:card, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        CHATS = T.let(:chats, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        CHECK = T.let(:check, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        CROSS_BORDER =
+          T.let(:cross_border, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        DK_NETS = T.let(:dk_nets, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        EFT = T.let(:eft, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        HU_ICS = T.let(:hu_ics, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        INTERAC = T.let(:interac, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        MASAV = T.let(:masav, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        MX_CCEN = T.let(:mx_ccen, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        NEFT = T.let(:neft, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        NICS = T.let(:nics, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        NZ_BECS = T.let(:nz_becs, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        PL_ELIXIR =
+          T.let(:pl_elixir, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        PROVXCHANGE =
+          T.let(:provxchange, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        RO_SENT = T.let(:ro_sent, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        RTP = T.let(:rtp, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        SE_BANKGIROT =
+          T.let(:se_bankgirot, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        SEN = T.let(:sen, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        SEPA = T.let(:sepa, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        SG_GIRO = T.let(:sg_giro, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        SIC = T.let(:sic, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        SIGNET = T.let(:signet, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        SKNBI = T.let(:sknbi, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        WIRE = T.let(:wire, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+        ZENGIN = T.let(:zengin, ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::TaggedSymbol]) }
         def self.values
         end
       end
 
-      class FallbackType < ModernTreasury::Enum
-        abstract!
+      # A payment type to fallback to if the original type is not valid for the
+      #   receiving account. Currently, this only supports falling back from RTP to ACH
+      #   (payment_type=rtp and fallback_type=ach)
+      module FallbackType
+        extend ModernTreasury::Enum
 
-        ACH = :ach
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::ExternalAccountVerifyParams::FallbackType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::ExternalAccountVerifyParams::FallbackType::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
+        ACH = T.let(:ach, ModernTreasury::Models::ExternalAccountVerifyParams::FallbackType::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[ModernTreasury::Models::ExternalAccountVerifyParams::FallbackType::TaggedSymbol])
+        end
         def self.values
         end
       end
 
-      class Priority < ModernTreasury::Enum
-        abstract!
+      # Either `normal` or `high`. For ACH payments, `high` represents a same-day ACH
+      #   transfer. This will apply to both `payment_type` and `fallback_type`.
+      module Priority
+        extend ModernTreasury::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::ExternalAccountVerifyParams::Priority) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::ExternalAccountVerifyParams::Priority::TaggedSymbol) }
 
-        HIGH = :high
-        NORMAL = :normal
+        HIGH = T.let(:high, ModernTreasury::Models::ExternalAccountVerifyParams::Priority::TaggedSymbol)
+        NORMAL = T.let(:normal, ModernTreasury::Models::ExternalAccountVerifyParams::Priority::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::ExternalAccountVerifyParams::Priority::TaggedSymbol]) }
         def self.values
         end
       end