RubyGems - modern_treasury - Versions diffs - 0.1.0.pre.alpha.15 → 0.1.0.pre.alpha.16 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (711) hide show

data/rbi/lib/modern_treasury/models/payment_order_create_async_params.rbi CHANGED Viewed

@@ -6,340 +6,314 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
+      # Value in specified currency's smallest unit. e.g. $10 would be represented as
+      #   1000 (cents). For RTP, the maximum amount allowed by the network is $100,000.
       sig { returns(Integer) }
-      def amount
-      end
-      sig { params(_: Integer).returns(Integer) }
-      def amount=(_)
-      end
-      sig { returns(Symbol) }
-      def direction
-      end
+      attr_accessor :amount
-      sig { params(_: Symbol).returns(Symbol) }
-      def direction=(_)
-      end
+      # One of `credit`, `debit`. Describes the direction money is flowing in the
+      #   transaction. A `credit` moves money from your account to someone else's. A
+      #   `debit` pulls money from someone else's account to your own. Note that wire,
+      #   rtp, and check payments will always be `credit`.
+      sig { returns(ModernTreasury::Models::PaymentOrderCreateAsyncParams::Direction::OrSymbol) }
+      attr_accessor :direction
+      # The ID of one of your organization's internal accounts.
       sig { returns(String) }
-      def originating_account_id
-      end
-      sig { params(_: String).returns(String) }
-      def originating_account_id=(_)
-      end
-      sig { returns(Symbol) }
-      def type
-      end
+      attr_accessor :originating_account_id
-      sig { params(_: Symbol).returns(Symbol) }
-      def type=(_)
-      end
+      # One of `ach`, `se_bankgirot`, `eft`, `wire`, `check`, `sen`, `book`, `rtp`,
+      #   `sepa`, `bacs`, `au_becs`, `interac`, `neft`, `nics`,
+      #   `nz_national_clearing_code`, `sic`, `signet`, `provexchange`, `zengin`.
+      sig { returns(ModernTreasury::Models::PaymentOrderType::OrSymbol) }
+      attr_accessor :type
       sig { returns(T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::Accounting)) }
-      def accounting
-      end
+      attr_reader :accounting
       sig do
-        params(_: ModernTreasury::Models::PaymentOrderCreateAsyncParams::Accounting)
-          .returns(ModernTreasury::Models::PaymentOrderCreateAsyncParams::Accounting)
-      end
-      def accounting=(_)
+        params(
+          accounting: T.any(ModernTreasury::Models::PaymentOrderCreateAsyncParams::Accounting, ModernTreasury::Util::AnyHash)
+        )
+          .void
       end
+      attr_writer :accounting
+      # The ID of one of your accounting categories. Note that these will only be
+      #   accessible if your accounting system has been connected.
       sig { returns(T.nilable(String)) }
-      def accounting_category_id
-      end
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def accounting_category_id=(_)
-      end
+      attr_accessor :accounting_category_id
+      # The ID of one of your accounting ledger classes. Note that these will only be
+      #   accessible if your accounting system has been connected.
       sig { returns(T.nilable(String)) }
-      def accounting_ledger_class_id
-      end
+      attr_accessor :accounting_ledger_class_id
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def accounting_ledger_class_id=(_)
-      end
+      # The party that will pay the fees for the payment order. Only applies to wire
+      #   payment orders. Can be one of shared, sender, or receiver, which correspond
+      #   respectively with the SWIFT 71A values `SHA`, `OUR`, `BEN`.
+      sig { returns(T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ChargeBearer::OrSymbol)) }
+      attr_accessor :charge_bearer
-      sig { returns(T.nilable(Symbol)) }
-      def charge_bearer
-      end
+      # Defaults to the currency of the originating account.
+      sig { returns(T.nilable(ModernTreasury::Models::Currency::OrSymbol)) }
+      attr_reader :currency
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def charge_bearer=(_)
-      end
-      sig { returns(T.nilable(Symbol)) }
-      def currency
-      end
-      sig { params(_: Symbol).returns(Symbol) }
-      def currency=(_)
-      end
+      sig { params(currency: ModernTreasury::Models::Currency::OrSymbol).void }
+      attr_writer :currency
+      # An optional description for internal use.
       sig { returns(T.nilable(String)) }
-      def description
-      end
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def description=(_)
-      end
+      attr_accessor :description
+      # Date transactions are to be posted to the participants' account. Defaults to the
+      #   current business day or the next business day if the current day is a bank
+      #   holiday or weekend. Format: yyyy-mm-dd.
       sig { returns(T.nilable(Date)) }
-      def effective_date
-      end
+      attr_reader :effective_date
-      sig { params(_: Date).returns(Date) }
-      def effective_date=(_)
-      end
+      sig { params(effective_date: Date).void }
+      attr_writer :effective_date
+      # RFP payments require an expires_at. This value must be past the effective_date.
       sig { returns(T.nilable(Time)) }
-      def expires_at
-      end
-      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-      def expires_at=(_)
-      end
+      attr_accessor :expires_at
-      sig { returns(T.nilable(Symbol)) }
-      def fallback_type
-      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
+      #   (type=rtp and fallback_type=ach)
+      sig { returns(T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::FallbackType::OrSymbol)) }
+      attr_reader :fallback_type
-      sig { params(_: Symbol).returns(Symbol) }
-      def fallback_type=(_)
-      end
+      sig { params(fallback_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::FallbackType::OrSymbol).void }
+      attr_writer :fallback_type
+      # If present, indicates a specific foreign exchange contract number that has been
+      #   generated by your financial institution.
       sig { returns(T.nilable(String)) }
-      def foreign_exchange_contract
-      end
+      attr_accessor :foreign_exchange_contract
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def foreign_exchange_contract=(_)
-      end
-      sig { returns(T.nilable(Symbol)) }
-      def foreign_exchange_indicator
-      end
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def foreign_exchange_indicator=(_)
+      # Indicates the type of FX transfer to initiate, can be either
+      #   `variable_to_fixed`, `fixed_to_variable`, or `null` if the payment order
+      #   currency matches the originating account currency.
+      sig do
+        returns(
+          T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ForeignExchangeIndicator::OrSymbol)
+        )
       end
+      attr_accessor :foreign_exchange_indicator
+      # Specifies a ledger transaction object that will be created with the payment
+      #   order. If the ledger transaction cannot be created, then the payment order
+      #   creation will fail. The resulting ledger transaction will mirror the status of
+      #   the payment order.
       sig { returns(T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction)) }
-      def ledger_transaction
-      end
+      attr_reader :ledger_transaction
       sig do
-        params(_: ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction)
-          .returns(ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction)
-      end
-      def ledger_transaction=(_)
+        params(
+          ledger_transaction: T.any(
+            ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction,
+            ModernTreasury::Util::AnyHash
+          )
+        )
+          .void
       end
+      attr_writer :ledger_transaction
+      # Either ledger_transaction or ledger_transaction_id can be provided. Only a
+      #   pending ledger transaction can be attached upon payment order creation. Once the
+      #   payment order is created, the status of the ledger transaction tracks the
+      #   payment order automatically.
       sig { returns(T.nilable(String)) }
-      def ledger_transaction_id
-      end
+      attr_reader :ledger_transaction_id
-      sig { params(_: String).returns(String) }
-      def ledger_transaction_id=(_)
-      end
+      sig { params(ledger_transaction_id: String).void }
+      attr_writer :ledger_transaction_id
+      # An array of line items that must sum up to the amount of the payment order.
       sig { returns(T.nilable(T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::LineItem])) }
-      def line_items
-      end
+      attr_reader :line_items
       sig do
-        params(_: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::LineItem])
-          .returns(T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::LineItem])
-      end
-      def line_items=(_)
+        params(
+          line_items: T::Array[T.any(ModernTreasury::Models::PaymentOrderCreateAsyncParams::LineItem, ModernTreasury::Util::AnyHash)]
+        )
+          .void
       end
