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

data/rbi/lib/modern_treasury/resources/expected_payments.rbi

@@ -3,155 +3,245 @@
 module ModernTreasury
   module Resources
     class ExpectedPayments
+      # create expected payment
       sig do
         params(
           amount_lower_bound: T.nilable(Integer),
           amount_upper_bound: T.nilable(Integer),
           counterparty_id: T.nilable(String),
-          currency: T.nilable(Symbol),
+          currency: T.nilable(ModernTreasury::Models::Currency::OrSymbol),
           date_lower_bound: T.nilable(Date),
           date_upper_bound: T.nilable(Date),
           description: T.nilable(String),
-          direction: T.nilable(Symbol),
+          direction: T.nilable(ModernTreasury::Models::ExpectedPaymentCreateParams::Direction::OrSymbol),
           internal_account_id: T.nilable(String),
-          ledger_transaction: ModernTreasury::Models::ExpectedPaymentCreateParams::LedgerTransaction,
+          ledger_transaction: T.any(
+            ModernTreasury::Models::ExpectedPaymentCreateParams::LedgerTransaction,
+            ModernTreasury::Util::AnyHash
+          ),
           ledger_transaction_id: String,
-          line_items: T::Array[ModernTreasury::Models::ExpectedPaymentCreateParams::LineItem],
+          line_items: T::Array[T.any(ModernTreasury::Models::ExpectedPaymentCreateParams::LineItem, ModernTreasury::Util::AnyHash)],
           metadata: T::Hash[Symbol, String],
           reconciliation_filters: T.nilable(T.anything),
           reconciliation_groups: T.nilable(T.anything),
-          reconciliation_rule_variables: T.nilable(T::Array[ModernTreasury::Models::ReconciliationRule]),
+          reconciliation_rule_variables: T.nilable(T::Array[T.any(ModernTreasury::Models::ReconciliationRule, ModernTreasury::Util::AnyHash)]),
           remittance_information: T.nilable(String),
           statement_descriptor: T.nilable(String),
-          type: T.nilable(Symbol),
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          type: T.nilable(ModernTreasury::Models::ExpectedPaymentType::OrSymbol),
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::ExpectedPayment)
       end
       def create(
+        # The lowest amount this expected payment may be equal to. Value in specified
+        #   currency's smallest unit. e.g. $10 would be represented as 1000.
         amount_lower_bound: nil,
+        # The highest amount this expected payment may be equal to. Value in specified
+        #   currency's smallest unit. e.g. $10 would be represented as 1000.
         amount_upper_bound: nil,
+        # The ID of the counterparty you expect for this payment.
         counterparty_id: nil,
+        # Must conform to ISO 4217. Defaults to the currency of the internal account.
         currency: nil,
+        # The earliest date the payment may come in. Format: yyyy-mm-dd
         date_lower_bound: nil,
+        # The latest date the payment may come in. Format: yyyy-mm-dd
         date_upper_bound: nil,
+        # An optional description for internal use.
         description: nil,
+        # One of credit or debit. When you are receiving money, use credit. When you are
+        #   being charged, use debit.
         direction: nil,
+        # The ID of the Internal Account for the expected payment.
         internal_account_id: nil,
+        # Specifies a ledger transaction object that will be created with the expected
+        #   payment. If the ledger transaction cannot be created, then the expected payment
+        #   creation will fail. The resulting ledger transaction will mirror the status of
+        #   the expected payment.
         ledger_transaction: nil,
+        # Either ledger_transaction or ledger_transaction_id can be provided. Only a
+        #   pending ledger transaction can be attached upon expected payment creation. Once
+        #   the expected payment is created, the status of the ledger transaction tracks the
+        #   expected payment automatically.
         ledger_transaction_id: nil,
         line_items: nil,
+        # Additional data represented as key-value pairs. Both the key and value must be
+        #   strings.
         metadata: nil,
+        # The reconciliation filters you have for this payment.
         reconciliation_filters: nil,
+        # The reconciliation groups you have for this payment.
         reconciliation_groups: nil,
+        # An array of reconciliation rule variables for this payment.
         reconciliation_rule_variables: nil,
+        # For `ach`, this field will be passed through on an addenda record. For `wire`
+        #   payments the field will be passed through as the "Originator to Beneficiary
+        #   Information", also known as OBI or Fedwire tag 6000.
         remittance_information: nil,
+        # The statement description you expect to see on the transaction. For ACH
+        #   payments, this will be the full line item passed from the bank. For wire
+        #   payments, this will be the OBI field on the wire. For check payments, this will
+        #   be the memo field.
         statement_descriptor: nil,
+        # One of: ach, au_becs, bacs, book, check, eft, interac, provxchange, rtp, sen,
+        #   sepa, signet, wire.
         type: nil,
         request_options: {}
       )
       end
 
