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

data/rbi/lib/modern_treasury/resources/external_accounts.rbi

@@ -3,80 +3,129 @@
 module ModernTreasury
   module Resources
     class ExternalAccounts
+      # create external account
       sig do
         params(
           counterparty_id: T.nilable(String),
-          account_details: T::Array[ModernTreasury::Models::ExternalAccountCreateParams::AccountDetail],
-          account_type: Symbol,
-          contact_details: T::Array[ModernTreasury::Models::ExternalAccountCreateParams::ContactDetail],
-          ledger_account: ModernTreasury::Models::ExternalAccountCreateParams::LedgerAccount,
+          account_details: T::Array[
+            T.any(
+              ModernTreasury::Models::ExternalAccountCreateParams::AccountDetail,
+              ModernTreasury::Internal::AnyHash
+            )
+          ],
+          account_type: ModernTreasury::Models::ExternalAccountType::OrSymbol,
+          contact_details: T::Array[
+            T.any(
+              ModernTreasury::Models::ExternalAccountCreateParams::ContactDetail,
+              ModernTreasury::Internal::AnyHash
+            )
+          ],
+          ledger_account: T.any(
+            ModernTreasury::Models::ExternalAccountCreateParams::LedgerAccount,
+            ModernTreasury::Internal::AnyHash
+          ),
           metadata: T::Hash[Symbol, String],
           name: T.nilable(String),
-          party_address: ModernTreasury::Models::ExternalAccountCreateParams::PartyAddress,
+          party_address: T.any(
+            ModernTreasury::Models::ExternalAccountCreateParams::PartyAddress,
+            ModernTreasury::Internal::AnyHash
+          ),
           party_identifier: String,
           party_name: String,
-          party_type: T.nilable(Symbol),
+          party_type: T.nilable(ModernTreasury::Models::ExternalAccountCreateParams::PartyType::OrSymbol),
           plaid_processor_token: String,
-          routing_details: T::Array[ModernTreasury::Models::ExternalAccountCreateParams::RoutingDetail],
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          routing_details: T::Array[
+            T.any(
+              ModernTreasury::Models::ExternalAccountCreateParams::RoutingDetail,
+              ModernTreasury::Internal::AnyHash
+            )
+          ],
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::ExternalAccount)
       end
       def create(
         counterparty_id:,
         account_details: nil,
+        # Can be `checking`, `savings` or `other`.
         account_type: nil,
         contact_details: nil,
+        # Specifies a ledger account object that will be created with the external
+        # account. The resulting ledger account is linked to the external account for
+        # auto-ledgering Payment objects. See
+        # https://docs.moderntreasury.com/docs/linking-to-other-modern-treasury-objects
+        # for more details.
         ledger_account: nil,
+        # Additional data represented as key-value pairs. Both the key and value must be
+        # strings.
         metadata: nil,
+        # A nickname for the external account. This is only for internal usage and won't
+        # affect any payments
         name: nil,
+        # Required if receiving wire payments.
         party_address: nil,
         party_identifier: nil,
+        # If this value isn't provided, it will be inherited from the counterparty's name.
         party_name: nil,
+        # Either `individual` or `business`.
         party_type: nil,
+        # If you've enabled the Modern Treasury + Plaid integration in your Plaid account,
+        # you can pass the processor token in this field.
         plaid_processor_token: nil,
         routing_details: nil,
         request_options: {}
-      )
-      end
-
+      ); end
+      # show external account
       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::ExternalAccount)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # external account id