+      attr_writer :line_items
+      # 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 boolean to determine if NSF Protection is enabled for this payment order. Note
+      #   that this setting must also be turned on in your organization settings page.
       sig { returns(T.nilable(T::Boolean)) }
-      def nsf_protected
-      end
+      attr_reader :nsf_protected
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def nsf_protected=(_)
-      end
+      sig { params(nsf_protected: T::Boolean).void }
+      attr_writer :nsf_protected
+      # If present, this will replace your default company name on receiver's bank
+      #   statement. This field can only be used for ACH payments currently. For ACH, only
+      #   the first 16 characters of this string will be used. Any additional characters
+      #   will be truncated.
       sig { returns(T.nilable(String)) }
-      def originating_party_name
-      end
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def originating_party_name=(_)
-      end
-      sig { returns(T.nilable(Symbol)) }
-      def priority
-      end
-      sig { params(_: Symbol).returns(Symbol) }
-      def priority=(_)
-      end
+      attr_accessor :originating_party_name
+      # Either `normal` or `high`. For ACH and EFT payments, `high` represents a
+      #   same-day ACH or EFT transfer, respectively. For check payments, `high` can mean
+      #   an overnight check rather than standard mail.
+      sig { returns(T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::Priority::OrSymbol)) }
+      attr_reader :priority
+      sig { params(priority: ModernTreasury::Models::PaymentOrderCreateAsyncParams::Priority::OrSymbol).void }
+      attr_writer :priority
+      # If present, Modern Treasury will not process the payment until after this time.
+      #   If `process_after` is past the cutoff for `effective_date`, `process_after` will
+      #   take precedence and `effective_date` will automatically update to reflect the
+      #   earliest possible sending date after `process_after`. Format is ISO8601
+      #   timestamp.
       sig { returns(T.nilable(Time)) }
-      def process_after
-      end
-      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-      def process_after=(_)
-      end
+      attr_accessor :process_after
+      # For `wire`, this is usually the purpose which is transmitted via the
+      #   "InstrForDbtrAgt" field in the ISO20022 file. For `eft`, this field is the 3
+      #   digit CPA Code that will be attached to the payment.
       sig { returns(T.nilable(String)) }
-      def purpose
-      end
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def purpose=(_)
-      end
+      attr_accessor :purpose
+      # Either `receiving_account` or `receiving_account_id` must be present. When using
+      #   `receiving_account_id`, you may pass the id of an external account or an
+      #   internal account.
       sig { returns(T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount)) }
-      def receiving_account
-      end
+      attr_reader :receiving_account
       sig do
-        params(_: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount)
-          .returns(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount)
-      end
-      def receiving_account=(_)
+        params(
+          receiving_account: T.any(
+            ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount,
+            ModernTreasury::Util::AnyHash
+          )
+        )
+          .void
       end
+      attr_writer :receiving_account
+      # Either `receiving_account` or `receiving_account_id` must be present. When using
+      #   `receiving_account_id`, you may pass the id of an external account or an
+      #   internal account.
       sig { returns(T.nilable(String)) }
-      def receiving_account_id
-      end
+      attr_reader :receiving_account_id
-      sig { params(_: String).returns(String) }
-      def receiving_account_id=(_)
-      end
+      sig { params(receiving_account_id: String).void }
+      attr_writer :receiving_account_id
+      # For `ach`, this field will be passed through on an addenda record. For `wire`
+      #   payments the field will be passed through as the "Originator to Beneficiary
+      #   Information", also known as OBI or Fedwire tag 6000.
       sig { returns(T.nilable(String)) }
-      def remittance_information
-      end
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def remittance_information=(_)
-      end
+      attr_accessor :remittance_information
+      # Send an email to the counterparty when the payment order is sent to the bank. If
+      #   `null`, `send_remittance_advice` on the Counterparty is used.
       sig { returns(T.nilable(T::Boolean)) }
-      def send_remittance_advice
-      end
-      sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-      def send_remittance_advice=(_)
-      end
+      attr_accessor :send_remittance_advice
+      # An optional descriptor which will appear in the receiver's statement. For
+      #   `check` payments this field will be used as the memo line. For `ach` the maximum
+      #   length is 10 characters. Note that for ACH payments, the name on your bank
+      #   account will be included automatically by the bank, so you can use the
+      #   characters for other useful information. For `eft` the maximum length is 15
+      #   characters.
       sig { returns(T.nilable(String)) }
-      def statement_descriptor
-      end
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def statement_descriptor=(_)
-      end
-      sig { returns(T.nilable(Symbol)) }
-      def subtype
-      end
+      attr_accessor :statement_descriptor
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def subtype=(_)
-      end
+      # An additional layer of classification for the type of payment order you are
+      #   doing. This field is only used for `ach` payment orders currently. For `ach`
+      #   payment orders, the `subtype` represents the SEC code. We currently support
+      #   `CCD`, `PPD`, `IAT`, `CTX`, `WEB`, `CIE`, and `TEL`.
+      sig { returns(T.nilable(ModernTreasury::Models::PaymentOrderSubtype::OrSymbol)) }
+      attr_accessor :subtype
+      # A flag that determines whether a payment order should go through transaction
+      #   monitoring.
       sig { returns(T.nilable(T::Boolean)) }
-      def transaction_monitoring_enabled
-      end
+      attr_reader :transaction_monitoring_enabled
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def transaction_monitoring_enabled=(_)
-      end
+      sig { params(transaction_monitoring_enabled: T::Boolean).void }
+      attr_writer :transaction_monitoring_enabled
+      # Identifier of the ultimate originator of the payment order.
       sig { returns(T.nilable(String)) }
-      def ultimate_originating_party_identifier
-      end
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def ultimate_originating_party_identifier=(_)
-      end
+      attr_accessor :ultimate_originating_party_identifier
+      # Name of the ultimate originator of the payment order.
       sig { returns(T.nilable(String)) }
-      def ultimate_originating_party_name
-      end
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def ultimate_originating_party_name=(_)
-      end
+      attr_accessor :ultimate_originating_party_name
+      # Identifier of the ultimate funds recipient.
       sig { returns(T.nilable(String)) }
-      def ultimate_receiving_party_identifier
-      end
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def ultimate_receiving_party_identifier=(_)
-      end
+      attr_accessor :ultimate_receiving_party_identifier
+      # Name of the ultimate funds recipient.
       sig { returns(T.nilable(String)) }
-      def ultimate_receiving_party_name
-      end
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def ultimate_receiving_party_name=(_)
-      end
+      attr_accessor :ultimate_receiving_party_name
       sig do
         params(
           amount: Integer,
-          direction: Symbol,
+          direction: ModernTreasury::Models::PaymentOrderCreateAsyncParams::Direction::OrSymbol,
           originating_account_id: String,
-          type: Symbol,
-          accounting: ModernTreasury::Models::PaymentOrderCreateAsyncParams::Accounting,
+          type: ModernTreasury::Models::PaymentOrderType::OrSymbol,
+          accounting: T.any(ModernTreasury::Models::PaymentOrderCreateAsyncParams::Accounting, ModernTreasury::Util::AnyHash),
           accounting_category_id: T.nilable(String),
           accounting_ledger_class_id: T.nilable(String),
-          charge_bearer: T.nilable(Symbol),
-          currency: Symbol,
+          charge_bearer: T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ChargeBearer::OrSymbol),
+          currency: ModernTreasury::Models::Currency::OrSymbol,
           description: T.nilable(String),
           effective_date: Date,
           expires_at: T.nilable(Time),
-          fallback_type: Symbol,
+          fallback_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::FallbackType::OrSymbol,
           foreign_exchange_contract: T.nilable(String),
-          foreign_exchange_indicator: T.nilable(Symbol),
-          ledger_transaction: ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction,
+          foreign_exchange_indicator: T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ForeignExchangeIndicator::OrSymbol),
+          ledger_transaction: T.any(
+            ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction,
+            ModernTreasury::Util::AnyHash
+          ),
           ledger_transaction_id: String,
