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

data/rbi/lib/modern_treasury/resources/counterparties.rbi

@@ -3,49 +3,64 @@
 module ModernTreasury
   module Resources
     class Counterparties
+      # Create a new counterparty.
       sig do
         params(
           name: T.nilable(String),
-          accounting: ModernTreasury::Models::CounterpartyCreateParams::Accounting,
-          accounts: T::Array[ModernTreasury::Models::CounterpartyCreateParams::Account],
+          accounting: T.any(ModernTreasury::Models::CounterpartyCreateParams::Accounting, ModernTreasury::Internal::AnyHash),
+          accounts: T::Array[T.any(ModernTreasury::Models::CounterpartyCreateParams::Account, ModernTreasury::Internal::AnyHash)],
           email: T.nilable(String),
-          ledger_type: Symbol,
-          legal_entity: ModernTreasury::Models::CounterpartyCreateParams::LegalEntity,
+          ledger_type: ModernTreasury::Models::CounterpartyCreateParams::LedgerType::OrSymbol,
+          legal_entity: T.any(ModernTreasury::Models::CounterpartyCreateParams::LegalEntity, ModernTreasury::Internal::AnyHash),
           legal_entity_id: T.nilable(String),
           metadata: T::Hash[Symbol, String],
           send_remittance_advice: T::Boolean,
           taxpayer_identifier: String,
-          verification_status: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          verification_status: ModernTreasury::Models::CounterpartyCreateParams::VerificationStatus::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::Counterparty)
       end
       def create(
+        # A human friendly name for this counterparty.
         name:,
         accounting: nil,
+        # The accounts for this counterparty.
         accounts: nil,
+        # The counterparty's email.
         email: nil,
+        # An optional type to auto-sync the counterparty to your ledger. Either `customer`
+        # or `vendor`.
         ledger_type: nil,
         legal_entity: nil,
+        # The id of the legal entity.
         legal_entity_id: nil,
+        # Additional data represented as key-value pairs. Both the key and value must be
+        # strings.
         metadata: nil,
+        # Send an email to the counterparty whenever an associated payment order is sent
+        # to the bank.
         send_remittance_advice: nil,
+        # Either a valid SSN or EIN.
         taxpayer_identifier: nil,
+        # The verification status of the counterparty.
         verification_status: nil,
         request_options: {}
-      )
-      end
-
+      ); end
+      # Get details on a single counterparty.
       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::Counterparty)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # The id of an existing counterparty.