+        id,
+        request_options: {}
+      ); end
+      # update external account
       sig do
         params(
           id: String,
-          account_type: Symbol,
+          account_type: ModernTreasury::Models::ExternalAccountType::OrSymbol,
           counterparty_id: T.nilable(String),
           metadata: T::Hash[Symbol, String],
           name: T.nilable(String),
-          party_address: ModernTreasury::Models::ExternalAccountUpdateParams::PartyAddress,
+          party_address: T.any(
+            ModernTreasury::Models::ExternalAccountUpdateParams::PartyAddress,
+            ModernTreasury::Internal::AnyHash
+          ),
           party_name: String,
-          party_type: T.nilable(Symbol),
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          party_type: T.nilable(ModernTreasury::Models::ExternalAccountUpdateParams::PartyType::OrSymbol),
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::ExternalAccount)
       end
       def update(
+        # external account id
         id,
+        # Can be `checking`, `savings` or `other`.
         account_type: nil,
         counterparty_id: nil,
+        # 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,
+        # A nickname for the external account. This is only for internal usage and won't
+        # affect any payments
         name: nil,
         party_address: nil,
+        # If this value isn't provided, it will be inherited from the counterparty's name.
         party_name: nil,
+        # Either `individual` or `business`.
         party_type: nil,
         request_options: {}
-      )
-      end
-
+      ); end
+      # list external accounts
       sig do
         params(
           after_cursor: T.nilable(String),
@@ -84,50 +133,60 @@ module ModernTreasury
           metadata: T::Hash[Symbol, String],
           party_name: 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::ExternalAccount])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::ExternalAccount])
       end
       def list(
         after_cursor: nil,
         counterparty_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,
+        # Searches the ExternalAccount's party_name AND the Counterparty's party_name
         party_name: nil,
         per_page: nil,
         request_options: {}
-      )
-      end
-
+      ); end
+      # delete external account
       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
-
+      def delete(
+        # external account id
+        id,
+        request_options: {}
+      ); end
+      # complete verification of external account
       sig do
         params(
           id: String,
           amounts: T::Array[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::Models::ExternalAccount)
       end
-      def complete_verification(id, amounts: nil, request_options: {})
-      end
-
+      def complete_verification(
+        # external account id
+        id,
+        amounts: nil,
+        request_options: {}
+      ); end
+      # verify external account
       sig do
         params(
           id: String,
           originating_account_id: String,
-          payment_type: Symbol,
-          currency: Symbol,
-          fallback_type: Symbol,
-          priority: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          payment_type: ModernTreasury::Models::ExternalAccountVerifyParams::PaymentType::OrSymbol,
+          currency: ModernTreasury::Models::Currency::OrSymbol,
+          fallback_type: ModernTreasury::Models::ExternalAccountVerifyParams::FallbackType::OrSymbol,
+          priority: ModernTreasury::Models::ExternalAccountVerifyParams::Priority::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(
             T.any(
@@ -137,19 +196,27 @@ module ModernTreasury
           )
       end
       def verify(
+        # external account id
         id,
+        # The ID of the internal account where the micro-deposits originate from. Both
+        # credit and debit capabilities must be enabled.
         originating_account_id:,
+        # Can be `ach`, `eft`, or `rtp`.
         payment_type:,
+        # Defaults to the currency of the originating account.
         currency: nil,
+        # A payment type to fallback to if the original type is not valid for the
+        # receiving account. Currently, this only supports falling back from RTP to ACH
+        # (payment_type=rtp and fallback_type=ach)
         fallback_type: nil,
+        # Either `normal` or `high`. For ACH payments, `high` represents a same-day ACH
+        # transfer. This will apply to both `payment_type` and `fallback_type`.
         priority: 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/foreign_exchange_quotes.rbi

@@ -3,39 +3,50 @@
 module ModernTreasury
   module Resources
     class ForeignExchangeQuotes
+      # create foreign_exchange_quote
       sig do
         params(
           internal_account_id: String,
-          target_currency: Symbol,
+          target_currency: ModernTreasury::Models::Currency::OrSymbol,
           base_amount: Integer,
-          base_currency: Symbol,
+          base_currency: ModernTreasury::Models::Currency::OrSymbol,
           effective_at: Time,
           target_amount: 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::Models::ForeignExchangeQuote)
       end
       def create(
+        # The ID for the `InternalAccount` this quote is associated with.
         internal_account_id:,
+        # Currency to convert the `base_currency` to, often called the "buy" currency.
         target_currency:,
+        # Amount in the lowest denomination of the `base_currency` to convert, often
+        # called the "sell" amount.
         base_amount: nil,
+        # Currency to convert, often called the "sell" currency.
         base_currency: nil,
+        # The timestamp until when the quoted rate is valid.
         effective_at: nil,
+        # Amount in the lowest denomination of the `target_currency`, often called the
+        # "buy" amount.
         target_amount: nil,
         request_options: {}
-      )
-      end
-
+      ); end
+      # get foreign_exchange_quote
       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::ForeignExchangeQuote)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # id
+        id,
+        request_options: {}
+      ); end
+      # list foreign_exchange_quotes
       sig do
         params(
           after_cursor: T.nilable(String),
@@ -47,27 +58,34 @@ module ModernTreasury
           metadata: T::Hash[Symbol, String],
           per_page: Integer,
           target_currency: 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::ForeignExchangeQuote])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::ForeignExchangeQuote])
       end
       def list(
         after_cursor: nil,
+        # Currency to convert, often called the "sell" currency.
         base_currency: nil,
+        # An inclusive upper bound for searching effective_at
         effective_at_end: nil,
+        # An inclusive lower bound for searching effective_at
         effective_at_start: nil,
+        # The timestamp until which the quote must be booked by.
         expires_at: nil,
+        # The ID for the `InternalAccount` this quote is associated with.
         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,
         per_page: nil,
+        # Currency to convert the `base_currency` to, often called the "buy" currency.
         target_currency: 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/incoming_payment_details.rbi

@@ -3,86 +3,121 @@
 module ModernTreasury
   module Resources
     class IncomingPaymentDetails
+      # Get an existing Incoming Payment Detail.
       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::IncomingPaymentDetail)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # The unique identifier of the incoming payment detail.