-          line_items: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::LineItem],
+          line_items: T::Array[T.any(ModernTreasury::Models::PaymentOrderCreateAsyncParams::LineItem, ModernTreasury::Util::AnyHash)],
           metadata: T::Hash[Symbol, String],
           nsf_protected: T::Boolean,
           originating_party_name: T.nilable(String),
-          priority: Symbol,
+          priority: ModernTreasury::Models::PaymentOrderCreateAsyncParams::Priority::OrSymbol,
           process_after: T.nilable(Time),
           purpose: T.nilable(String),
-          receiving_account: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount,
+          receiving_account: T.any(
+            ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount,
+            ModernTreasury::Util::AnyHash
+          ),
           receiving_account_id: String,
           remittance_information: T.nilable(String),
           send_remittance_advice: T.nilable(T::Boolean),
           statement_descriptor: T.nilable(String),
-          subtype: T.nilable(Symbol),
+          subtype: T.nilable(ModernTreasury::Models::PaymentOrderSubtype::OrSymbol),
           transaction_monitoring_enabled: T::Boolean,
           ultimate_originating_party_identifier: T.nilable(String),
           ultimate_originating_party_name: T.nilable(String),
           ultimate_receiving_party_identifier: T.nilable(String),
           ultimate_receiving_party_name: T.nilable(String),
-          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(
         amount:,
         direction:,
         originating_account_id:,
@@ -384,27 +358,27 @@ module ModernTreasury
           .returns(
             {
               amount: Integer,
-              direction: Symbol,
+              direction: ModernTreasury::Models::PaymentOrderCreateAsyncParams::Direction::OrSymbol,
               originating_account_id: String,
-              type: Symbol,
+              type: ModernTreasury::Models::PaymentOrderType::OrSymbol,
               accounting: ModernTreasury::Models::PaymentOrderCreateAsyncParams::Accounting,
               accounting_category_id: T.nilable(String),
               accounting_ledger_class_id: T.nilable(String),
-              charge_bearer: T.nilable(Symbol),
-              currency: Symbol,
+              charge_bearer: T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ChargeBearer::OrSymbol),
+              currency: ModernTreasury::Models::Currency::OrSymbol,
               description: T.nilable(String),
               effective_date: Date,
               expires_at: T.nilable(Time),
-              fallback_type: Symbol,
+              fallback_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::FallbackType::OrSymbol,
               foreign_exchange_contract: T.nilable(String),
-              foreign_exchange_indicator: T.nilable(Symbol),
+              foreign_exchange_indicator: T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ForeignExchangeIndicator::OrSymbol),
               ledger_transaction: ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction,
               ledger_transaction_id: String,
               line_items: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::LineItem],
               metadata: T::Hash[Symbol, String],
               nsf_protected: T::Boolean,
               originating_party_name: T.nilable(String),
-              priority: Symbol,
+              priority: ModernTreasury::Models::PaymentOrderCreateAsyncParams::Priority::OrSymbol,
               process_after: T.nilable(Time),
               purpose: T.nilable(String),
               receiving_account: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount,
@@ -412,7 +386,7 @@ module ModernTreasury
               remittance_information: T.nilable(String),
               send_remittance_advice: T.nilable(T::Boolean),
               statement_descriptor: T.nilable(String),
-              subtype: T.nilable(Symbol),
+              subtype: T.nilable(ModernTreasury::Models::PaymentOrderSubtype::OrSymbol),
               transaction_monitoring_enabled: T::Boolean,
               ultimate_originating_party_identifier: T.nilable(String),
               ultimate_originating_party_name: T.nilable(String),
@@ -425,36 +399,40 @@ module ModernTreasury
       def to_hash
       end
-      class Direction < ModernTreasury::Enum
-        abstract!
+      # One of `credit`, `debit`. Describes the direction money is flowing in the
+      #   transaction. A `credit` moves money from your account to someone else's. A
+      #   `debit` pulls money from someone else's account to your own. Note that wire,
+      #   rtp, and check payments will always be `credit`.
+      module Direction
+        extend ModernTreasury::Enum
-        CREDIT = :credit
-        DEBIT = :debit
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::Direction) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::Direction::TaggedSymbol) }
-        sig { override.returns(T::Array[Symbol]) }
+        CREDIT = T.let(:credit, ModernTreasury::Models::PaymentOrderCreateAsyncParams::Direction::TaggedSymbol)
+        DEBIT = T.let(:debit, ModernTreasury::Models::PaymentOrderCreateAsyncParams::Direction::TaggedSymbol)
+        sig { override.returns(T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::Direction::TaggedSymbol]) }
         def self.values
         end
       end
       class Accounting < ModernTreasury::BaseModel
+        # The ID of one of your accounting categories. Note that these will only be
+        #   accessible if your accounting system has been connected.
         sig { returns(T.nilable(String)) }
-        def account_id
-        end
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def account_id=(_)
-        end
+        attr_accessor :account_id
+        # The ID of one of the class objects in your accounting system. Class objects
+        #   track segments of your business independent of client or project. Note that
+        #   these will only be accessible if your accounting system has been connected.
         sig { returns(T.nilable(String)) }
-        def class_id
-        end
+        attr_accessor :class_id
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def class_id=(_)
-        end
-        sig { params(account_id: T.nilable(String), class_id: T.nilable(String)).void }
-        def initialize(account_id: nil, class_id: nil)
+        sig { params(account_id: T.nilable(String), class_id: T.nilable(String)).returns(T.attached_class) }
+        def self.new(account_id: nil, class_id: nil)
         end
         sig { override.returns({account_id: T.nilable(String), class_id: T.nilable(String)}) }
@@ -462,130 +440,198 @@ module ModernTreasury
         end
       end
-      class ChargeBearer < ModernTreasury::Enum
-        abstract!
+      # The party that will pay the fees for the payment order. Only applies to wire
+      #   payment orders. Can be one of shared, sender, or receiver, which correspond
+      #   respectively with the SWIFT 71A values `SHA`, `OUR`, `BEN`.
+      module ChargeBearer
+        extend ModernTreasury::Enum
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::ChargeBearer) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::ChargeBearer::TaggedSymbol) }
-        SHARED = T.let(:shared, T.nilable(Symbol))
-        SENDER = T.let(:sender, T.nilable(Symbol))
-        RECEIVER = T.let(:receiver, T.nilable(Symbol))
+        SHARED =
+          T.let(:shared, ModernTreasury::Models::PaymentOrderCreateAsyncParams::ChargeBearer::TaggedSymbol)
+        SENDER =
+          T.let(:sender, ModernTreasury::Models::PaymentOrderCreateAsyncParams::ChargeBearer::TaggedSymbol)
+        RECEIVER =
+          T.let(:receiver, ModernTreasury::Models::PaymentOrderCreateAsyncParams::ChargeBearer::TaggedSymbol)
-        sig { override.returns(T::Array[Symbol]) }
+        sig do
+          override
+            .returns(T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ChargeBearer::TaggedSymbol])
+        end
         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
+      #   (type=rtp and fallback_type=ach)
+      module FallbackType
+        extend ModernTreasury::Enum
-        ACH = :ach
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::FallbackType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::FallbackType::TaggedSymbol) }
-        sig { override.returns(T::Array[Symbol]) }
+        ACH = T.let(:ach, ModernTreasury::Models::PaymentOrderCreateAsyncParams::FallbackType::TaggedSymbol)
+        sig do
+          override
+            .returns(T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::FallbackType::TaggedSymbol])
+        end
         def self.values
         end
       end
