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

data/rbi/lib/modern_treasury/models/transaction.rbi

@@ -4,239 +4,162 @@ module ModernTreasury
   module Models
     class Transaction < ModernTreasury::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
+      # 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 date on which the transaction occurred.
       sig { returns(T.nilable(Date)) }
-      def as_of_date
-      end
+      attr_accessor :as_of_date
 
-      sig { params(_: T.nilable(Date)).returns(T.nilable(Date)) }
-      def as_of_date=(_)
-      end
-
-      sig { returns(T.nilable(String)) }
-      def as_of_time
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def as_of_time=(_)
-      end
+      # The time on which the transaction occurred. Depending on the granularity of the
+      #   timestamp information received from the bank, it may be `null`.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :as_of_time
 
+      # The timezone in which the `as_of_time` is represented. Can be `null` if the bank
+      #   does not provide timezone info.
       sig { returns(T.nilable(String)) }
-      def as_of_timezone
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def as_of_timezone=(_)
-      end
+      attr_accessor :as_of_timezone
 
       sig { returns(Time) }
-      def created_at
-      end
+      attr_accessor :created_at
 
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
-
-      sig { returns(Symbol) }
-      def currency
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def currency=(_)
-      end
+      # Currency that this transaction is denominated in.
+      sig { returns(ModernTreasury::Models::Currency::TaggedSymbol) }
+      attr_accessor :currency
 
+      # An object containing key-value pairs, each with a custom identifier as the key
+      #   and a string value.
       sig { returns(T::Hash[Symbol, String]) }
-      def custom_identifiers
-      end
-
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def custom_identifiers=(_)
-      end
+      attr_accessor :custom_identifiers
 
+      # Either `credit` or `debit`.
       sig { returns(String) }
-      def direction
-      end
-
-      sig { params(_: String).returns(String) }
-      def direction=(_)
-      end
+      attr_accessor :direction
 
       sig { returns(T.nilable(Time)) }
-      def discarded_at
-      end
-
-      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-      def discarded_at=(_)
-      end
+      attr_accessor :discarded_at
 
+      # Associated serialized foreign exchange rate information.
       sig { returns(T.nilable(ModernTreasury::Models::Transaction::ForeignExchangeRate)) }
-      def foreign_exchange_rate
-      end
+      attr_reader :foreign_exchange_rate
 
       sig do
-        params(_: T.nilable(ModernTreasury::Models::Transaction::ForeignExchangeRate))
-          .returns(T.nilable(ModernTreasury::Models::Transaction::ForeignExchangeRate))
-      end
-      def foreign_exchange_rate=(_)
+        params(
+          foreign_exchange_rate: T.nilable(T.any(ModernTreasury::Models::Transaction::ForeignExchangeRate, ModernTreasury::Util::AnyHash))
+        )
+          .void
       end
+      attr_writer :foreign_exchange_rate
 
+      # The ID of the relevant Internal Account.
       sig { returns(String) }
-      def internal_account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def internal_account_id=(_)
-      end
+      attr_accessor :internal_account_id
 
+      # This field will be true if this object exists in the live environment or false
+      #   if it exists in the test environment.
       sig { returns(T::Boolean) }
-      def live_mode
-      end
-
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def live_mode=(_)
-      end
+      attr_accessor :live_mode
 
+      # Additional data represented as key-value pairs. Both the key and value must be
+      #   strings.
       sig { returns(T::Hash[Symbol, String]) }
-      def metadata
-      end
-
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def metadata=(_)
-      end
+      attr_accessor :metadata
 
       sig { returns(String) }
-      def object
-      end
-
-      sig { params(_: String).returns(String) }
-      def object=(_)
-      end
+      attr_accessor :object
 
+      # This field will be `true` if the transaction has posted to the account.
       sig { returns(T::Boolean) }
-      def posted
-      end
-
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def posted=(_)
-      end
+      attr_accessor :posted
 
+      # This field will be `true` if a transaction is reconciled by the Modern Treasury
+      #   system. This means that it has transaction line items that sum up to the
+      #   transaction's amount.
       sig { returns(T::Boolean) }
-      def reconciled
-      end
-
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def reconciled=(_)
-      end
+      attr_accessor :reconciled
 
-      sig { returns(Symbol) }
-      def type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def type=(_)
-      end
+      # The type of the transaction. Examples could be
+      #   `card, `ach`, `wire`, `check`, `rtp`, `book`, or `sen`.
+      sig { returns(ModernTreasury::Models::Transaction::Type::TaggedSymbol) }
+      attr_accessor :type
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      attr_accessor :updated_at
 
