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

data/rbi/lib/modern_treasury/resources/payment_references.rbi

@@ -3,50 +3,47 @@
 module ModernTreasury
   module Resources
     class PaymentReferences
+      # get payment_reference
       sig do
         params(
           id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::PaymentReference)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # id
+        id,
+        request_options: {}
+      ); end
+      # list payment_references
       sig do
         params(
           after_cursor: T.nilable(String),
           per_page: Integer,
           reference_number: String,
           referenceable_id: String,
-          referenceable_type: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          referenceable_type: ModernTreasury::Models::PaymentReferenceListParams::ReferenceableType::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
-          .returns(ModernTreasury::Page[ModernTreasury::Models::PaymentReference])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::PaymentReference])
       end
       def list(
         after_cursor: nil,
         per_page: nil,
+        # The actual reference number assigned by the bank.
         reference_number: nil,
+        # The id of the referenceable to search for. Must be accompanied by the
+        # referenceable_type or will return an error.
         referenceable_id: nil,
+        # One of the referenceable types. This must be accompanied by the id of the
+        # referenceable or will return an error.
         referenceable_type: nil,
         request_options: {}
-      )
-      end
-
-      sig do
-        params(
-          id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
-        )
-          .returns(ModernTreasury::Models::PaymentReference)
-      end
-      def retireve(id, request_options: {})
-      end
-
-      sig { params(client: ModernTreasury::Client).void }
-      def initialize(client:)
-      end
+      ); end
+      # @api private
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:); end
     end
   end
 end

data/rbi/lib/modern_treasury/resources/returns.rbi

@@ -3,39 +3,55 @@
 module ModernTreasury
   module Resources
     class Returns
+      # Create a return.
       sig do
         params(
           returnable_id: T.nilable(String),
-          returnable_type: Symbol,
+          returnable_type: ModernTreasury::Models::ReturnCreateParams::ReturnableType::OrSymbol,
           additional_information: T.nilable(String),
-          code: T.nilable(Symbol),
+          code: T.nilable(ModernTreasury::Models::ReturnCreateParams::Code::OrSymbol),
+          data: T.nilable(T.anything),
           date_of_death: T.nilable(Date),
           reason: T.nilable(String),
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::ReturnObject)
       end
       def create(
+        # The ID of the object being returned or `null`.
         returnable_id:,
+        # The type of object being returned. Currently, this may only be
+        # incoming_payment_detail.
         returnable_type:,
+        # Some returns may include additional information from the bank. In these cases,
+        # this string will be present.
         additional_information: nil,
+        # The return code. For ACH returns, this is the required ACH return code.
         code: nil,
+        # The raw data from the return file that we get from the bank.
+        data: nil,
+        # If the return code is `R14` or `R15` this is the date the deceased counterparty
+        # passed away.
         date_of_death: nil,
+        # An optional description of the reason for the return. This is for internal usage
+        # and will not be transmitted to the bank.”
         reason: nil,
         request_options: {}
-      )
-      end
-
+      ); end
+      # Get a single return.
       sig do
         params(
           id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::ReturnObject)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # The ID of an existing return.
+        id,
+        request_options: {}
+      ); end
+      # Get a list of returns.
       sig do
         params(
           after_cursor: T.nilable(String),
@@ -43,25 +59,30 @@ module ModernTreasury
           internal_account_id: String,
           per_page: Integer,
           returnable_id: String,
-          returnable_type: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          returnable_type: ModernTreasury::Models::ReturnListParams::ReturnableType::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
-          .returns(ModernTreasury::Page[ModernTreasury::Models::ReturnObject])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::ReturnObject])
       end
       def list(
         after_cursor: nil,
+        # Specify `counterparty_id` if you wish to see returns that occurred with a
+        # specific counterparty.
         counterparty_id: nil,
+        # Specify `internal_account_id` if you wish to see returns to/from a specific
+        # account.
         internal_account_id: nil,
         per_page: nil,
+        # The ID of a valid returnable. Must be accompanied by `returnable_type`.
         returnable_id: nil,
+        # One of `payment_order`, `paper_item`, `reversal`, or `incoming_payment_detail`.
+        # Must be accompanied by `returnable_id`.
         returnable_type: nil,
         request_options: {}
-      )
-      end
-
-      sig { params(client: ModernTreasury::Client).void }
-      def initialize(client:)
-      end
+      ); end
+      # @api private
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:); end
     end
   end
 end

data/rbi/lib/modern_treasury/resources/routing_details.rbi

@@ -3,67 +3,95 @@
 module ModernTreasury
   module Resources
     class RoutingDetails