-      class ForeignExchangeIndicator < ModernTreasury::Enum
-        abstract!
+      # Indicates the type of FX transfer to initiate, can be either
+      #   `variable_to_fixed`, `fixed_to_variable`, or `null` if the payment order
+      #   currency matches the originating account currency.
+      module ForeignExchangeIndicator
+        extend ModernTreasury::Enum
-        FIXED_TO_VARIABLE = T.let(:fixed_to_variable, T.nilable(Symbol))
-        VARIABLE_TO_FIXED = T.let(:variable_to_fixed, T.nilable(Symbol))
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::ForeignExchangeIndicator) }
+        OrSymbol =
+          T.type_alias do
+            T.any(
+              Symbol,
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ForeignExchangeIndicator::TaggedSymbol
+            )
+          end
-        sig { override.returns(T::Array[Symbol]) }
+        FIXED_TO_VARIABLE =
+          T.let(
+            :fixed_to_variable,
+            ModernTreasury::Models::PaymentOrderCreateAsyncParams::ForeignExchangeIndicator::TaggedSymbol
+          )
+        VARIABLE_TO_FIXED =
+          T.let(
+            :variable_to_fixed,
+            ModernTreasury::Models::PaymentOrderCreateAsyncParams::ForeignExchangeIndicator::TaggedSymbol
+          )
+        sig do
+          override
+            .returns(
+              T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ForeignExchangeIndicator::TaggedSymbol]
+            )
+        end
         def self.values
         end
       end
       class LedgerTransaction < ModernTreasury::BaseModel
+        # An array of ledger entry objects.
         sig { returns(T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerEntry]) }
-        def ledger_entries
-        end
-        sig do
-          params(_: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerEntry])
-            .returns(T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerEntry])
-        end
-        def ledger_entries=(_)
-        end
+        attr_accessor :ledger_entries
+        # An optional description for internal use.
         sig { returns(T.nilable(String)) }
-        def description
-        end
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def description=(_)
-        end
+        attr_accessor :description
+        # The timestamp (ISO8601 format) at which the ledger transaction happened for
+        #   reporting purposes.
         sig { returns(T.nilable(Time)) }
-        def effective_at
-        end
+        attr_reader :effective_at
-        sig { params(_: Time).returns(Time) }
-        def effective_at=(_)
-        end
+        sig { params(effective_at: Time).void }
+        attr_writer :effective_at
+        # The date (YYYY-MM-DD) on which the ledger transaction happened for reporting
+        #   purposes.
         sig { returns(T.nilable(Date)) }
-        def effective_date
-        end
+        attr_reader :effective_date
-        sig { params(_: Date).returns(Date) }
-        def effective_date=(_)
-        end
+        sig { params(effective_date: Date).void }
+        attr_writer :effective_date
+        # A unique string to represent the ledger transaction. Only one pending or posted
+        #   ledger transaction may have this ID in the ledger.
         sig { returns(T.nilable(String)) }
-        def external_id
-        end
+        attr_reader :external_id
-        sig { params(_: String).returns(String) }
-        def external_id=(_)
-        end
+        sig { params(external_id: String).void }
+        attr_writer :external_id
+        # If the ledger transaction can be reconciled to another object in Modern
+        #   Treasury, the id will be populated here, otherwise null.
         sig { returns(T.nilable(String)) }
-        def ledgerable_id
-        end
+        attr_reader :ledgerable_id
-        sig { params(_: String).returns(String) }
-        def ledgerable_id=(_)
-        end
+        sig { params(ledgerable_id: String).void }
+        attr_writer :ledgerable_id
-        sig { returns(T.nilable(Symbol)) }
-        def ledgerable_type
+        # If the ledger transaction can be reconciled to another object in Modern
+        #   Treasury, the type will be populated here, otherwise null. This can be one of
+        #   payment_order, incoming_payment_detail, expected_payment, return, paper_item, or
+        #   reversal.
+        sig do
+          returns(
+            T.nilable(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType::OrSymbol
+            )
+          )
         end
+        attr_reader :ledgerable_type
-        sig { params(_: Symbol).returns(Symbol) }
-        def ledgerable_type=(_)
+        sig do
+          params(
+            ledgerable_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType::OrSymbol
+          )
+            .void
         end
+        attr_writer :ledgerable_type
+        # 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
-        sig { returns(T.nilable(Symbol)) }
-        def status
+        # To post a ledger transaction at creation, use `posted`.
+        sig do
+          returns(
+            T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::Status::OrSymbol)
+          )
         end
+        attr_reader :status
-        sig { params(_: Symbol).returns(Symbol) }
-        def status=(_)
+        sig do
+          params(status: ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::Status::OrSymbol)
+            .void
         end
+        attr_writer :status
+        # Specifies a ledger transaction object that will be created with the payment
+        #   order. If the ledger transaction cannot be created, then the payment order
+        #   creation will fail. The resulting ledger transaction will mirror the status of
+        #   the payment order.
         sig do
           params(
-            ledger_entries: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerEntry],
+            ledger_entries: T::Array[
+            T.any(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerEntry,
+              ModernTreasury::Util::AnyHash
+            )
+            ],
             description: T.nilable(String),
             effective_at: Time,
             effective_date: Date,
             external_id: String,
             ledgerable_id: String,
-            ledgerable_type: Symbol,
+            ledgerable_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType::OrSymbol,
             metadata: T::Hash[Symbol, String],
-            status: Symbol
+            status: ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::Status::OrSymbol
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           ledger_entries:,
           description: nil,
           effective_at: nil,
@@ -608,9 +654,9 @@ module ModernTreasury
                 effective_date: Date,
                 external_id: String,
                 ledgerable_id: String,
-                ledgerable_type: Symbol,
+                ledgerable_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType::OrSymbol,
                 metadata: T::Hash[Symbol, String],
-                status: Symbol
+                status: ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::Status::OrSymbol
               }
             )
         end
@@ -618,82 +664,64 @@ module ModernTreasury
         end
         class LedgerEntry < ModernTreasury::BaseModel
+          # Value in specified currency's smallest unit. e.g. $10 would be represented
+          #   as 1000. Can be any integer up to 36 digits.
           sig { returns(Integer) }
-          def amount
-          end
+          attr_accessor :amount
-          sig { params(_: Integer).returns(Integer) }
-          def amount=(_)
-          end
-          sig { returns(Symbol) }
-          def direction
-          end
-          sig { params(_: Symbol).returns(Symbol) }
-          def direction=(_)
-          end
+          # One of `credit`, `debit`. Describes the direction money is flowing in the
+          #   transaction. A `credit` moves money from your account to someone else's. A
+          #   `debit` pulls money from someone else's account to your own. Note that wire,
+          #   rtp, and check payments will always be `credit`.
+          sig { returns(ModernTreasury::Models::TransactionDirection::OrSymbol) }
+          attr_accessor :direction
+          # The ledger account that this ledger entry is associated with.
           sig { returns(String) }
-          def ledger_account_id
-          end
-          sig { params(_: String).returns(String) }
-          def ledger_account_id=(_)
-          end
+          attr_accessor :ledger_account_id
+          # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to lock on the
+          #   account’s available balance. If any of these conditions would be false after the
+          #   transaction is created, the entire call will fail with error code 422.
           sig { returns(T.nilable(T::Hash[Symbol, Integer])) }
-          def available_balance_amount
-          end
-          sig { params(_: T.nilable(T::Hash[Symbol, Integer])).returns(T.nilable(T::Hash[Symbol, Integer])) }
-          def available_balance_amount=(_)
-          end
+          attr_accessor :available_balance_amount
+          # Lock version of the ledger account. This can be passed when creating a ledger
+          #   transaction to only succeed if no ledger transactions have posted since the
+          #   given version. See our post about Designing the Ledgers API with Optimistic
+          #   Locking for more details.
           sig { returns(T.nilable(Integer)) }
-          def lock_version
-          end
-          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-          def lock_version=(_)
-          end
+          attr_accessor :lock_version
+          # 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
+          # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to lock on the
+          #   account’s pending balance. If any of these conditions would be false after the
+          #   transaction is created, the entire call will fail with error code 422.
           sig { returns(T.nilable(T::Hash[Symbol, Integer])) }
-          def pending_balance_amount
-          end
-          sig { params(_: T.nilable(T::Hash[Symbol, Integer])).returns(T.nilable(T::Hash[Symbol, Integer])) }
-          def pending_balance_amount=(_)
-          end
+          attr_accessor :pending_balance_amount
+          # Use `gt` (>), `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to lock on the
+          #   account’s posted balance. If any of these conditions would be false after the
+          #   transaction is created, the entire call will fail with error code 422.
           sig { returns(T.nilable(T::Hash[Symbol, Integer])) }
