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

data/rbi/lib/modern_treasury/models/payment_order_list_params.rbi

@@ -2,145 +2,122 @@
 
 module ModernTreasury
   module Models
-    class PaymentOrderListParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class PaymentOrderListParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
 
       sig { returns(T.nilable(String)) }
-      def after_cursor
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def after_cursor=(_)
-      end
+      attr_accessor :after_cursor
 
       sig { returns(T.nilable(String)) }
-      def counterparty_id
-      end
+      attr_reader :counterparty_id
 
-      sig { params(_: String).returns(String) }
-      def counterparty_id=(_)
-      end
+      sig { params(counterparty_id: String).void }
+      attr_writer :counterparty_id
 
+      # An inclusive upper bound for searching created_at
       sig { returns(T.nilable(Date)) }
-      def created_at_end
-      end
+      attr_reader :created_at_end
 
-      sig { params(_: Date).returns(Date) }
-      def created_at_end=(_)
-      end
+      sig { params(created_at_end: Date).void }
+      attr_writer :created_at_end
 
+      # An inclusive lower bound for searching created_at
       sig { returns(T.nilable(Date)) }
-      def created_at_start
-      end
+      attr_reader :created_at_start
 
-      sig { params(_: Date).returns(Date) }
-      def created_at_start=(_)
-      end
+      sig { params(created_at_start: Date).void }
+      attr_writer :created_at_start
 
-      sig { returns(T.nilable(Symbol)) }
-      def direction
-      end
+      sig { returns(T.nilable(ModernTreasury::Models::TransactionDirection::OrSymbol)) }
+      attr_reader :direction
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def direction=(_)
-      end
+      sig { params(direction: ModernTreasury::Models::TransactionDirection::OrSymbol).void }
+      attr_writer :direction
 
+      # An inclusive upper bound for searching effective_date
       sig { returns(T.nilable(Date)) }
-      def effective_date_end
-      end
+      attr_reader :effective_date_end
 
-      sig { params(_: Date).returns(Date) }
-      def effective_date_end=(_)
-      end
+      sig { params(effective_date_end: Date).void }
+      attr_writer :effective_date_end
 
+      # An inclusive lower bound for searching effective_date
       sig { returns(T.nilable(Date)) }
-      def effective_date_start
-      end
+      attr_reader :effective_date_start
 
-      sig { params(_: Date).returns(Date) }
-      def effective_date_start=(_)
-      end
+      sig { params(effective_date_start: Date).void }
+      attr_writer :effective_date_start
 
+      # For example, if you want to query for records with metadata key `Type` and value
+      # `Loan`, the query would be `metadata%5BType%5D=Loan`. This encodes the query
+      # parameters.
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
-      def metadata
-      end
+      attr_reader :metadata
 
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def metadata=(_)
-      end
+      sig { params(metadata: T::Hash[Symbol, String]).void }
+      attr_writer :metadata
 
       sig { returns(T.nilable(String)) }
-      def originating_account_id
-      end
+      attr_reader :originating_account_id
 
-      sig { params(_: String).returns(String) }
-      def originating_account_id=(_)
-      end
+      sig { params(originating_account_id: String).void }
+      attr_writer :originating_account_id
 
       sig { returns(T.nilable(Integer)) }
-      def per_page
-      end
+      attr_reader :per_page
 
-      sig { params(_: Integer).returns(Integer) }
-      def per_page=(_)
-      end
+      sig { params(per_page: Integer).void }
+      attr_writer :per_page
 
-      sig { returns(T.nilable(Symbol)) }
-      def priority
-      end
+      # 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::PaymentOrderListParams::Priority::OrSymbol)) }
+      attr_reader :priority
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def priority=(_)
-      end
+      sig { params(priority: ModernTreasury::Models::PaymentOrderListParams::Priority::OrSymbol).void }
+      attr_writer :priority
 
+      # An inclusive upper bound for searching process_after
       sig { returns(T.nilable(Time)) }
-      def process_after_end
-      end
+      attr_reader :process_after_end
 
-      sig { params(_: Time).returns(Time) }
-      def process_after_end=(_)
-      end
+      sig { params(process_after_end: Time).void }
+      attr_writer :process_after_end
 
+      # An inclusive lower bound for searching process_after
       sig { returns(T.nilable(Time)) }
-      def process_after_start
-      end
+      attr_reader :process_after_start
 
-      sig { params(_: Time).returns(Time) }
-      def process_after_start=(_)
-      end
+      sig { params(process_after_start: Time).void }
+      attr_writer :process_after_start
 
+      # Query for records with the provided reference number
       sig { returns(T.nilable(String)) }