+      # get expected payment
       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::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::ExpectedPayment)
       end
-      def retrieve(id, request_options: {})
+      def retrieve(
+        # id
+        id,
+        request_options: {}
+      )
       end
 
+      # update expected payment
       sig do
         params(
           id: String,
           amount_lower_bound: T.nilable(Integer),
           amount_upper_bound: T.nilable(Integer),
           counterparty_id: T.nilable(String),
-          currency: T.nilable(Symbol),
+          currency: T.nilable(ModernTreasury::Models::Currency::OrSymbol),
           date_lower_bound: T.nilable(Date),
           date_upper_bound: T.nilable(Date),
           description: T.nilable(String),
-          direction: T.nilable(Symbol),
+          direction: T.nilable(ModernTreasury::Models::ExpectedPaymentUpdateParams::Direction::OrSymbol),
           internal_account_id: T.nilable(String),
           metadata: T::Hash[Symbol, String],
           reconciliation_filters: T.nilable(T.anything),
           reconciliation_groups: T.nilable(T.anything),
-          reconciliation_rule_variables: T.nilable(T::Array[ModernTreasury::Models::ReconciliationRule]),
+          reconciliation_rule_variables: T.nilable(T::Array[T.any(ModernTreasury::Models::ReconciliationRule, ModernTreasury::Util::AnyHash)]),
           remittance_information: T.nilable(String),
           statement_descriptor: T.nilable(String),
-          status: T.nilable(Symbol),
-          type: T.nilable(Symbol),
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          status: T.nilable(ModernTreasury::Models::ExpectedPaymentUpdateParams::Status::OrSymbol),
+          type: T.nilable(ModernTreasury::Models::ExpectedPaymentType::OrSymbol),
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::ExpectedPayment)
       end
       def update(
+        # id
         id,
+        # The lowest amount this expected payment may be equal to. Value in specified
+        #   currency's smallest unit. e.g. $10 would be represented as 1000.
         amount_lower_bound: nil,
+        # The highest amount this expected payment may be equal to. Value in specified
+        #   currency's smallest unit. e.g. $10 would be represented as 1000.
         amount_upper_bound: nil,
+        # The ID of the counterparty you expect for this payment.
         counterparty_id: nil,
+        # Must conform to ISO 4217. Defaults to the currency of the internal account.
         currency: nil,
+        # The earliest date the payment may come in. Format: yyyy-mm-dd
         date_lower_bound: nil,
+        # The latest date the payment may come in. Format: yyyy-mm-dd
         date_upper_bound: nil,
+        # An optional description for internal use.
         description: nil,
+        # One of credit or debit. When you are receiving money, use credit. When you are
+        #   being charged, use debit.
         direction: nil,
+        # The ID of the Internal Account for the expected payment.
         internal_account_id: nil,
+        # Additional data represented as key-value pairs. Both the key and value must be
+        #   strings.
         metadata: nil,
+        # The reconciliation filters you have for this payment.
         reconciliation_filters: nil,
+        # The reconciliation groups you have for this payment.
         reconciliation_groups: nil,
+        # An array of reconciliation rule variables for this payment.
         reconciliation_rule_variables: nil,
+        # For `ach`, this field will be passed through on an addenda record. For `wire`
+        #   payments the field will be passed through as the "Originator to Beneficiary
+        #   Information", also known as OBI or Fedwire tag 6000.
         remittance_information: nil,
+        # The statement description you expect to see on the transaction. For ACH
+        #   payments, this will be the full line item passed from the bank. For wire
+        #   payments, this will be the OBI field on the wire. For check payments, this will
+        #   be the memo field.
         statement_descriptor: nil,
+        # The Expected Payment's status can be updated from partially_reconciled to
+        #   reconciled.
         status: nil,
+        # One of: ach, au_becs, bacs, book, check, eft, interac, provxchange, rtp, sen,
+        #   sepa, signet, wire.
         type: nil,
         request_options: {}
       )
       end
 