-          def posted_balance_amount
-          end
-          sig { params(_: T.nilable(T::Hash[Symbol, Integer])).returns(T.nilable(T::Hash[Symbol, Integer])) }
-          def posted_balance_amount=(_)
-          end
+          attr_accessor :posted_balance_amount
+          # If true, response will include the balance of the associated ledger account for
+          #   the entry.
           sig { returns(T.nilable(T::Boolean)) }
-          def show_resulting_ledger_account_balances
-          end
-          sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
-          def show_resulting_ledger_account_balances=(_)
-          end
+          attr_accessor :show_resulting_ledger_account_balances
           sig do
             params(
               amount: Integer,
-              direction: Symbol,
+              direction: ModernTreasury::Models::TransactionDirection::OrSymbol,
               ledger_account_id: String,
               available_balance_amount: T.nilable(T::Hash[Symbol, Integer]),
               lock_version: T.nilable(Integer),
@@ -702,9 +730,9 @@ module ModernTreasury
               posted_balance_amount: T.nilable(T::Hash[Symbol, Integer]),
               show_resulting_ledger_account_balances: T.nilable(T::Boolean)
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(
+          def self.new(
             amount:,
             direction:,
             ledger_account_id:,
@@ -722,7 +750,7 @@ module ModernTreasury
               .returns(
                 {
                   amount: Integer,
-                  direction: Symbol,
+                  direction: ModernTreasury::Models::TransactionDirection::OrSymbol,
                   ledger_account_id: String,
                   available_balance_amount: T.nilable(T::Hash[Symbol, Integer]),
                   lock_version: T.nilable(Integer),
@@ -737,66 +765,127 @@ module ModernTreasury
           end
         end
-        class LedgerableType < ModernTreasury::Enum
-          abstract!
+        # If the ledger transaction can be reconciled to another object in Modern
+        #   Treasury, the type will be populated here, otherwise null. This can be one of
+        #   payment_order, incoming_payment_detail, expected_payment, return, paper_item, or
+        #   reversal.
+        module LedgerableType
+          extend ModernTreasury::Enum
-          EXPECTED_PAYMENT = :expected_payment
-          INCOMING_PAYMENT_DETAIL = :incoming_payment_detail
-          PAPER_ITEM = :paper_item
-          PAYMENT_ORDER = :payment_order
-          RETURN = :return
-          REVERSAL = :reversal
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType) }
+          OrSymbol =
+            T.type_alias do
+              T.any(
+                Symbol,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType::TaggedSymbol
+              )
+            end
-          sig { override.returns(T::Array[Symbol]) }
+          EXPECTED_PAYMENT =
+            T.let(
+              :expected_payment,
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType::TaggedSymbol
+            )
+          INCOMING_PAYMENT_DETAIL =
+            T.let(
+              :incoming_payment_detail,
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType::TaggedSymbol
+            )
+          PAPER_ITEM =
+            T.let(
+              :paper_item,
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType::TaggedSymbol
+            )
+          PAYMENT_ORDER =
+            T.let(
+              :payment_order,
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType::TaggedSymbol
+            )
+          RETURN =
+            T.let(
+              :return,
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType::TaggedSymbol
+            )
+          REVERSAL =
+            T.let(
+              :reversal,
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType::TaggedSymbol
+            )
+          sig do
+            override
+              .returns(
+                T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::LedgerableType::TaggedSymbol]
+              )
+          end
           def self.values
           end
         end
-        class Status < ModernTreasury::Enum
-          abstract!
+        # To post a ledger transaction at creation, use `posted`.
+        module Status
+          extend ModernTreasury::Enum
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::Status) }
+          OrSymbol =
+            T.type_alias do
+              T.any(
+                Symbol,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::Status::TaggedSymbol
+              )
+            end
-          ARCHIVED = :archived
-          PENDING = :pending
-          POSTED = :posted
+          ARCHIVED =
+            T.let(
+              :archived,
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::Status::TaggedSymbol
+            )
+          PENDING =
+            T.let(
+              :pending,
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::Status::TaggedSymbol
+            )
+          POSTED =
+            T.let(
+              :posted,
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::Status::TaggedSymbol
+            )
-          sig { override.returns(T::Array[Symbol]) }
+          sig do
+            override
+              .returns(
+                T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::LedgerTransaction::Status::TaggedSymbol]
+              )
+          end
           def self.values
           end
         end
       end
       class LineItem < ModernTreasury::BaseModel
+        # Value in specified currency's smallest unit. e.g. $10 would be represented
+        #   as 1000.
         sig { returns(Integer) }
-        def amount
-        end
-        sig { params(_: Integer).returns(Integer) }
-        def amount=(_)
-        end
+        attr_accessor :amount
+        # The ID of one of your accounting categories. Note that these will only be
+        #   accessible if your accounting system has been connected.
         sig { returns(T.nilable(String)) }
-        def accounting_category_id
-        end
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def accounting_category_id=(_)
-        end
+        attr_accessor :accounting_category_id
+        # A free-form description of the line item.
         sig { returns(T.nilable(String)) }
-        def description
-        end
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def description=(_)
-        end
+        attr_accessor :description
+        # 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
         sig do
           params(
@@ -805,9 +894,9 @@ module ModernTreasury
             description: T.nilable(String),
             metadata: T::Hash[Symbol, String]
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(amount:, accounting_category_id: nil, description: nil, metadata: nil)
+        def self.new(amount:, accounting_category_id: nil, description: nil, metadata: nil)
         end
         sig do
@@ -825,13 +914,21 @@ module ModernTreasury
         end
       end
-      class Priority < ModernTreasury::Enum
-        abstract!
+      # Either `normal` or `high`. For ACH and EFT payments, `high` represents a
+      #   same-day ACH or EFT transfer, respectively. For check payments, `high` can mean
+      #   an overnight check rather than standard mail.
+      module Priority
+        extend ModernTreasury::Enum
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::Priority) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::Priority::TaggedSymbol) }
-        HIGH = :high
-        NORMAL = :normal
+        HIGH = T.let(:high, ModernTreasury::Models::PaymentOrderCreateAsyncParams::Priority::TaggedSymbol)
+        NORMAL = T.let(:normal, ModernTreasury::Models::PaymentOrderCreateAsyncParams::Priority::TaggedSymbol)
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::Priority::TaggedSymbol]) }
         def self.values
         end
       end
@@ -844,25 +941,27 @@ module ModernTreasury
             )
           )
         end
-        def account_details
-        end
+        attr_reader :account_details
         sig do
           params(
-            _: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail]
+            account_details: T::Array[
+            T.any(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail,
+              ModernTreasury::Util::AnyHash
+            )
+            ]
           )
-            .returns(T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail])
-        end
-        def account_details=(_)
+            .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::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 do
           returns(
@@ -871,87 +970,96 @@ module ModernTreasury
             )
           )
         end
-        def contact_details
-        end
+        attr_reader :contact_details
         sig do
           params(
-            _: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail]
+            contact_details: T::Array[
+            T.any(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail,
+              ModernTreasury::Util::AnyHash
+            )
+            ]
           )
-            .returns(T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail])
-        end
-        def contact_details=(_)
+            .void
         end
+        attr_writer :contact_details
+        # Specifies a ledger account object that will be created with the external
+        #   account. The resulting ledger account is linked to the external account for
+        #   auto-ledgering Payment objects. See
+        #   https://docs.moderntreasury.com/docs/linking-to-other-modern-treasury-objects
+        #   for more details.
         sig { returns(T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount)) }
-        def ledger_account
-        end
+        attr_reader :ledger_account
         sig do
-          params(_: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount)
-            .returns(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount)
-        end
-        def ledger_account=(_)
+          params(
+            ledger_account: T.any(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount,
+              ModernTreasury::Util::AnyHash
+            )
+          )
+            .void
         end
+        attr_writer :ledger_account
+        # 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
+        # Required if receiving wire payments.
         sig { returns(T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyAddress)) }