+        id,
+        request_options: {}
+      ); end
+      # Update an existing Incoming Payment Detail.
       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::IncomingPaymentDetail)
       end
-      def update(id, metadata: nil, request_options: {})
-      end
-
+      def update(
+        # The unique identifier of the incoming payment detail.
+        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 Incoming Payment Details.
       sig do
         params(
           after_cursor: T.nilable(String),
           as_of_date_end: Date,
           as_of_date_start: Date,
-          direction: Symbol,
+          direction: ModernTreasury::Models::TransactionDirection::OrSymbol,
           metadata: T::Hash[Symbol, String],
           per_page: Integer,
-          status: Symbol,
-          type: Symbol,
+          status: ModernTreasury::Models::IncomingPaymentDetailListParams::Status::OrSymbol,
+          type: ModernTreasury::Models::IncomingPaymentDetailListParams::Type::OrSymbol,
           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::IncomingPaymentDetail])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::IncomingPaymentDetail])
       end
       def list(
         after_cursor: nil,
+        # Filters incoming payment details with an as_of_date starting on or before the
+        # specified date (YYYY-MM-DD).
         as_of_date_end: nil,
+        # Filters incoming payment details with an as_of_date starting on or after the
+        # specified date (YYYY-MM-DD).
         as_of_date_start: nil,
+        # One of `credit` or `debit`.
         direction: 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,
         per_page: nil,
+        # The current status of the incoming payment order. One of `pending`, `completed`,
+        # or `returned`.
         status: nil,
+        # One of: `ach`, `book`, `check`, `eft`, `interac`, `rtp`, `sepa`, `signet`, or
+        # `wire`.
         type: nil,
+        # If the incoming payment detail is in a virtual account, the ID of the Virtual
+        # Account.
         virtual_account_id: nil,
         request_options: {}
-      )
-      end
-
+      ); end
+      # Simulate Incoming Payment Detail
       sig do
         params(
           amount: Integer,
           as_of_date: T.nilable(Date),
-          currency: T.nilable(Symbol),
+          currency: T.nilable(ModernTreasury::Models::Currency::OrSymbol),
+          data: T.nilable(T.anything),
           description: T.nilable(String),
-          direction: Symbol,
+          direction: ModernTreasury::Models::IncomingPaymentDetailCreateAsyncParams::Direction::OrSymbol,
           internal_account_id: String,
-          type: Symbol,
+          type: ModernTreasury::Models::IncomingPaymentDetailCreateAsyncParams::Type::OrSymbol,
           virtual_account_id: 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::AsyncResponse)
       end
       def create_async(
+        # Value in specified currency's smallest unit. e.g. $10 would be represented
+        # as 1000.
         amount: nil,
+        # Defaults to today.
         as_of_date: nil,
+        # Defaults to the currency of the originating account.
         currency: nil,
+        # An object passed through to the simulated IPD that could reflect what a vendor
+        # would pass.
+        data: nil,
+        # Defaults to a random description.
         description: nil,
+        # One of `credit`, `debit`.
         direction: nil,
+        # The ID of one of your internal accounts.
         internal_account_id: nil,
+        # One of `ach`, `wire`, `check`.
         type: nil,
+        # An optional parameter to associate the incoming payment detail to a virtual
+        # account.
         virtual_account_id: 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/internal_accounts/balance_reports.rbi

@@ -4,73 +4,114 @@ module ModernTreasury
   module Resources
     class InternalAccounts
       class BalanceReports
+        # create balance reports
         sig do
           params(
             internal_account_id: String,
             as_of_date: Date,
             as_of_time: String,
-            balance_report_type: Symbol,
-            balances: T::Array[ModernTreasury::Models::InternalAccounts::BalanceReportCreateParams::Balance],
-            request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+            balance_report_type: ModernTreasury::Models::InternalAccounts::BalanceReportCreateParams::BalanceReportType::OrSymbol,
+            balances: T::Array[
+              T.any(
+                ModernTreasury::Models::InternalAccounts::BalanceReportCreateParams::Balance,
+                ModernTreasury::Internal::AnyHash
+              )
+            ],
+            request_options: T.nilable(
+              T.any(
+                ModernTreasury::RequestOptions,
+                ModernTreasury::Internal::AnyHash
+              )
+            )
           )
             .returns(ModernTreasury::Models::InternalAccounts::BalanceReport)
         end
         def create(
           internal_account_id,
+          # The date of the balance report in local time.
           as_of_date:,
+          # The time (24-hour clock) of the balance report in local time.
           as_of_time:,
+          # The specific type of balance report. One of `intraday`, `previous_day`,
+          # `real_time`, or `other`.
           balance_report_type:,
+          # An array of `Balance` objects.
           balances:,
           request_options: {}
-        )
-        end
-
+        ); end
+        # Get a single balance report for a given internal account.
         sig do
           params(
             id: String,
             internal_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::InternalAccounts::BalanceReport)
         end