+      # When applicable, the bank-given code that determines the transaction's category.
+      #   For most banks this is the BAI2/BTRS transaction code.
       sig { returns(T.nilable(String)) }
-      def vendor_code
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def vendor_code=(_)
-      end
+      attr_accessor :vendor_code
 
-      sig { returns(T.nilable(Symbol)) }
-      def vendor_code_type
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def vendor_code_type=(_)
-      end
+      # The type of `vendor_code` being reported. Can be one of `bai2`, `bankprov`,
+      #   `bnk_dev`, `cleartouch`, `currencycloud`, `cross_river`, `dc_bank`, `dwolla`,
+      #   `evolve`, `goldman_sachs`, `iso20022`, `jpmc`, `mx`, `signet`, `silvergate`,
+      #   `swift`, `us_bank`, or others.
+      sig { returns(T.nilable(ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)) }
+      attr_accessor :vendor_code_type
 
+      # An identifier given to this transaction by the bank, often `null`.
       sig { returns(T.nilable(String)) }
-      def vendor_customer_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def vendor_customer_id=(_)
-      end
+      attr_accessor :vendor_customer_id
 
+      # An identifier given to this transaction by the bank.
       sig { returns(T.nilable(String)) }
-      def vendor_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def vendor_id=(_)
-      end
-
+      attr_accessor :vendor_id
+
+      # This field contains additional information that the bank provided about the
+      #   transaction. This is structured data. Some of the data in here might overlap
+      #   with what is in the `vendor_description`. For example, the OBI could be a part
+      #   of the vendor description, and it would also be included in here. The attributes
+      #   that are passed through the details field will vary based on your banking
+      #   partner. Currently, the following keys may be in the details object:
+      #   `originator_name`, `originator_to_beneficiary_information`.
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
-      def details
-      end
+      attr_reader :details
 
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def details=(_)
-      end
+      sig { params(details: T::Hash[Symbol, String]).void }
+      attr_writer :details
 
+      # The transaction detail text that often appears in on your bank statement and in
+      #   your banking portal.
       sig { returns(T.nilable(String)) }