-        def party_address
-        end
+        attr_reader :party_address
         sig do
-          params(_: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyAddress)
-            .returns(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyAddress)
-        end
-        def party_address=(_)
+          params(
+            party_address: T.any(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyAddress,
+              ModernTreasury::Util::AnyHash
+            )
+          )
+            .void
         end
+        attr_writer :party_address
         sig { returns(T.nilable(String)) }
-        def party_identifier
-        end
+        attr_reader :party_identifier
-        sig { params(_: String).returns(String) }
-        def party_identifier=(_)
-        end
+        sig { params(party_identifier: String).void }
+        attr_writer :party_identifier
+        # 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=(_)
+        # Either `individual` or `business`.
+        sig do
+          returns(
+            T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyType::OrSymbol)
+          )
         end
+        attr_accessor :party_type
+        # If you've enabled the Modern Treasury + Plaid integration in your Plaid account,
+        #   you can pass the processor token in this field.
         sig { returns(T.nilable(String)) }
-        def plaid_processor_token
-        end
+        attr_reader :plaid_processor_token
-        sig { params(_: String).returns(String) }
-        def plaid_processor_token=(_)
-        end
+        sig { params(plaid_processor_token: String).void }
+        attr_writer :plaid_processor_token
         sig do
           returns(
@@ -960,36 +1068,63 @@ module ModernTreasury
             )
           )
         end
-        def routing_details
-        end
+        attr_reader :routing_details
         sig do
           params(
-            _: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail]
+            routing_details: T::Array[
+            T.any(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail,
+              ModernTreasury::Util::AnyHash
+            )
+            ]
           )
-            .returns(T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail])
-        end
-        def routing_details=(_)
+            .void
         end
+        attr_writer :routing_details
+        # Either `receiving_account` or `receiving_account_id` must be present. When using
+        #   `receiving_account_id`, you may pass the id of an external account or an
+        #   internal account.
         sig do
           params(
-            account_details: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail],
-            account_type: Symbol,
-            contact_details: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail],
-            ledger_account: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount,
+            account_details: T::Array[
+            T.any(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail,
+              ModernTreasury::Util::AnyHash
+            )
+            ],
+            account_type: ModernTreasury::Models::ExternalAccountType::OrSymbol,
+            contact_details: T::Array[
+            T.any(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail,
+              ModernTreasury::Util::AnyHash
+            )
+            ],
+            ledger_account: T.any(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount,
+              ModernTreasury::Util::AnyHash
+            ),
             metadata: T::Hash[Symbol, String],
             name: T.nilable(String),
-            party_address: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyAddress,
+            party_address: T.any(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyAddress,
+              ModernTreasury::Util::AnyHash
+            ),
             party_identifier: String,
             party_name: String,
-            party_type: T.nilable(Symbol),
+            party_type: T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyType::OrSymbol),
             plaid_processor_token: String,
-            routing_details: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail]
+            routing_details: T::Array[
+            T.any(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail,
+              ModernTreasury::Util::AnyHash
+            )
+            ]
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           account_details: nil,
           account_type: nil,
           contact_details: nil,
@@ -1010,7 +1145,7 @@ module ModernTreasury
             .returns(
               {
                 account_details: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail],
-                account_type: Symbol,
+                account_type: ModernTreasury::Models::ExternalAccountType::OrSymbol,
                 contact_details: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail],
                 ledger_account: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount,
                 metadata: T::Hash[Symbol, String],
@@ -1018,7 +1153,7 @@ module ModernTreasury
                 party_address: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyAddress,
                 party_identifier: String,
                 party_name: String,
-                party_type: T.nilable(Symbol),
+                party_type: T.nilable(ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyType::OrSymbol),
                 plaid_processor_token: String,
                 routing_details: T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail]
               }
@@ -1029,44 +1164,121 @@ module ModernTreasury
         class AccountDetail < ModernTreasury::BaseModel
           sig { returns(String) }
-          def account_number
-          end
+          attr_accessor :account_number
-          sig { params(_: String).returns(String) }
-          def account_number=(_)
+          sig do
+            returns(
+              T.nilable(
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::OrSymbol
+              )
+            )
           end
+          attr_reader :account_number_type
-          sig { returns(T.nilable(Symbol)) }
-          def account_number_type
+          sig do
+            params(
+              account_number_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::OrSymbol
+            )
+              .void
           end
+          attr_writer :account_number_type
-          sig { params(_: Symbol).returns(Symbol) }
-          def account_number_type=(_)
+          sig do
+            params(
+              account_number: String,
+              account_number_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::OrSymbol
+            )
+              .returns(T.attached_class)
           end
-          sig { params(account_number: String, account_number_type: Symbol).void }
-          def initialize(account_number:, account_number_type: nil)
+          def self.new(account_number:, account_number_type: nil)
           end
-          sig { override.returns({account_number: String, account_number_type: Symbol}) }
+          sig do
+            override
+              .returns(
+                {
+                  account_number: String,
+                  account_number_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::OrSymbol
+                }
+              )
+          end
           def to_hash
           end
-          class AccountNumberType < ModernTreasury::Enum
-            abstract!
-            AU_NUMBER = :au_number
-            CLABE = :clabe
-            HK_NUMBER = :hk_number
-            IBAN = :iban
-            ID_NUMBER = :id_number
-            NZ_NUMBER = :nz_number
-            OTHER = :other
-            PAN = :pan
-            SG_NUMBER = :sg_number
-            WALLET_ADDRESS = :wallet_address
-            sig { override.returns(T::Array[Symbol]) }
+          module AccountNumberType
+            extend ModernTreasury::Enum
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType)
+              end
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::TaggedSymbol
+                )
+              end
+            AU_NUMBER =
+              T.let(
+                :au_number,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::TaggedSymbol
+              )
+            CLABE =
+              T.let(
+                :clabe,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::TaggedSymbol
+              )
+            HK_NUMBER =
+              T.let(
+                :hk_number,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::TaggedSymbol
+              )
+            IBAN =
+              T.let(
+                :iban,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::TaggedSymbol
+              )
+            ID_NUMBER =
+              T.let(
+                :id_number,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::TaggedSymbol
+              )
+            NZ_NUMBER =
+              T.let(
+                :nz_number,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::TaggedSymbol
+              )
+            OTHER =
+              T.let(
+                :other,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::TaggedSymbol
+              )
+            PAN =
+              T.let(
+                :pan,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::TaggedSymbol
+              )
+            SG_NUMBER =
+              T.let(
+                :sg_number,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::TaggedSymbol
+              )
+            WALLET_ADDRESS =
+              T.let(
+                :wallet_address,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::TaggedSymbol
+              )
+            sig do
+              override
+                .returns(
+                  T::Array[
+                  ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::AccountDetail::AccountNumberType::TaggedSymbol
+                  ]
+                )
+            end
             def self.values
             end
           end
@@ -1074,139 +1286,184 @@ module ModernTreasury
         class ContactDetail < ModernTreasury::BaseModel
           sig { returns(T.nilable(String)) }
-          def contact_identifier
-          end
+          attr_reader :contact_identifier
-          sig { params(_: String).returns(String) }
-          def contact_identifier=(_)
-          end
+          sig { params(contact_identifier: String).void }
+          attr_writer :contact_identifier
-          sig { returns(T.nilable(Symbol)) }
-          def contact_identifier_type
+          sig do
+            returns(
+              T.nilable(
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail::ContactIdentifierType::OrSymbol
+              )
+            )
           end
+          attr_reader :contact_identifier_type
-          sig { params(_: Symbol).returns(Symbol) }
-          def contact_identifier_type=(_)
+          sig do
+            params(
+              contact_identifier_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail::ContactIdentifierType::OrSymbol
+            )
+              .void
           end