-        def retrieve(id, internal_account_id:, request_options: {})
-        end
-
+        def retrieve(
+          # Either the unique identifier of the balance report or latest for the latest
+          # balance report.
+          id,
+          internal_account_id:,
+          request_options: {}
+        ); end
+        # Get all balance reports for a given internal account.
         sig do
           params(
             internal_account_id: String,
             after_cursor: T.nilable(String),
             as_of_date: Date,
-            balance_report_type: Symbol,
+            balance_report_type: ModernTreasury::Models::InternalAccounts::BalanceReportListParams::BalanceReportType::OrSymbol,
             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::InternalAccounts::BalanceReport])
+            .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::InternalAccounts::BalanceReport])
         end
         def list(
           internal_account_id,
           after_cursor: nil,
+          # The date of the balance report in local time.
           as_of_date: nil,
+          # The specific type of balance report. One of `intraday`, `previous_day`,
+          # `real_time`, or `other`.
           balance_report_type: nil,
           per_page: nil,
           request_options: {}
-        )
-        end
-
+        ); end
+        # Deletes a given balance report.
         sig do
           params(
             id: String,
             internal_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, internal_account_id:, request_options: {})
-        end
-
-        sig { params(client: ModernTreasury::Client).void }
-        def initialize(client:)
-        end
+        def delete(
+          # Either the unique identifier of the balance report or latest for the latest
+          # balance report.
+          id,
+          internal_account_id:,
+          request_options: {}
+        ); end
+        # @api private
+        sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+        def self.new(client:); end
       end
     end
   end