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

data/rbi/lib/modern_treasury/models/transactions/line_item_list_params.rbi

@@ -8,44 +8,28 @@ module ModernTreasury
         include ModernTreasury::RequestParameters
 
         sig { returns(T.nilable(T::Hash[Symbol, String])) }
-        def id
-        end
+        attr_reader :id
 
-        sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-        def id=(_)
-        end
+        sig { params(id: T::Hash[Symbol, String]).void }
+        attr_writer :id
 
         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(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(String)) }
-        def transaction_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def transaction_id=(_)
-        end
+        attr_reader :transaction_id
 
-        sig { returns(T.nilable(Symbol)) }
-        def type
-        end
+        sig { params(transaction_id: String).void }
+        attr_writer :transaction_id
 
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def type=(_)
-        end
+        sig { returns(T.nilable(ModernTreasury::Models::Transactions::LineItemListParams::Type::OrSymbol)) }
+        attr_accessor :type
 
         sig do
           params(
@@ -53,19 +37,12 @@ module ModernTreasury
             after_cursor: T.nilable(String),
             per_page: Integer,
             transaction_id: String,
-            type: T.nilable(Symbol),
-            request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+            type: T.nilable(ModernTreasury::Models::Transactions::LineItemListParams::Type::OrSymbol),
+            request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
-          id: nil,
-          after_cursor: nil,
-          per_page: nil,
-          transaction_id: nil,
-          type: nil,
-          request_options: {}
-        )
+        def self.new(id: nil, after_cursor: nil, per_page: nil, transaction_id: nil, type: nil, request_options: {})
         end
 
         sig do
@@ -76,7 +53,7 @@ module ModernTreasury
                 after_cursor: T.nilable(String),
                 per_page: Integer,
                 transaction_id: String,
-                type: T.nilable(Symbol),
+                type: T.nilable(ModernTreasury::Models::Transactions::LineItemListParams::Type::OrSymbol),
                 request_options: ModernTreasury::RequestOptions
               }
             )
@@ -84,13 +61,20 @@ module ModernTreasury
         def to_hash
         end
 
-        class Type < ModernTreasury::Enum
-          abstract!
+        module Type
+          extend ModernTreasury::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, ModernTreasury::Models::Transactions::LineItemListParams::Type) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, ModernTreasury::Models::Transactions::LineItemListParams::Type::TaggedSymbol) }
 