+          attr_writer :contact_identifier_type
-          sig { params(contact_identifier: String, contact_identifier_type: Symbol).void }
-          def initialize(contact_identifier: nil, contact_identifier_type: nil)
+          sig do
+            params(
+              contact_identifier: String,
+              contact_identifier_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail::ContactIdentifierType::OrSymbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(contact_identifier: nil, contact_identifier_type: nil)
           end
-          sig { override.returns({contact_identifier: String, contact_identifier_type: Symbol}) }
+          sig do
+            override
+              .returns(
+                {
+                  contact_identifier: String,
+                  contact_identifier_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail::ContactIdentifierType::OrSymbol
+                }
+              )
+          end
           def to_hash
           end
-          class ContactIdentifierType < ModernTreasury::Enum
-            abstract!
-            EMAIL = :email
-            PHONE_NUMBER = :phone_number
-            WEBSITE = :website
+          module ContactIdentifierType
+            extend ModernTreasury::Enum
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail::ContactIdentifierType)
+              end
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail::ContactIdentifierType::TaggedSymbol
+                )
+              end
+            EMAIL =
+              T.let(
+                :email,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail::ContactIdentifierType::TaggedSymbol
+              )
+            PHONE_NUMBER =
+              T.let(
+                :phone_number,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail::ContactIdentifierType::TaggedSymbol
+              )
+            WEBSITE =
+              T.let(
+                :website,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail::ContactIdentifierType::TaggedSymbol
+              )
-            sig { override.returns(T::Array[Symbol]) }
+            sig do
+              override
+                .returns(
+                  T::Array[
+                  ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::ContactDetail::ContactIdentifierType::TaggedSymbol
+                  ]
+                )
+            end
             def self.values
             end
           end
         end
         class LedgerAccount < ModernTreasury::BaseModel
+          # The currency of the ledger account.
           sig { returns(String) }
-          def currency
-          end
-          sig { params(_: String).returns(String) }
-          def currency=(_)
-          end
+          attr_accessor :currency
+          # The id of the ledger that this account belongs to.
           sig { returns(String) }
-          def ledger_id
-          end
-          sig { params(_: String).returns(String) }
-          def ledger_id=(_)
-          end
+          attr_accessor :ledger_id
+          # The name of the ledger account.
           sig { returns(String) }
-          def name
-          end
-          sig { params(_: String).returns(String) }
-          def name=(_)
-          end
-          sig { returns(Symbol) }
-          def normal_balance
-          end
+          attr_accessor :name
-          sig { params(_: Symbol).returns(Symbol) }
-          def normal_balance=(_)
-          end
+          # The normal balance of the ledger account.
+          sig { returns(ModernTreasury::Models::TransactionDirection::OrSymbol) }
+          attr_accessor :normal_balance
+          # The currency exponent of the ledger account.
           sig { returns(T.nilable(Integer)) }
-          def currency_exponent
-          end
-          sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-          def currency_exponent=(_)
-          end
+          attr_accessor :currency_exponent
+          # The description of the ledger account.
           sig { returns(T.nilable(String)) }
-          def description
-          end
-          sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-          def description=(_)
-          end
+          attr_accessor :description
+          # The array of ledger account category ids that this ledger account should be a
+          #   child of.
           sig { returns(T.nilable(T::Array[String])) }
-          def ledger_account_category_ids
-          end
+          attr_reader :ledger_account_category_ids
-          sig { params(_: T::Array[String]).returns(T::Array[String]) }
-          def ledger_account_category_ids=(_)
-          end
+          sig { params(ledger_account_category_ids: T::Array[String]).void }
+          attr_writer :ledger_account_category_ids
+          # If the ledger account links to another object in Modern Treasury, the id will be
+          #   populated here, otherwise null.
           sig { returns(T.nilable(String)) }
-          def ledgerable_id
-          end
+          attr_reader :ledgerable_id
-          sig { params(_: String).returns(String) }
-          def ledgerable_id=(_)
-          end
+          sig { params(ledgerable_id: String).void }
+          attr_writer :ledgerable_id
-          sig { returns(T.nilable(Symbol)) }
-          def ledgerable_type
+          # If the ledger account links to another object in Modern Treasury, the type will
+          #   be populated here, otherwise null. The value is one of internal_account or
+          #   external_account.
+          sig do
+            returns(
+              T.nilable(
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount::LedgerableType::OrSymbol
+              )
+            )
           end
+          attr_reader :ledgerable_type
-          sig { params(_: Symbol).returns(Symbol) }
-          def ledgerable_type=(_)
+          sig do
+            params(
+              ledgerable_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount::LedgerableType::OrSymbol
+            )
+              .void
           end
+          attr_writer :ledgerable_type
+          # 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
+          # Specifies a ledger account object that will be created with the external
+          #   account. The resulting ledger account is linked to the external account for
+          #   auto-ledgering Payment objects. See
+          #   https://docs.moderntreasury.com/docs/linking-to-other-modern-treasury-objects
+          #   for more details.
           sig do
             params(
               currency: String,
               ledger_id: String,
               name: String,
-              normal_balance: Symbol,
+              normal_balance: ModernTreasury::Models::TransactionDirection::OrSymbol,
               currency_exponent: T.nilable(Integer),
               description: T.nilable(String),
               ledger_account_category_ids: T::Array[String],
               ledgerable_id: String,
-              ledgerable_type: Symbol,
+              ledgerable_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount::LedgerableType::OrSymbol,
               metadata: T::Hash[Symbol, String]
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(
+          def self.new(
             currency:,
             ledger_id:,
             name:,
@@ -1227,12 +1484,12 @@ module ModernTreasury
                   currency: String,
                   ledger_id: String,
                   name: String,
-                  normal_balance: Symbol,
+                  normal_balance: ModernTreasury::Models::TransactionDirection::OrSymbol,
                   currency_exponent: T.nilable(Integer),
                   description: T.nilable(String),
                   ledger_account_category_ids: T::Array[String],
                   ledgerable_id: String,
-                  ledgerable_type: Symbol,
+                  ledgerable_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount::LedgerableType::OrSymbol,
                   metadata: T::Hash[Symbol, String]
                 }
               )
@@ -1240,69 +1497,82 @@ module ModernTreasury
           def to_hash
           end
-          class LedgerableType < ModernTreasury::Enum
-            abstract!
-            COUNTERPARTY = :counterparty
-            EXTERNAL_ACCOUNT = :external_account
-            INTERNAL_ACCOUNT = :internal_account
-            VIRTUAL_ACCOUNT = :virtual_account
+          # If the ledger account links to another object in Modern Treasury, the type will
+          #   be populated here, otherwise null. The value is one of internal_account or
+          #   external_account.
+          module LedgerableType
+            extend ModernTreasury::Enum
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount::LedgerableType)
+              end
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount::LedgerableType::TaggedSymbol
+                )
+              end
+            COUNTERPARTY =
+              T.let(
+                :counterparty,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount::LedgerableType::TaggedSymbol
+              )
+            EXTERNAL_ACCOUNT =
+              T.let(
+                :external_account,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount::LedgerableType::TaggedSymbol
+              )
+            INTERNAL_ACCOUNT =
+              T.let(
+                :internal_account,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount::LedgerableType::TaggedSymbol
+              )
+            VIRTUAL_ACCOUNT =
+              T.let(
+                :virtual_account,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount::LedgerableType::TaggedSymbol
+              )
-            sig { override.returns(T::Array[Symbol]) }
+            sig do
+              override
+                .returns(
+                  T::Array[
+                  ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::LedgerAccount::LedgerableType::TaggedSymbol
+                  ]
+                )
+            end
             def self.values
             end
           end
         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