+      # Create a routing detail for a single external account.
       sig do
         params(
           account_id: String,
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::RoutingDetailCreateParams::AccountsType::OrSymbol,
           routing_number: String,
-          routing_number_type: Symbol,
-          payment_type: T.nilable(Symbol),
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          routing_number_type: ModernTreasury::Models::RoutingDetailCreateParams::RoutingNumberType::OrSymbol,
+          payment_type: T.nilable(ModernTreasury::Models::RoutingDetailCreateParams::PaymentType::OrSymbol),
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::RoutingDetail)
       end
       def create(
+        # Path param: The ID of the account.
         account_id,
+        # Path param:
         accounts_type:,
+        # Body param: The routing number of the bank.
         routing_number:,
+        # Body param: The type of routing number. See
+        # https://docs.moderntreasury.com/platform/reference/routing-detail-object for
+        # more details.
         routing_number_type:,
+        # Body param: If the routing detail is to be used for a specific payment type this
+        # field will be populated, otherwise null.
         payment_type: nil,
         request_options: {}
-      )
-      end
-
+      ); end
+      # Get a single routing detail for a single internal or external account.
       sig do
         params(
           id: String,
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::AccountsType::OrSymbol,
           account_id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::RoutingDetail)
       end
-      def retrieve(id, accounts_type:, account_id:, request_options: {})
-      end
-
+      def retrieve(
+        # The ID of the routing detail.
+        id,
+        accounts_type:,
+        # The ID of the account.
+        account_id:,
+        request_options: {}
+      ); end
+      # Get a list of routing details for a single internal or external account.
       sig do
         params(
           account_id: String,
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::AccountsType::OrSymbol,
           after_cursor: T.nilable(String),
           per_page: Integer,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
-          .returns(ModernTreasury::Page[ModernTreasury::Models::RoutingDetail])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::RoutingDetail])
       end
-      def list(account_id, accounts_type:, after_cursor: nil, per_page: nil, request_options: {})
-      end
-
+      def list(
+        # Path param: The ID of the account.
+        account_id,
+        # Path param:
+        accounts_type:,
+        # Query param:
+        after_cursor: nil,
+        # Query param:
+        per_page: nil,
+        request_options: {}
+      ); end
+      # Delete a routing detail for a single external account.
       sig do
         params(
           id: String,
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::RoutingDetailDeleteParams::AccountsType::OrSymbol,
           account_id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .void
       end
-      def delete(id, accounts_type:, account_id:, request_options: {})
-      end
-
-      sig { params(client: ModernTreasury::Client).void }
-      def initialize(client:)
-      end
+      def delete(
+        # The ID of the routing detail.
+        id,
+        accounts_type:,
+        # The ID of the account.
+        account_id:,
+        request_options: {}
+      ); end
+      # @api private
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:); end
     end
   end
 end

data/rbi/lib/modern_treasury/resources/transactions/line_items.rbi

@@ -4,38 +4,65 @@ module ModernTreasury
   module Resources
     class Transactions
       class LineItems
+        # create transaction line items
         sig do
           params(
             amount: Integer,
             expected_payment_id: String,
             transaction_id: String,
-            request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(
+              T.any(
+                ModernTreasury::RequestOptions,
+                ModernTreasury::Internal::AnyHash
+              )
+            )
           )
             .returns(ModernTreasury::Models::Transactions::TransactionLineItem)
         end
-        def create(amount:, expected_payment_id:, transaction_id:, request_options: {})
-        end
-
+        def create(
+          # If a matching object exists in Modern Treasury, `amount` will be populated.
+          # Value in specified currency's smallest unit (taken from parent Transaction).
+          amount:,
+          # The ID of the reconciled Expected Payment, otherwise `null`.
+          expected_payment_id:,
+          # The ID of the parent transaction.
+          transaction_id:,
+          request_options: {}
+        ); end
+        # get transaction line item
         sig do
           params(
             id: String,
-            request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(
+              T.any(
+                ModernTreasury::RequestOptions,
+                ModernTreasury::Internal::AnyHash
+              )
+            )
           )
             .returns(ModernTreasury::Models::Transactions::TransactionLineItem)
         end
-        def retrieve(id, request_options: {})
-        end
-
+        def retrieve(
+          # id
+          id,
+          request_options: {}
+        ); end
+        # list transaction_line_items
         sig do
           params(
             id: T::Hash[Symbol, String],
             after_cursor: T.nilable(String),
             per_page: Integer,
             transaction_id: String,
-            type: T.nilable(Symbol),
-            request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+            type: T.nilable(ModernTreasury::Models::Transactions::LineItemListParams::Type::OrSymbol),
+            request_options: T.nilable(
+              T.any(
+                ModernTreasury::RequestOptions,
+                ModernTreasury::Internal::AnyHash
+              )
+            )
           )
-            .returns(ModernTreasury::Page[ModernTreasury::Models::Transactions::TransactionLineItem])
+            .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::Transactions::TransactionLineItem])
         end
         def list(
           id: nil,
@@ -47,19 +74,27 @@ module ModernTreasury
         )
         end
 
+        # delete transaction line item
         sig do
           params(
             id: String,
-            request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+            request_options: T.nilable(
+              T.any(
+                ModernTreasury::RequestOptions,
+                ModernTreasury::Internal::AnyHash
+              )
+            )
           )
             .void
         end
-        def delete(id, request_options: {})
-        end
-
-        sig { params(client: ModernTreasury::Client).void }
-        def initialize(client:)
-        end
+        def delete(
+          # id
+          id,
+          request_options: {}
+        ); end
+        # @api private
+        sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+        def self.new(client:); end
       end
     end
   end