-          ORIGINATING = T.let(:originating, T.nilable(Symbol))
-          RECEIVING = T.let(:receiving, T.nilable(Symbol))
+          ORIGINATING =
+            T.let(:originating, ModernTreasury::Models::Transactions::LineItemListParams::Type::TaggedSymbol)
+          RECEIVING =
+            T.let(:receiving, ModernTreasury::Models::Transactions::LineItemListParams::Type::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig { override.returns(T::Array[ModernTreasury::Models::Transactions::LineItemListParams::Type::TaggedSymbol]) }
           def self.values
           end
         end

data/rbi/lib/modern_treasury/models/transactions/line_item_retrieve_params.rbi

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

data/rbi/lib/modern_treasury/models/transactions/transaction_line_item.rbi

@@ -2,129 +2,76 @@
 
 module ModernTreasury
   module Models
-    TransactionLineItem = T.type_alias { Transactions::TransactionLineItem }
-
     module Transactions
       class TransactionLineItem < ModernTreasury::BaseModel
         sig { returns(String) }
-        def id
-        end
-
-        sig { params(_: String).returns(String) }
-        def id=(_)
-        end
+        attr_accessor :id
 
+        # If a matching object exists in Modern Treasury, `amount` will be populated.
+        #   Value in specified currency's smallest unit (taken from parent Transaction).
         sig { returns(Integer) }
-        def amount
-        end
-
-        sig { params(_: Integer).returns(Integer) }
-        def amount=(_)
-        end
+        attr_accessor :amount
 
+        # The ID for the counterparty for this transaction line item.
         sig { returns(T.nilable(String)) }
-        def counterparty_id
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def counterparty_id=(_)
-        end
+        attr_accessor :counterparty_id
 
         sig { returns(Time) }
-        def created_at
-        end
-
-        sig { params(_: Time).returns(Time) }
-        def created_at=(_)
-        end
+        attr_accessor :created_at
 
+        # If no matching object is found, `description` will be a free-form text field
+        #   describing the line item. This field may contain personally identifiable
+        #   information (PII) and is not included in API responses by default. Learn more
+        #   about changing your settings at
+        #   https://docs.moderntreasury.com/reference/personally-identifiable-information.
         sig { returns(String) }
-        def description
-        end
-
-        sig { params(_: String).returns(String) }
-        def description=(_)
-        end
+        attr_accessor :description
 
         sig { returns(T.nilable(Time)) }
-        def discarded_at
-        end
-
-        sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-        def discarded_at=(_)
-        end
+        attr_accessor :discarded_at
 
+        # The ID of the reconciled Expected Payment, otherwise `null`.
         sig { returns(T.nilable(String)) }
-        def expected_payment_id
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def expected_payment_id=(_)
-        end
+        attr_accessor :expected_payment_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
 
         sig { returns(String) }
-        def object
-        end
-
-        sig { params(_: String).returns(String) }
-        def object=(_)
-        end
+        attr_accessor :object
 
+        # Describes whether this line item should be counted towards the corresponding
+        #   transaction’s reconciliation.
         sig { returns(T::Boolean) }
-        def reconcilable
-        end
-
-        sig { params(_: T::Boolean).returns(T::Boolean) }
-        def reconcilable=(_)
-        end
+        attr_accessor :reconcilable
 
+        # If a matching object exists in Modern Treasury, the ID will be populated here,
+        #   otherwise `null`.
         sig { returns(T.nilable(String)) }
-        def transactable_id
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def transactable_id=(_)
-        end
-
-        sig { returns(T.nilable(Symbol)) }
-        def transactable_type
-        end
+        attr_accessor :transactable_id
 
-        sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-        def transactable_type=(_)
+        # If a matching object exists in Modern Treasury, the type will be populated here,
+        #   otherwise `null`.
+        sig do
+          returns(
+            T.nilable(ModernTreasury::Models::Transactions::TransactionLineItem::TransactableType::TaggedSymbol)
+          )
         end
+        attr_accessor :transactable_type
 
+        # The ID of the parent transaction.
         sig { returns(String) }
-        def transaction_id
-        end
-
-        sig { params(_: String).returns(String) }
-        def transaction_id=(_)
-        end
-
-        sig { returns(Symbol) }
-        def type
-        end
+        attr_accessor :transaction_id
 
-        sig { params(_: Symbol).returns(Symbol) }
-        def type=(_)
-        end
+        # Indicates whether the line item is `originating` or `receiving` (see
+        #   https://www.moderntreasury.com/journal/beginners-guide-to-ach for more).
+        sig { returns(ModernTreasury::Models::Transactions::TransactionLineItem::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
 
         sig do
           params(
@@ -139,14 +86,14 @@ module ModernTreasury
             object: String,
             reconcilable: T::Boolean,
             transactable_id: T.nilable(String),
-            transactable_type: T.nilable(Symbol),
+            transactable_type: T.nilable(ModernTreasury::Models::Transactions::TransactionLineItem::TransactableType::OrSymbol),
             transaction_id: String,
-            type: Symbol,
+            type: ModernTreasury::Models::Transactions::TransactionLineItem::Type::OrSymbol,
             updated_at: Time
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           id:,
           amount:,
           counterparty_id:,
@@ -180,9 +127,9 @@ module ModernTreasury
                 object: String,
                 reconcilable: T::Boolean,
                 transactable_id: T.nilable(String),
-                transactable_type: T.nilable(Symbol),
+                transactable_type: T.nilable(ModernTreasury::Models::Transactions::TransactionLineItem::TransactableType::TaggedSymbol),
                 transaction_id: String,
-                type: Symbol,
+                type: ModernTreasury::Models::Transactions::TransactionLineItem::Type::TaggedSymbol,
                 updated_at: Time
               }
             )
@@ -190,32 +137,76 @@ module ModernTreasury
         def to_hash
         end
 
-        class TransactableType < ModernTreasury::Enum
-          abstract!
+        # If a matching object exists in Modern Treasury, the type will be populated here,
+        #   otherwise `null`.
+        module TransactableType
+          extend ModernTreasury::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, ModernTreasury::Models::Transactions::TransactionLineItem::TransactableType) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, ModernTreasury::Models::Transactions::TransactionLineItem::TransactableType::TaggedSymbol) }
 