-      def reference_number
-      end
+      attr_reader :reference_number
 
-      sig { params(_: String).returns(String) }
-      def reference_number=(_)
-      end
+      sig { params(reference_number: String).void }
+      attr_writer :reference_number
 
-      sig { returns(T.nilable(Symbol)) }
-      def status
-      end
+      sig { returns(T.nilable(ModernTreasury::Models::PaymentOrderListParams::Status::OrSymbol)) }
+      attr_reader :status
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def status=(_)
-      end
+      sig { params(status: ModernTreasury::Models::PaymentOrderListParams::Status::OrSymbol).void }
+      attr_writer :status
 
+      # The ID of a transaction that the payment order has been reconciled to.
       sig { returns(T.nilable(String)) }
-      def transaction_id
-      end
+      attr_reader :transaction_id
 
-      sig { params(_: String).returns(String) }
-      def transaction_id=(_)
-      end
+      sig { params(transaction_id: String).void }
+      attr_writer :transaction_id
 
-      sig { returns(T.nilable(Symbol)) }
-      def type
-      end
+      sig { returns(T.nilable(ModernTreasury::Models::PaymentOrderListParams::Type::OrSymbol)) }
+      attr_reader :type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def type=(_)
-      end
+      sig { params(type: ModernTreasury::Models::PaymentOrderListParams::Type::OrSymbol).void }
+      attr_writer :type
 
       sig do
         params(
@@ -148,24 +125,24 @@ module ModernTreasury
           counterparty_id: String,
           created_at_end: Date,
           created_at_start: Date,
-          direction: Symbol,
+          direction: ModernTreasury::Models::TransactionDirection::OrSymbol,
           effective_date_end: Date,
           effective_date_start: Date,
           metadata: T::Hash[Symbol, String],
           originating_account_id: String,
           per_page: Integer,
-          priority: Symbol,
+          priority: ModernTreasury::Models::PaymentOrderListParams::Priority::OrSymbol,
           process_after_end: Time,
           process_after_start: Time,
           reference_number: String,
-          status: Symbol,
+          status: ModernTreasury::Models::PaymentOrderListParams::Status::OrSymbol,
           transaction_id: String,
-          type: Symbol,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          type: ModernTreasury::Models::PaymentOrderListParams::Type::OrSymbol,
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         after_cursor: nil,
         counterparty_id: nil,
         created_at_end: nil,
@@ -184,9 +161,7 @@ module ModernTreasury
         transaction_id: nil,
         type: nil,
         request_options: {}
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -195,94 +170,106 @@ module ModernTreasury
               counterparty_id: String,
               created_at_end: Date,
               created_at_start: Date,
-              direction: Symbol,
+              direction: ModernTreasury::Models::TransactionDirection::OrSymbol,
               effective_date_end: Date,
               effective_date_start: Date,
               metadata: T::Hash[Symbol, String],
               originating_account_id: String,
               per_page: Integer,
-              priority: Symbol,
+              priority: ModernTreasury::Models::PaymentOrderListParams::Priority::OrSymbol,
               process_after_end: Time,
               process_after_start: Time,
               reference_number: String,
-              status: Symbol,
+              status: ModernTreasury::Models::PaymentOrderListParams::Status::OrSymbol,
               transaction_id: String,
-              type: Symbol,
+              type: ModernTreasury::Models::PaymentOrderListParams::Type::OrSymbol,
               request_options: ModernTreasury::RequestOptions
             }
           )
       end