+        id,
+        request_options: {}
+      ); end
+      # Updates a given counterparty with new information.
       sig do
         params(
           id: String,
@@ -55,22 +70,30 @@ module ModernTreasury
           name: String,
           send_remittance_advice: T::Boolean,
           taxpayer_identifier: 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::Counterparty)
       end
       def update(
+        # The id of an existing counterparty.
         id,
+        # A new email for the counterparty.
         email: nil,
+        # The id of the legal entity.
         legal_entity_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 new name for the counterparty. Will only update if passed.
         name: nil,
+        # If this is `true`, Modern Treasury will send an email to the counterparty
+        # whenever an associated payment order is sent to the bank.
         send_remittance_advice: nil,
+        # Either a valid SSN or EIN.
         taxpayer_identifier: nil,
         request_options: {}
-      )
-      end
-
+      ); end
+      # Get a paginated list of all counterparties.
       sig do
         params(
           after_cursor: T.nilable(String),
@@ -81,57 +104,83 @@ module ModernTreasury
           metadata: T::Hash[Symbol, String],
           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::Counterparty])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::Counterparty])
       end
       def list(
         after_cursor: nil,
+        # Used to return counterparties created after some datetime.
         created_at_lower_bound: nil,
+        # Used to return counterparties created before some datetime.
         created_at_upper_bound: nil,
+        # Performs a partial string match of the email field. This is also case
+        # insensitive.
         email: nil,
+        # Filters for counterparties with the given legal entity ID.
         legal_entity_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,
+        # Performs a partial string match of the name field. This is also case
+        # insensitive.
         name: nil,
         per_page: nil,
         request_options: {}
-      )
-      end
-
+      ); end
+      # Deletes a given counterparty.
       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(
+        # The id of an existing counterparty.
+        id,
+        request_options: {}
+      ); end
+      # Send an email requesting account details.
       sig do
         params(
           id: String,
-          direction: Symbol,
+          direction: ModernTreasury::Models::TransactionDirection::OrSymbol,
           custom_redirect: String,
-          fields: T::Array[Symbol],
+          fields: T::Array[ModernTreasury::Models::CounterpartyCollectAccountParams::Field::OrSymbol],
           send_email: T::Boolean,
-          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::CounterpartyCollectAccountResponse)
       end
       def collect_account(
+        # counterparty id
         id,
+        # One of `credit` or `debit`. Use `credit` when you want to pay a counterparty.
+        # Use `debit` when you need to charge a counterparty. This field helps us send a
+        # more tailored email to your counterparties."
         direction:,
+        # The URL you want your customer to visit upon filling out the form. By default,
+        # they will be sent to a Modern Treasury landing page. This must be a valid HTTPS
+        # URL if set.
         custom_redirect: nil,
+        # The list of fields you want on the form. This field is optional and if it is not
+        # set, will default to [\"nameOnAccount\", \"accountType\", \"accountNumber\",
+        # \"routingNumber\", \"address\"]. The full list of options is [\"name\",
+        # \"nameOnAccount\", \"taxpayerIdentifier\", \"accountType\", \"accountNumber\",
+        # \"routingNumber\", \"address\", \"ibanNumber\", \"swiftCode\"].
         fields: nil,
+        # By default, Modern Treasury will send an email to your counterparty that
+        # includes a link to the form they must fill out. However, if you would like to
+        # send the counterparty the link, you can set this parameter to `false`. The JSON
+        # body will include the link to the secure Modern Treasury form.
         send_email: 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/documents.rbi

@@ -3,51 +3,64 @@
 module ModernTreasury
   module Resources
     class Documents
+      # Create a document.
       sig do
         params(
           documentable_id: String,
-          documentable_type: Symbol,
+          documentable_type: ModernTreasury::Models::DocumentCreateParams::DocumentableType::OrSymbol,
           file: T.any(IO, StringIO),
           document_type: 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::Document)
       end
-      def create(documentable_id:, documentable_type:, file:, document_type: nil, request_options: {})
-      end
-
+      def create(
+        # The unique identifier for the associated object.
+        documentable_id:,
+        documentable_type:,
+        file:,
+        # A category given to the document, can be `null`.
+        document_type: nil,
+        request_options: {}
+      ); end
+      # Get an existing document.
       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::Document)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # The ID of the document.
+        id,
+        request_options: {}
+      ); end
+      # Get a list of documents.
       sig do
         params(
           after_cursor: T.nilable(String),
           documentable_id: String,
-          documentable_type: Symbol,
+          documentable_type: ModernTreasury::Models::DocumentListParams::DocumentableType::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::Document])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::Document])
       end
       def list(
         after_cursor: nil,
+        # The unique identifier for the associated object.
         documentable_id: nil,
+        # The type of the associated object. Currently can be one of `payment_order`,
+        # `transaction`, `paper_item`, `expected_payment`, `counterparty`, `organization`,
+        # `case`, `internal_account`, `decision`, or `external_account`.
         documentable_type: nil,
         per_page: 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/events.rbi

@@ -3,16 +3,20 @@
 module ModernTreasury
   module Resources
     class Events
+      # get event
       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::Event)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # event id
+        id,
+        request_options: {}
+      ); end
+      # list events
       sig do
         params(
           after_cursor: T.nilable(String),
@@ -22,25 +26,25 @@ module ModernTreasury
           event_time_start: Time,
           per_page: Integer,
           resource: 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::Event])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::Event])
       end
       def list(
         after_cursor: nil,
         entity_id: nil,
         event_name: nil,
+        # An inclusive upper bound for when the event occurred
         event_time_end: nil,
+        # An inclusive lower bound for when the event occurred
         event_time_start: nil,
         per_page: nil,
         resource: 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/expected_payments.rbi

@@ -3,156 +3,236 @@
 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::Internal::AnyHash
+          ),
           ledger_transaction_id: String,
-          line_items: T::Array[ModernTreasury::Models::ExpectedPaymentCreateParams::LineItem],
+          line_items: T::Array[T.any(ModernTreasury::Models::ExpectedPaymentCreateParams::LineItem, ModernTreasury::Internal::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::Internal::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::Internal::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
-
+      ); 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::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::ExpectedPayment)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      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::Internal::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::Internal::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
-
+      ); 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::Internal::AnyHash))
         )
-          .returns(ModernTreasury::Page[ModernTreasury::Models::ExpectedPayment])
+          .returns(ModernTreasury::Internal::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
-
+      ); 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::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::ExpectedPayment)
       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