-          INCOMING_PAYMENT_DETAIL = T.let(:incoming_payment_detail, T.nilable(Symbol))
-          PAPER_ITEM = T.let(:paper_item, T.nilable(Symbol))
-          PAYMENT_ORDER = T.let(:payment_order, T.nilable(Symbol))
-          PAYMENT_ORDER_ATTEMPT = T.let(:payment_order_attempt, T.nilable(Symbol))
-          RETURN = T.let(:return, T.nilable(Symbol))
-          REVERSAL = T.let(:reversal, T.nilable(Symbol))
+          INCOMING_PAYMENT_DETAIL =
+            T.let(
+              :incoming_payment_detail,
+              ModernTreasury::Models::Transactions::TransactionLineItem::TransactableType::TaggedSymbol
+            )
+          PAPER_ITEM =
+            T.let(
+              :paper_item,
+              ModernTreasury::Models::Transactions::TransactionLineItem::TransactableType::TaggedSymbol
+            )
+          PAYMENT_ORDER =
+            T.let(
+              :payment_order,
+              ModernTreasury::Models::Transactions::TransactionLineItem::TransactableType::TaggedSymbol
+            )
+          PAYMENT_ORDER_ATTEMPT =
+            T.let(
+              :payment_order_attempt,
+              ModernTreasury::Models::Transactions::TransactionLineItem::TransactableType::TaggedSymbol
+            )
+          RETURN =
+            T.let(:return, ModernTreasury::Models::Transactions::TransactionLineItem::TransactableType::TaggedSymbol)
+          REVERSAL =
+            T.let(
+              :reversal,
+              ModernTreasury::Models::Transactions::TransactionLineItem::TransactableType::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig do
+            override
+              .returns(
+                T::Array[ModernTreasury::Models::Transactions::TransactionLineItem::TransactableType::TaggedSymbol]
+              )
+          end
           def self.values
           end
         end
 
-        class Type < ModernTreasury::Enum
-          abstract!
+        # Indicates whether the line item is `originating` or `receiving` (see
+        #   https://www.moderntreasury.com/journal/beginners-guide-to-ach for more).
+        module Type
+          extend ModernTreasury::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, ModernTreasury::Models::Transactions::TransactionLineItem::Type) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, ModernTreasury::Models::Transactions::TransactionLineItem::Type::TaggedSymbol) }
 
-          ORIGINATING = :originating
-          RECEIVING = :receiving
+          ORIGINATING =
+            T.let(:originating, ModernTreasury::Models::Transactions::TransactionLineItem::Type::TaggedSymbol)
+          RECEIVING =
+            T.let(:receiving, ModernTreasury::Models::Transactions::TransactionLineItem::Type::TaggedSymbol)
 
-          sig { override.returns(T::Array[Symbol]) }
+          sig { override.returns(T::Array[ModernTreasury::Models::Transactions::TransactionLineItem::Type::TaggedSymbol]) }
           def self.values
           end
         end
       end
     end
+
+    TransactionLineItem = Transactions::TransactionLineItem
   end
 end

data/rbi/lib/modern_treasury/models/validation_validate_routing_number_params.rbi

@@ -6,31 +6,26 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # The routing number that is being validated.
       sig { returns(String) }