-      def to_hash
-      end
-
-      class Priority < ModernTreasury::Enum
-        abstract!
-
-        HIGH = :high
-        NORMAL = :normal
-
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
-      end
-
-      class Status < ModernTreasury::Enum
-        abstract!
-
-        APPROVED = :approved
-        CANCELLED = :cancelled
-        COMPLETED = :completed
-        DENIED = :denied
-        FAILED = :failed
-        NEEDS_APPROVAL = :needs_approval
-        PENDING = :pending
-        PROCESSING = :processing
-        RETURNED = :returned
-        REVERSED = :reversed
-        SENT = :sent
-
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        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
-
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+      def to_hash; end
+
+      # 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::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderListParams::Priority) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::PaymentOrderListParams::Priority::TaggedSymbol) }
+
+        HIGH = T.let(:high, ModernTreasury::Models::PaymentOrderListParams::Priority::TaggedSymbol)
+        NORMAL = T.let(:normal, ModernTreasury::Models::PaymentOrderListParams::Priority::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::PaymentOrderListParams::Priority::TaggedSymbol]) }
+        def self.values; end
+      end
+
+      module Status
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderListParams::Status) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol) }
+
+        APPROVED = T.let(:approved, ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol)
+        CANCELLED = T.let(:cancelled, ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol)
+        COMPLETED = T.let(:completed, ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol)
+        DENIED = T.let(:denied, ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol)
+        FAILED = T.let(:failed, ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol)
+        NEEDS_APPROVAL =
+          T.let(:needs_approval, ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol)
+        PENDING = T.let(:pending, ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol)
+        PROCESSING = T.let(:processing, ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol)
+        RETURNED = T.let(:returned, ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol)
+        REVERSED = T.let(:reversed, ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol)
+        SENT = T.let(:sent, ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::PaymentOrderListParams::Status::TaggedSymbol]) }
+        def self.values; end
+      end
+
+      module Type
+        extend ModernTreasury::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderListParams::Type) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol) }
+
+        ACH = T.let(:ach, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        AU_BECS = T.let(:au_becs, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        BACS = T.let(:bacs, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        BOOK = T.let(:book, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        CARD = T.let(:card, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        CHATS = T.let(:chats, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        CHECK = T.let(:check, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        CROSS_BORDER = T.let(:cross_border, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        DK_NETS = T.let(:dk_nets, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        EFT = T.let(:eft, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        HU_ICS = T.let(:hu_ics, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        INTERAC = T.let(:interac, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        MASAV = T.let(:masav, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        MX_CCEN = T.let(:mx_ccen, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        NEFT = T.let(:neft, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        NICS = T.let(:nics, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        NZ_BECS = T.let(:nz_becs, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        PL_ELIXIR = T.let(:pl_elixir, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        PROVXCHANGE = T.let(:provxchange, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        RO_SENT = T.let(:ro_sent, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        RTP = T.let(:rtp, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        SE_BANKGIROT = T.let(:se_bankgirot, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        SEN = T.let(:sen, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        SEPA = T.let(:sepa, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        SG_GIRO = T.let(:sg_giro, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        SIC = T.let(:sic, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        SIGNET = T.let(:signet, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        SKNBI = T.let(:sknbi, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        WIRE = T.let(:wire, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+        ZENGIN = T.let(:zengin, ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::PaymentOrderListParams::Type::TaggedSymbol]) }
+        def self.values; end
       end
     end
   end

data/rbi/lib/modern_treasury/models/payment_order_retrieve_params.rbi

@@ -2,17 +2,18 @@
 
 module ModernTreasury
   module Models
-    class PaymentOrderRetrieveParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class PaymentOrderRetrieveParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
 
-      sig { params(request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])).void }
-      def initialize(request_options: {})
+      sig do
+        params(request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
+          .returns(T.attached_class)
       end
+      def self.new(request_options: {}); end
 
       sig { override.returns({request_options: ModernTreasury::RequestOptions}) }
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/modern_treasury/models/payment_order_subtype.rbi

@@ -2,42 +2,49 @@
 
 module ModernTreasury
   module Models
-    class PaymentOrderSubtype < ModernTreasury::Enum
-      abstract!
+    # 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`.
+    module PaymentOrderSubtype
+      extend ModernTreasury::Internal::Type::Enum
 
-      BACS_NEW_INSTRUCTION = T.let(:"0C", T.nilable(Symbol))
-      BACS_CANCELLATION_INSTRUCTION = T.let(:"0N", T.nilable(Symbol))
-      BACS_CONVERSION_INSTRUCTION = T.let(:"0S", T.nilable(Symbol))
-      CCD = T.let(:CCD, T.nilable(Symbol))
-      CIE = T.let(:CIE, T.nilable(Symbol))
-      CTX = T.let(:CTX, T.nilable(Symbol))
-      IAT = T.let(:IAT, T.nilable(Symbol))
-      PPD = T.let(:PPD, T.nilable(Symbol))
-      TEL = T.let(:TEL, T.nilable(Symbol))
-      WEB = T.let(:WEB, T.nilable(Symbol))
-      AU_BECS = T.let(:au_becs, T.nilable(Symbol))
-      BACS = T.let(:bacs, T.nilable(Symbol))
-      CHATS = T.let(:chats, T.nilable(Symbol))
-      DK_NETS = T.let(:dk_nets, T.nilable(Symbol))
-      EFT = T.let(:eft, T.nilable(Symbol))
-      HU_ICS = T.let(:hu_ics, T.nilable(Symbol))
-      MASAV = T.let(:masav, T.nilable(Symbol))
-      MX_CCEN = T.let(:mx_ccen, T.nilable(Symbol))
-      NEFT = T.let(:neft, T.nilable(Symbol))
-      NICS = T.let(:nics, T.nilable(Symbol))
-      NZ_BECS = T.let(:nz_becs, T.nilable(Symbol))
-      PL_ELIXIR = T.let(:pl_elixir, T.nilable(Symbol))
-      RO_SENT = T.let(:ro_sent, T.nilable(Symbol))
-      SE_BANKGIROT = T.let(:se_bankgirot, T.nilable(Symbol))
-      SEPA = T.let(:sepa, T.nilable(Symbol))
-      SG_GIRO = T.let(:sg_giro, T.nilable(Symbol))
-      SIC = T.let(:sic, T.nilable(Symbol))
-      SKNBI = T.let(:sknbi, T.nilable(Symbol))
-      ZENGIN = T.let(:zengin, T.nilable(Symbol))
+      TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderSubtype) }
+      OrSymbol =
+        T.type_alias { T.any(Symbol, String, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol) }
 
-      sig { override.returns(T::Array[Symbol]) }
-      def self.values
-      end
+      BACS_NEW_INSTRUCTION = T.let(:"0C", ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      BACS_CANCELLATION_INSTRUCTION = T.let(:"0N", ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      BACS_CONVERSION_INSTRUCTION = T.let(:"0S", ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      CCD = T.let(:CCD, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      CIE = T.let(:CIE, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      CTX = T.let(:CTX, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      IAT = T.let(:IAT, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      PPD = T.let(:PPD, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      TEL = T.let(:TEL, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      WEB = T.let(:WEB, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      AU_BECS = T.let(:au_becs, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      BACS = T.let(:bacs, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      CHATS = T.let(:chats, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      DK_NETS = T.let(:dk_nets, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      EFT = T.let(:eft, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      HU_ICS = T.let(:hu_ics, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      MASAV = T.let(:masav, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      MX_CCEN = T.let(:mx_ccen, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      NEFT = T.let(:neft, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      NICS = T.let(:nics, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      NZ_BECS = T.let(:nz_becs, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      PL_ELIXIR = T.let(:pl_elixir, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      RO_SENT = T.let(:ro_sent, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      SE_BANKGIROT = T.let(:se_bankgirot, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      SEPA = T.let(:sepa, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      SG_GIRO = T.let(:sg_giro, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      SIC = T.let(:sic, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      SKNBI = T.let(:sknbi, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+      ZENGIN = T.let(:zengin, ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol)
+
+      sig { override.returns(T::Array[ModernTreasury::Models::PaymentOrderSubtype::TaggedSymbol]) }
+      def self.values; end
     end
   end
 end

data/rbi/lib/modern_treasury/models/payment_order_type.rbi

@@ -2,43 +2,48 @@
 
 module ModernTreasury
   module Models
-    class PaymentOrderType < ModernTreasury::Enum
-      abstract!
+    # 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`.
+    module PaymentOrderType
+      extend ModernTreasury::Internal::Type::Enum
 
-      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
+      TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::PaymentOrderType) }
+      OrSymbol = T.type_alias { T.any(Symbol, String, ModernTreasury::Models::PaymentOrderType::TaggedSymbol) }
 
-      sig { override.returns(T::Array[Symbol]) }
-      def self.values
-      end
+      ACH = T.let(:ach, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      AU_BECS = T.let(:au_becs, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      BACS = T.let(:bacs, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      BOOK = T.let(:book, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      CARD = T.let(:card, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      CHATS = T.let(:chats, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      CHECK = T.let(:check, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      CROSS_BORDER = T.let(:cross_border, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      DK_NETS = T.let(:dk_nets, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      EFT = T.let(:eft, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      HU_ICS = T.let(:hu_ics, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      INTERAC = T.let(:interac, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      MASAV = T.let(:masav, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      MX_CCEN = T.let(:mx_ccen, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      NEFT = T.let(:neft, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      NICS = T.let(:nics, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      NZ_BECS = T.let(:nz_becs, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      PL_ELIXIR = T.let(:pl_elixir, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      PROVXCHANGE = T.let(:provxchange, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      RO_SENT = T.let(:ro_sent, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      RTP = T.let(:rtp, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      SE_BANKGIROT = T.let(:se_bankgirot, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      SEN = T.let(:sen, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      SEPA = T.let(:sepa, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      SG_GIRO = T.let(:sg_giro, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      SIC = T.let(:sic, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      SIGNET = T.let(:signet, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      SKNBI = T.let(:sknbi, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      WIRE = T.let(:wire, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+      ZENGIN = T.let(:zengin, ModernTreasury::Models::PaymentOrderType::TaggedSymbol)
+
+      sig { override.returns(T::Array[ModernTreasury::Models::PaymentOrderType::TaggedSymbol]) }
+      def self.values; end
     end
   end
 end