+      # list expected_payments
       sig do
         params(
           after_cursor: T.nilable(String),
           counterparty_id: String,
           created_at_lower_bound: Time,
           created_at_upper_bound: Time,
-          direction: Symbol,
+          direction: ModernTreasury::Models::TransactionDirection::OrSymbol,
           internal_account_id: String,
           metadata: T::Hash[Symbol, String],
           per_page: Integer,
-          status: Symbol,
-          type: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          status: ModernTreasury::Models::ExpectedPaymentListParams::Status::OrSymbol,
+          type: ModernTreasury::Models::ExpectedPaymentListParams::Type::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Page[ModernTreasury::Models::ExpectedPayment])
       end
       def list(
         after_cursor: nil,
+        # Specify counterparty_id to see expected_payments for a specific account.
         counterparty_id: nil,
+        # Used to return expected payments created after some datetime
         created_at_lower_bound: nil,
+        # Used to return expected payments created before some datetime
         created_at_upper_bound: nil,
+        # One of credit, debit
         direction: nil,
+        # Specify internal_account_id to see expected_payments for 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,
         per_page: nil,
+        # One of unreconciled, reconciled, or archived.
         status: nil,
+        # One of: ach, au_becs, bacs, book, check, eft, interac, provxchange, rtp,sen,
+        #   sepa, signet, wire
         type: nil,
         request_options: {}
       )
       end
 
+      # delete expected payment
       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::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::ExpectedPayment)
       end
-      def delete(id, request_options: {})
+      def delete(
+        # id
+        id,
+        request_options: {}
+      )
       end
 
-      sig { params(client: ModernTreasury::Client).void }
-      def initialize(client:)
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:)
       end
     end
   end

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

@@ -3,80 +3,111 @@
 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::Util::AnyHash)],
+          account_type: ModernTreasury::Models::ExternalAccountType::OrSymbol,
+          contact_details: T::Array[T.any(ModernTreasury::Models::ExternalAccountCreateParams::ContactDetail, ModernTreasury::Util::AnyHash)],
+          ledger_account: T.any(ModernTreasury::Models::ExternalAccountCreateParams::LedgerAccount, ModernTreasury::Util::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::Util::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::Util::AnyHash)],
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::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
 
+      # 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::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::ExternalAccount)
       end
-      def retrieve(id, request_options: {})
+      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::Util::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::Util::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
 
+      # list external accounts
       sig do
         params(
           after_cursor: T.nilable(String),
@@ -84,50 +115,66 @@ 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::Util::AnyHash))
         )
           .returns(ModernTreasury::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
 
+      # 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::Util::AnyHash))
         )
           .void
       end
-      def delete(id, request_options: {})
+      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::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::ExternalAccount)
       end
-      def complete_verification(id, amounts: nil, request_options: {})
+      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::Util::AnyHash))
         )
           .returns(
             T.any(
@@ -137,18 +184,28 @@ 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:)
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:)
       end
     end
   end

data/rbi/lib/modern_treasury/resources/foreign_exchange_quotes.rbi

@@ -3,39 +3,54 @@
 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::Util::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
 
+      # 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::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::ForeignExchangeQuote)
       end
-      def retrieve(id, request_options: {})
+      def retrieve(
+        # id
+        id,
+        request_options: {}
+      )
       end
 
+      # list foreign_exchange_quotes
       sig do
         params(
           after_cursor: T.nilable(String),
@@ -47,26 +62,35 @@ 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::Util::AnyHash))
         )
           .returns(ModernTreasury::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:)
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:)
       end
     end
   end