-      def routing_number
-      end
-
-      sig { params(_: String).returns(String) }
-      def routing_number=(_)
-      end
-
-      sig { returns(Symbol) }
-      def routing_number_type
-      end
+      attr_accessor :routing_number
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def routing_number_type=(_)
-      end
+      # The type of routing number. See
+      #   https://docs.moderntreasury.com/platform/reference/routing-detail-object for
+      #   more details. In sandbox mode we currently only support `aba` and `swift` with
+      #   routing numbers '123456789' and 'GRINUST0XXX' respectively.
+      sig { returns(ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::OrSymbol) }
+      attr_accessor :routing_number_type
 
       sig do
         params(
           routing_number: String,
-          routing_number_type: Symbol,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          routing_number_type: ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::OrSymbol,
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(routing_number:, routing_number_type:, request_options: {})
+      def self.new(routing_number:, routing_number_type:, request_options: {})
       end
 
       sig do
@@ -38,7 +33,7 @@ module ModernTreasury
           .returns(
             {
               routing_number: String,
-              routing_number_type: Symbol,
+              routing_number_type: ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::OrSymbol,
               request_options: ModernTreasury::RequestOptions
             }
           )
@@ -46,32 +41,135 @@ module ModernTreasury
       def to_hash
       end
 
-      class RoutingNumberType < ModernTreasury::Enum
-        abstract!
+      # The type of routing number. See
+      #   https://docs.moderntreasury.com/platform/reference/routing-detail-object for
+      #   more details. In sandbox mode we currently only support `aba` and `swift` with
+      #   routing numbers '123456789' and 'GRINUST0XXX' respectively.
+      module RoutingNumberType
+        extend ModernTreasury::Enum
 
-        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
-        MX_BANK_IDENTIFIER = :mx_bank_identifier
-        MY_BRANCH_CODE = :my_branch_code
-        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
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType) }
+        OrSymbol =
+          T.type_alias do
+            T.any(
+              Symbol,
+              ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+            )
+          end
 
-        sig { override.returns(T::Array[Symbol]) }
+        ABA =
+          T.let(
+            :aba,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        AU_BSB =
+          T.let(
+            :au_bsb,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        BR_CODIGO =
+          T.let(
+            :br_codigo,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        CA_CPA =
+          T.let(
+            :ca_cpa,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        CHIPS =
+          T.let(
+            :chips,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        CNAPS =
+          T.let(
+            :cnaps,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        DK_INTERBANK_CLEARING_CODE =
+          T.let(
+            :dk_interbank_clearing_code,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        GB_SORT_CODE =
+          T.let(
+            :gb_sort_code,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        HK_INTERBANK_CLEARING_CODE =
+          T.let(
+            :hk_interbank_clearing_code,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        HU_INTERBANK_CLEARING_CODE =
+          T.let(
+            :hu_interbank_clearing_code,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        ID_SKNBI_CODE =
+          T.let(
+            :id_sknbi_code,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        IN_IFSC =
+          T.let(
+            :in_ifsc,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        JP_ZENGIN_CODE =
+          T.let(
+            :jp_zengin_code,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        MX_BANK_IDENTIFIER =
+          T.let(
+            :mx_bank_identifier,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        MY_BRANCH_CODE =
+          T.let(
+            :my_branch_code,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        NZ_NATIONAL_CLEARING_CODE =
+          T.let(
+            :nz_national_clearing_code,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        PL_NATIONAL_CLEARING_CODE =
+          T.let(
+            :pl_national_clearing_code,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        SE_BANKGIRO_CLEARING_CODE =
+          T.let(
+            :se_bankgiro_clearing_code,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        SG_INTERBANK_CLEARING_CODE =
+          T.let(
+            :sg_interbank_clearing_code,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        SWIFT =
+          T.let(
+            :swift,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+        ZA_NATIONAL_CLEARING_CODE =
+          T.let(
+            :za_national_clearing_code,
+            ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol
+          )
+
+        sig do
+          override
+            .returns(
+              T::Array[ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::TaggedSymbol]
+            )
+        end
         def self.values
         end
       end