+          # Required if receiving wire payments.
           sig do
             params(
               country: T.nilable(String),
@@ -1312,9 +1582,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
@@ -1334,117 +1604,400 @@ module ModernTreasury
           end
         end
-        class PartyType < ModernTreasury::Enum
-          abstract!
+        # Either `individual` or `business`.
+        module PartyType
+          extend ModernTreasury::Enum
-          BUSINESS = T.let(:business, T.nilable(Symbol))
-          INDIVIDUAL = T.let(:individual, T.nilable(Symbol))
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyType) }
+          OrSymbol =
+            T.type_alias do
+              T.any(
+                Symbol,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyType::TaggedSymbol
+              )
+            end
-          sig { override.returns(T::Array[Symbol]) }
+          BUSINESS =
+            T.let(
+              :business,
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyType::TaggedSymbol
+            )
+          INDIVIDUAL =
+            T.let(
+              :individual,
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyType::TaggedSymbol
+            )
+          sig do
+            override
+              .returns(
+                T::Array[ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::PartyType::TaggedSymbol]
+              )
+          end
           def self.values
           end
         end
         class RoutingDetail < ModernTreasury::BaseModel
           sig { returns(String) }
-          def routing_number
-          end
+          attr_accessor :routing_number
-          sig { params(_: String).returns(String) }
-          def routing_number=(_)
-          end
-          sig { returns(Symbol) }
-          def routing_number_type
+          sig do
+            returns(
+              ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::OrSymbol
+            )
           end
+          attr_accessor :routing_number_type
-          sig { params(_: Symbol).returns(Symbol) }
-          def routing_number_type=(_)
+          sig do
+            returns(
+              T.nilable(
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::OrSymbol
+              )
+            )
           end
+          attr_reader :payment_type
-          sig { returns(T.nilable(Symbol)) }
-          def payment_type
+          sig do
+            params(
+              payment_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::OrSymbol
+            )
+              .void
           end
+          attr_writer :payment_type
-          sig { params(_: Symbol).returns(Symbol) }
-          def payment_type=(_)
+          sig do
+            params(
+              routing_number: String,
+              routing_number_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::OrSymbol,
+              payment_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::OrSymbol
+            )
+              .returns(T.attached_class)
           end
-          sig { params(routing_number: String, routing_number_type: Symbol, payment_type: Symbol).void }
-          def initialize(routing_number:, routing_number_type:, payment_type: nil)
+          def self.new(routing_number:, routing_number_type:, payment_type: nil)
           end
           sig do
-            override.returns({routing_number: String, routing_number_type: Symbol, payment_type: Symbol})
+            override
+              .returns(
+                {
+                  routing_number: String,
+                  routing_number_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::OrSymbol,
+                  payment_type: ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::OrSymbol
+                }
+              )
           end
           def to_hash
           end
-          class RoutingNumberType < ModernTreasury::Enum
-            abstract!
-            ABA = :aba
-            AU_BSB = :au_bsb
-            BR_CODIGO = :br_codigo
-            CA_CPA = :ca_cpa
-            CHIPS = :chips
-            CNAPS = :cnaps
-            DK_INTERBANK_CLEARING_CODE = :dk_interbank_clearing_code
-            GB_SORT_CODE = :gb_sort_code
-            HK_INTERBANK_CLEARING_CODE = :hk_interbank_clearing_code
-            HU_INTERBANK_CLEARING_CODE = :hu_interbank_clearing_code
-            ID_SKNBI_CODE = :id_sknbi_code
-            IN_IFSC = :in_ifsc
-            JP_ZENGIN_CODE = :jp_zengin_code
-            MY_BRANCH_CODE = :my_branch_code
-            MX_BANK_IDENTIFIER = :mx_bank_identifier
-            NZ_NATIONAL_CLEARING_CODE = :nz_national_clearing_code
-            PL_NATIONAL_CLEARING_CODE = :pl_national_clearing_code
-            SE_BANKGIRO_CLEARING_CODE = :se_bankgiro_clearing_code
-            SG_INTERBANK_CLEARING_CODE = :sg_interbank_clearing_code
-            SWIFT = :swift
-            ZA_NATIONAL_CLEARING_CODE = :za_national_clearing_code
-            sig { override.returns(T::Array[Symbol]) }
+          module RoutingNumberType
+            extend ModernTreasury::Enum
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType)
+              end
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+                )
+              end
+            ABA =
+              T.let(
+                :aba,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            AU_BSB =
+              T.let(
+                :au_bsb,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            BR_CODIGO =
+              T.let(
+                :br_codigo,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            CA_CPA =
+              T.let(
+                :ca_cpa,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            CHIPS =
+              T.let(
+                :chips,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            CNAPS =
+              T.let(
+                :cnaps,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            DK_INTERBANK_CLEARING_CODE =
+              T.let(
+                :dk_interbank_clearing_code,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            GB_SORT_CODE =
+              T.let(
+                :gb_sort_code,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            HK_INTERBANK_CLEARING_CODE =
+              T.let(
+                :hk_interbank_clearing_code,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            HU_INTERBANK_CLEARING_CODE =
+              T.let(
+                :hu_interbank_clearing_code,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            ID_SKNBI_CODE =
+              T.let(
+                :id_sknbi_code,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            IN_IFSC =
+              T.let(
+                :in_ifsc,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            JP_ZENGIN_CODE =
+              T.let(
+                :jp_zengin_code,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            MY_BRANCH_CODE =
+              T.let(
+                :my_branch_code,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            MX_BANK_IDENTIFIER =
+              T.let(
+                :mx_bank_identifier,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            NZ_NATIONAL_CLEARING_CODE =
+              T.let(
+                :nz_national_clearing_code,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            PL_NATIONAL_CLEARING_CODE =
+              T.let(
+                :pl_national_clearing_code,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            SE_BANKGIRO_CLEARING_CODE =
+              T.let(
+                :se_bankgiro_clearing_code,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            SG_INTERBANK_CLEARING_CODE =
+              T.let(
+                :sg_interbank_clearing_code,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            SWIFT =
+              T.let(
+                :swift,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            ZA_NATIONAL_CLEARING_CODE =
+              T.let(
+                :za_national_clearing_code,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+              )
+            sig do
+              override
+                .returns(
+                  T::Array[
+                  ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::RoutingNumberType::TaggedSymbol
+                  ]
+                )
+            end
             def self.values
             end
           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]) }
+          module PaymentType
+            extend ModernTreasury::Enum
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType)
+              end
+            OrSymbol =
+              T.type_alias do
+                T.any(
+                  Symbol,
+                  ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+                )
+              end
+            ACH =
+              T.let(
+                :ach,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            AU_BECS =
+              T.let(
+                :au_becs,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            BACS =
+              T.let(
+                :bacs,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            BOOK =
+              T.let(
+                :book,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            CARD =
+              T.let(
+                :card,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            CHATS =
+              T.let(
+                :chats,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            CHECK =
+              T.let(
+                :check,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            CROSS_BORDER =
+              T.let(
+                :cross_border,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            DK_NETS =
+              T.let(
+                :dk_nets,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            EFT =
+              T.let(
+                :eft,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            HU_ICS =
+              T.let(
+                :hu_ics,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            INTERAC =
+              T.let(
+                :interac,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            MASAV =
+              T.let(
+                :masav,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            MX_CCEN =
+              T.let(
+                :mx_ccen,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            NEFT =
+              T.let(
+                :neft,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            NICS =
+              T.let(
+                :nics,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            NZ_BECS =
+              T.let(
+                :nz_becs,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            PL_ELIXIR =
+              T.let(
+                :pl_elixir,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            PROVXCHANGE =
+              T.let(
+                :provxchange,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            RO_SENT =
+              T.let(
+                :ro_sent,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            RTP =
+              T.let(
+                :rtp,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            SE_BANKGIROT =
+              T.let(
+                :se_bankgirot,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            SEN =
+              T.let(
+                :sen,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            SEPA =
+              T.let(
+                :sepa,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            SG_GIRO =
+              T.let(
+                :sg_giro,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            SIC =
+              T.let(
+                :sic,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            SIGNET =
+              T.let(
+                :signet,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            SKNBI =
+              T.let(
+                :sknbi,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            WIRE =
+              T.let(
+                :wire,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            ZENGIN =
+              T.let(
+                :zengin,
+                ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+              )
+            sig do
+              override
+                .returns(
+                  T::Array[
+                  ModernTreasury::Models::PaymentOrderCreateAsyncParams::ReceivingAccount::RoutingDetail::PaymentType::TaggedSymbol
+                  ]
+                )
+            end
             def self.values
             end
           end