-      def vendor_description
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def vendor_description=(_)
-      end
+      attr_accessor :vendor_description
 
       sig do
         params(
           id: String,
           amount: Integer,
           as_of_date: T.nilable(Date),
-          as_of_time: T.nilable(String),
+          as_of_time: T.nilable(Time),
           as_of_timezone: T.nilable(String),
           created_at: Time,
-          currency: Symbol,
+          currency: ModernTreasury::Models::Currency::OrSymbol,
           custom_identifiers: T::Hash[Symbol, String],
           direction: String,
           discarded_at: T.nilable(Time),
-          foreign_exchange_rate: T.nilable(ModernTreasury::Models::Transaction::ForeignExchangeRate),
+          foreign_exchange_rate: T.nilable(T.any(ModernTreasury::Models::Transaction::ForeignExchangeRate, ModernTreasury::Util::AnyHash)),
           internal_account_id: String,
           live_mode: T::Boolean,
           metadata: T::Hash[Symbol, String],
           object: String,
           posted: T::Boolean,
           reconciled: T::Boolean,
-          type: Symbol,
+          type: ModernTreasury::Models::Transaction::Type::OrSymbol,
           updated_at: Time,
           vendor_code: T.nilable(String),
-          vendor_code_type: T.nilable(Symbol),
+          vendor_code_type: T.nilable(ModernTreasury::Models::Transaction::VendorCodeType::OrSymbol),
           vendor_customer_id: T.nilable(String),
           vendor_id: T.nilable(String),
           details: T::Hash[Symbol, String],
           vendor_description: T.nilable(String)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         amount:,
         as_of_date:,
@@ -272,10 +195,10 @@ module ModernTreasury
               id: String,
               amount: Integer,
               as_of_date: T.nilable(Date),
-              as_of_time: T.nilable(String),
+              as_of_time: T.nilable(Time),
               as_of_timezone: T.nilable(String),
               created_at: Time,
-              currency: Symbol,
+              currency: ModernTreasury::Models::Currency::TaggedSymbol,
               custom_identifiers: T::Hash[Symbol, String],
               direction: String,
               discarded_at: T.nilable(Time),
@@ -286,10 +209,10 @@ module ModernTreasury
               object: String,
               posted: T::Boolean,
               reconciled: T::Boolean,
-              type: Symbol,
+              type: ModernTreasury::Models::Transaction::Type::TaggedSymbol,
               updated_at: Time,
               vendor_code: T.nilable(String),
-              vendor_code_type: T.nilable(Symbol),
+              vendor_code_type: T.nilable(ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol),
               vendor_customer_id: T.nilable(String),
               vendor_id: T.nilable(String),
               details: T::Hash[Symbol, String],
@@ -301,83 +224,52 @@ module ModernTreasury
       end
 
       class ForeignExchangeRate < ModernTreasury::BaseModel
+        # Amount in the lowest denomination of the `base_currency` to convert, often
+        #   called the "sell" amount.
         sig { returns(Integer) }
-        def base_amount
-        end
+        attr_accessor :base_amount
 
-        sig { params(_: Integer).returns(Integer) }
-        def base_amount=(_)
-        end
-
-        sig { returns(Symbol) }
-        def base_currency
-        end
-
-        sig { params(_: Symbol).returns(Symbol) }
-        def base_currency=(_)
-        end
+        # Currency to convert, often called the "sell" currency.
+        sig { returns(ModernTreasury::Models::Currency::TaggedSymbol) }
+        attr_accessor :base_currency
 
+        # The exponent component of the rate. The decimal is calculated as `value` / (10 ^
+        #   `exponent`).
         sig { returns(Integer) }
-        def exponent
-        end
-
-        sig { params(_: Integer).returns(Integer) }
-        def exponent=(_)
-        end
+        attr_accessor :exponent
 
+        # A string representation of the rate.
         sig { returns(String) }
-        def rate_string
-        end
-
-        sig { params(_: String).returns(String) }
-        def rate_string=(_)
-        end
+        attr_accessor :rate_string
 
+        # Amount in the lowest denomination of the `target_currency`, often called the
+        #   "buy" amount.
         sig { returns(Integer) }
-        def target_amount
-        end
-
-        sig { params(_: Integer).returns(Integer) }
-        def target_amount=(_)
-        end
-
-        sig { returns(Symbol) }
-        def target_currency
-        end
+        attr_accessor :target_amount
 
-        sig { params(_: Symbol).returns(Symbol) }
-        def target_currency=(_)
-        end
+        # Currency to convert the `base_currency` to, often called the "buy" currency.
+        sig { returns(ModernTreasury::Models::Currency::TaggedSymbol) }
+        attr_accessor :target_currency
 
+        # The whole number component of the rate. The decimal is calculated as `value` /
+        #   (10 ^ `exponent`).
         sig { returns(Integer) }
-        def value
-        end
-
-        sig { params(_: Integer).returns(Integer) }
-        def value=(_)
-        end
+        attr_accessor :value
 
+        # Associated serialized foreign exchange rate information.
         sig do
           params(
             base_amount: Integer,
-            base_currency: Symbol,
+            base_currency: ModernTreasury::Models::Currency::OrSymbol,
             exponent: Integer,
             rate_string: String,
             target_amount: Integer,
-            target_currency: Symbol,
+            target_currency: ModernTreasury::Models::Currency::OrSymbol,
             value: Integer
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
-          base_amount:,
-          base_currency:,
-          exponent:,
-          rate_string:,
-          target_amount:,
-          target_currency:,
-          value:
-        )
+        def self.new(base_amount:, base_currency:, exponent:, rate_string:, target_amount:, target_currency:, value:)
         end
 
         sig do
@@ -385,11 +277,11 @@ module ModernTreasury
             .returns(
               {
                 base_amount: Integer,
-                base_currency: Symbol,
+                base_currency: ModernTreasury::Models::Currency::TaggedSymbol,
                 exponent: Integer,
                 rate_string: String,
                 target_amount: Integer,
-                target_currency: Symbol,
+                target_currency: ModernTreasury::Models::Currency::TaggedSymbol,
                 value: Integer
               }
             )
@@ -398,74 +290,88 @@ module ModernTreasury
         end
       end
 
-      class Type < 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
-        OTHER = :other
-
-        sig { override.returns(T::Array[Symbol]) }
+      # The type of the transaction. Examples could be
+      #   `card, `ach`, `wire`, `check`, `rtp`, `book`, or `sen`.
+      module Type
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::Transaction::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, ModernTreasury::Models::Transaction::Type::TaggedSymbol) }
+
+        ACH = T.let(:ach, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        AU_BECS = T.let(:au_becs, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        BACS = T.let(:bacs, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        BOOK = T.let(:book, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        CARD = T.let(:card, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        CHATS = T.let(:chats, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        CHECK = T.let(:check, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        CROSS_BORDER = T.let(:cross_border, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        DK_NETS = T.let(:dk_nets, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        EFT = T.let(:eft, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        HU_ICS = T.let(:hu_ics, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        INTERAC = T.let(:interac, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        MASAV = T.let(:masav, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        MX_CCEN = T.let(:mx_ccen, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        NEFT = T.let(:neft, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        NICS = T.let(:nics, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        NZ_BECS = T.let(:nz_becs, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        PL_ELIXIR = T.let(:pl_elixir, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        PROVXCHANGE = T.let(:provxchange, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        RO_SENT = T.let(:ro_sent, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        RTP = T.let(:rtp, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        SE_BANKGIROT = T.let(:se_bankgirot, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        SEN = T.let(:sen, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        SEPA = T.let(:sepa, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        SG_GIRO = T.let(:sg_giro, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        SIC = T.let(:sic, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        SIGNET = T.let(:signet, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        SKNBI = T.let(:sknbi, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        WIRE = T.let(:wire, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        ZENGIN = T.let(:zengin, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+        OTHER = T.let(:other, ModernTreasury::Models::Transaction::Type::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::Transaction::Type::TaggedSymbol]) }
         def self.values
         end
       end
 
-      class VendorCodeType < ModernTreasury::Enum
-        abstract!
-
-        BAI2 = T.let(:bai2, T.nilable(Symbol))
-        BANKING_CIRCLE = T.let(:banking_circle, T.nilable(Symbol))
-        BANKPROV = T.let(:bankprov, T.nilable(Symbol))
-        BNK_DEV = T.let(:bnk_dev, T.nilable(Symbol))
-        CLEARTOUCH = T.let(:cleartouch, T.nilable(Symbol))
-        COLUMN = T.let(:column, T.nilable(Symbol))
-        CROSS_RIVER = T.let(:cross_river, T.nilable(Symbol))
-        CURRENCYCLOUD = T.let(:currencycloud, T.nilable(Symbol))
-        DC_BANK = T.let(:dc_bank, T.nilable(Symbol))
-        DWOLLA = T.let(:dwolla, T.nilable(Symbol))
-        EVOLVE = T.let(:evolve, T.nilable(Symbol))
-        GOLDMAN_SACHS = T.let(:goldman_sachs, T.nilable(Symbol))
-        ISO20022 = T.let(:iso20022, T.nilable(Symbol))
-        JPMC = T.let(:jpmc, T.nilable(Symbol))
-        MX = T.let(:mx, T.nilable(Symbol))
-        PLAID = T.let(:plaid, T.nilable(Symbol))
-        PNC = T.let(:pnc, T.nilable(Symbol))
-        RSPEC_VENDOR = T.let(:rspec_vendor, T.nilable(Symbol))
-        SIGNET = T.let(:signet, T.nilable(Symbol))
-        SILVERGATE = T.let(:silvergate, T.nilable(Symbol))
-        SWIFT = T.let(:swift, T.nilable(Symbol))
-        US_BANK = T.let(:us_bank, T.nilable(Symbol))
-        USER = T.let(:user, T.nilable(Symbol))
-
-        sig { override.returns(T::Array[Symbol]) }
+      # The type of `vendor_code` being reported. Can be one of `bai2`, `bankprov`,
+      #   `bnk_dev`, `cleartouch`, `currencycloud`, `cross_river`, `dc_bank`, `dwolla`,
+      #   `evolve`, `goldman_sachs`, `iso20022`, `jpmc`, `mx`, `signet`, `silvergate`,
+      #   `swift`, `us_bank`, or others.
+      module VendorCodeType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::Transaction::VendorCodeType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol) }
+
+        BAI2 = T.let(:bai2, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        BANKING_CIRCLE =
+          T.let(:banking_circle, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        BANKPROV = T.let(:bankprov, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        BNK_DEV = T.let(:bnk_dev, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        CLEARTOUCH = T.let(:cleartouch, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        COLUMN = T.let(:column, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        CROSS_RIVER = T.let(:cross_river, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        CURRENCYCLOUD = T.let(:currencycloud, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        DC_BANK = T.let(:dc_bank, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        DWOLLA = T.let(:dwolla, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        EVOLVE = T.let(:evolve, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        GOLDMAN_SACHS = T.let(:goldman_sachs, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        ISO20022 = T.let(:iso20022, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        JPMC = T.let(:jpmc, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        MX = T.let(:mx, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        PLAID = T.let(:plaid, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        PNC = T.let(:pnc, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        RSPEC_VENDOR = T.let(:rspec_vendor, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        SIGNET = T.let(:signet, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        SILVERGATE = T.let(:silvergate, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        SWIFT = T.let(:swift, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        US_BANK = T.let(:us_bank, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+        USER = T.let(:user, ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::Transaction::VendorCodeType::TaggedSymbol]) }
         def self.values
         end
       end