data/rbi/lib/modern_treasury/resources/transactions.rbi

@@ -4,9 +4,9 @@ module ModernTreasury
   module Resources
     class Transactions
       sig { returns(ModernTreasury::Resources::Transactions::LineItems) }
-      def line_items
-      end
+      attr_reader :line_items
 
+      # create transaction
       sig do
         params(
           amount: Integer,
@@ -17,48 +17,74 @@ module ModernTreasury
           vendor_code_type: T.nilable(String),
           metadata: T::Hash[Symbol, String],
           posted: T::Boolean,
-          type: T.nilable(Symbol),
+          type: T.nilable(ModernTreasury::Models::TransactionCreateParams::Type::OrSymbol),
           vendor_description: T.nilable(String),
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::Transaction)
       end
       def create(
+        # Value in specified currency's smallest unit. e.g. $10 would be represented
+        # as 1000.
         amount:,
+        # The date on which the transaction occurred.
         as_of_date:,
+        # Either `credit` or `debit`.
         direction:,
+        # The ID of the relevant Internal Account.
         internal_account_id:,
+        # When applicable, the bank-given code that determines the transaction's category.
+        # For most banks this is the BAI2/BTRS transaction code.
         vendor_code:,
+        # 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.
         vendor_code_type:,
+        # Additional data represented as key-value pairs. Both the key and value must be
+        # strings.
         metadata: nil,
+        # This field will be `true` if the transaction has posted to the account.
         posted: nil,
+        # The type of the transaction. Examples could be
+        # `card, `ach`, `wire`, `check`, `rtp`, `book`, or `sen`.
         type: nil,
+        # The transaction detail text that often appears in on your bank statement and in
+        # your banking portal.
         vendor_description: nil,
         request_options: {}
-      )
-      end
-
+      ); end
+      # Get details on a single transaction.
       sig do
         params(
           id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::Transaction)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # Transaction ID
+        id,
+        request_options: {}
+      ); end
+      # Update a single transaction.
       sig do
         params(
           id: String,
           metadata: T::Hash[Symbol, String],
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::Transaction)
       end
-      def update(id, metadata: nil, request_options: {})
-      end
-
+      def update(
+        # Transaction ID
+        id,
+        # Additional data in the form of key-value pairs. Pairs can be removed by passing
+        # an empty string or `null` as the value.
+        metadata: nil,
+        request_options: {}
+      ); end
+      # Get a list of all transactions.
       sig do
         params(
           after_cursor: T.nilable(String),
@@ -75,42 +101,56 @@ module ModernTreasury
           transactable_type: String,
           vendor_id: String,
           virtual_account_id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
-          .returns(ModernTreasury::Page[ModernTreasury::Models::Transaction])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::Transaction])
       end
       def list(
         after_cursor: nil,
+        # Filters transactions with an `as_of_date` starting on or before the specified
+        # date (YYYY-MM-DD).
         as_of_date_end: nil,
+        # Filters transactions with an `as_of_date` starting on or after the specified
+        # date (YYYY-MM-DD).
         as_of_date_start: nil,
         counterparty_id: nil,
+        # Filters for transactions including the queried string in the description.
         description: nil,
         direction: nil,
+        # Specify `internal_account_id` if you wish to see transactions to/from a specific
+        # account.
         internal_account_id: nil,
+        # 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.
         metadata: nil,
         payment_type: nil,
         per_page: nil,
+        # Either `true` or `false`.
         posted: nil,
         transactable_type: nil,
+        # Filters for transactions including the queried vendor id (an identifier given to
+        # transactions by the bank).
         vendor_id: nil,
         virtual_account_id: nil,
         request_options: {}
-      )
-      end
-
+      ); end
+      # delete transaction
       sig do
         params(
           id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .void
       end
-      def delete(id, request_options: {})
-      end
-
-      sig { params(client: ModernTreasury::Client).void }
-      def initialize(client:)
-      end
+      def delete(
+        # Transaction ID
+        id,
+        request_options: {}
+      ); end
+      # @api private
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:); end
     end
   end
 end

data/rbi/lib/modern_treasury/resources/validations.rbi

@@ -3,20 +3,29 @@
 module ModernTreasury
   module Resources
     class Validations
+      # Validates the routing number information supplied without creating a routing
+      # detail
       sig do
         params(
           routing_number: String,
-          routing_number_type: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          routing_number_type: ModernTreasury::Models::ValidationValidateRoutingNumberParams::RoutingNumberType::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::RoutingNumberLookupRequest)
       end
-      def validate_routing_number(routing_number:, routing_number_type:, request_options: {})
-      end
-
-      sig { params(client: ModernTreasury::Client).void }
-      def initialize(client:)
-      end
+      def validate_routing_number(
+        # The routing number that is being validated.
+        routing_number:,
+        # 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.
+        routing_number_type:,
+        request_options: {}
+      ); end
+      # @api private
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:); end
     end
   end
 end