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

data/rbi/lib/modern_treasury/request_options.rbi

@@ -1,84 +1,46 @@
 # typed: strong
 
 module ModernTreasury
-  module RequestParameters
-    abstract!
-
-    sig { returns(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])) }
-    def request_options
-    end
-
-    sig do
-      params(_: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
-        .returns(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
-    end
-    def request_options=(_)
-    end
-
-    module Converter
-      sig { params(params: T.anything).returns([T.anything, T::Hash[Symbol, T.anything]]) }
-      def dump_request(params)
-      end
-    end
-  end
-
-  class RequestOptions < ModernTreasury::BaseModel
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < ModernTreasury::Internal::Type::BaseModel
+    # @api private
     sig { params(opts: T.any(T.self_type, T::Hash[Symbol, T.anything])).void }
-    def self.validate!(opts)
-    end
+    def self.validate!(opts); end
 
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
     sig { returns(T.nilable(String)) }
-    def idempotency_key
-    end
-
-    sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-    def idempotency_key=(_)
-    end
+    attr_accessor :idempotency_key
 
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
     sig { returns(T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])) }
-    def extra_query
-    end
-
-    sig do
-      params(_: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
-        .returns(T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
-    end
-    def extra_query=(_)
-    end
+    attr_accessor :extra_query
 
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
     sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
-    def extra_headers
-    end
-
-    sig do
-      params(_: T.nilable(T::Hash[String, T.nilable(String)]))
-        .returns(T.nilable(T::Hash[String, T.nilable(String)]))
-    end
-    def extra_headers=(_)
-    end
+    attr_accessor :extra_headers
 
-    sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
-    def extra_body
-    end
-
-    sig { params(_: T.nilable(T::Hash[Symbol, T.anything])).returns(T.nilable(T::Hash[Symbol, T.anything])) }
-    def extra_body=(_)
-    end
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
 
+    # Maximum number of retries to attempt after a failed initial request.
     sig { returns(T.nilable(Integer)) }
-    def max_retries
-    end
-
-    sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-    def max_retries=(_)
-    end
+    attr_accessor :max_retries
 
+    # Request timeout in seconds.
     sig { returns(T.nilable(Float)) }
-    def timeout
-    end
+    attr_accessor :timeout
 
-    sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
-    def timeout=(_)
-    end
+    # Returns a new instance of RequestOptions.
+    sig { params(values: ModernTreasury::Internal::AnyHash).returns(T.attached_class) }
+    def self.new(values = {}); end
   end
 end

data/rbi/lib/modern_treasury/resources/account_collection_flows.rbi

@@ -3,39 +3,54 @@
 module ModernTreasury
   module Resources
     class AccountCollectionFlows
+      # create account_collection_flow
       sig do
         params(
           counterparty_id: String,
           payment_types: T::Array[String],
-          receiving_countries: T::Array[Symbol],
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          receiving_countries: T::Array[ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::OrSymbol],
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::AccountCollectionFlow)
       end
-      def create(counterparty_id:, payment_types:, receiving_countries: nil, request_options: {})
-      end
-
+      def create(
+        # Required.
+        counterparty_id:,
+        payment_types:,
+        receiving_countries: nil,
+        request_options: {}
+      ); end
+      # get account_collection_flow
       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::AccountCollectionFlow)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # id
+        id,
+        request_options: {}
+      ); end
+      # update account_collection_flow
       sig do
         params(
           id: String,
-          status: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          status: ModernTreasury::Models::AccountCollectionFlowUpdateParams::Status::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::AccountCollectionFlow)
       end
-      def update(id, status:, request_options: {})
-      end
-
+      def update(
+        # id
+        id,
+        # Required. The updated status of the account collection flow. Can only be used to
+        # mark a flow as `cancelled`.
+        status:,
+        request_options: {}
+      ); end
+      # list account_collection_flows
       sig do
         params(
           after_cursor: T.nilable(String),
@@ -44,9 +59,9 @@ module ModernTreasury
           external_account_id: String,
           per_page: Integer,
           status: 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::AccountCollectionFlow])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::AccountCollectionFlow])
       end
       def list(
         after_cursor: nil,
@@ -56,12 +71,10 @@ module ModernTreasury
         per_page: nil,
         status: 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/account_details.rbi

@@ -3,59 +3,90 @@
 module ModernTreasury
   module Resources
     class AccountDetails
+      # Create an account detail for an external account.
       sig do
         params(
           account_id: String,
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::AccountDetailCreateParams::AccountsType::OrSymbol,
           account_number: String,
-          account_number_type: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          account_number_type: ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::AccountDetail)
       end
-      def create(account_id, accounts_type:, account_number:, account_number_type: nil, request_options: {})
-      end
-
+      def create(
+        # Path param: The ID of the account.
+        account_id,
+        # Path param:
+        accounts_type:,
+        # Body param: The account number for the bank account.
+        account_number:,
+        # Body param: One of `iban`, `clabe`, `wallet_address`, or `other`. Use `other` if
+        # the bank account number is in a generic format.
+        account_number_type: nil,
+        request_options: {}
+      ); end
+      # Get a single account 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::AccountDetail)
       end
-      def retrieve(id, accounts_type:, account_id:, request_options: {})
-      end
-
+      def retrieve(
+        # The ID of the account detail.
+        id,
+        accounts_type:,
+        # The ID of the account.
+        account_id:,
+        request_options: {}
+      ); end
+      # Get a list of account 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::AccountDetail])
-      end
-      def list(account_id, accounts_type:, after_cursor: nil, per_page: nil, request_options: {})
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::AccountDetail])
       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 single account detail for an external account.
       sig do
         params(
           id: String,
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::AccountDetailDeleteParams::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 account 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/bulk_requests.rbi

@@ -3,67 +3,87 @@
 module ModernTreasury
   module Resources
     class BulkRequests
+      # create bulk_request
       sig do
         params(
-          action_type: Symbol,
-          resource_type: Symbol,
+          action_type: ModernTreasury::Models::BulkRequestCreateParams::ActionType::OrSymbol,
+          resource_type: ModernTreasury::Models::BulkRequestCreateParams::ResourceType::OrSymbol,
           resources: T::Array[
-          T.any(
-            ModernTreasury::Models::BulkRequestCreateParams::Resource::PaymentOrderAsyncCreateRequest,
-            ModernTreasury::Models::BulkRequestCreateParams::Resource::ExpectedPaymentCreateRequest,
-            ModernTreasury::Models::BulkRequestCreateParams::Resource::LedgerTransactionCreateRequest,
-            ModernTreasury::Models::BulkRequestCreateParams::Resource::TransactionCreateRequest,
-            ModernTreasury::Models::BulkRequestCreateParams::Resource::ID,
-            ModernTreasury::Models::BulkRequestCreateParams::Resource::PaymentOrderUpdateRequestWithID,
-            ModernTreasury::Models::BulkRequestCreateParams::Resource::ExpectedPaymentUpdateRequestWithID,
-            ModernTreasury::Models::BulkRequestCreateParams::Resource::TransactionUpdateRequestWithID,
-            ModernTreasury::Models::BulkRequestCreateParams::Resource::LedgerTransactionUpdateRequestWithID
-          )
+            T.any(
+              ModernTreasury::Models::BulkRequestCreateParams::Resource::PaymentOrderAsyncCreateRequest,
+              ModernTreasury::Internal::AnyHash,
+              ModernTreasury::Models::BulkRequestCreateParams::Resource::ExpectedPaymentCreateRequest,
+              ModernTreasury::Models::BulkRequestCreateParams::Resource::LedgerTransactionCreateRequest,
+              ModernTreasury::Models::BulkRequestCreateParams::Resource::TransactionCreateRequest,
+              ModernTreasury::Models::BulkRequestCreateParams::Resource::ID,
+              ModernTreasury::Models::BulkRequestCreateParams::Resource::PaymentOrderUpdateRequestWithID,
+              ModernTreasury::Models::BulkRequestCreateParams::Resource::ExpectedPaymentUpdateRequestWithID,
+              ModernTreasury::Models::BulkRequestCreateParams::Resource::TransactionUpdateRequestWithID,
+              ModernTreasury::Models::BulkRequestCreateParams::Resource::LedgerTransactionUpdateRequestWithID
+            )
           ],
           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::BulkRequest)
       end
-      def create(action_type:, resource_type:, resources:, metadata: nil, request_options: {})
-      end
-
+      def create(
+        # One of create, or update.
+        action_type:,
+        # One of payment_order, expected_payment, or ledger_transaction.
+        resource_type:,
+        # An array of objects where each object contains the input params for a single
+        # `action_type` request on a `resource_type` resource
+        resources:,
+        # Additional data represented as key-value pairs. Both the key and value must be
+        # strings.
+        metadata: nil,
+        request_options: {}
+      ); end
+      # get bulk_request
       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::BulkRequest)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # id
+        id,
+        request_options: {}
+      ); end
+      # list bulk_requests
       sig do
         params(
-          action_type: Symbol,
+          action_type: ModernTreasury::Models::BulkRequestListParams::ActionType::OrSymbol,
           after_cursor: T.nilable(String),
           metadata: T::Hash[Symbol, String],
           per_page: Integer,
-          resource_type: Symbol,
-          status: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          resource_type: ModernTreasury::Models::BulkRequestListParams::ResourceType::OrSymbol,
+          status: ModernTreasury::Models::BulkRequestListParams::Status::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
-          .returns(ModernTreasury::Page[ModernTreasury::Models::BulkRequest])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::BulkRequest])
       end
       def list(
+        # One of create, or update.
         action_type: nil,
         after_cursor: 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 payment_order, expected_payment, or ledger_transaction.
         resource_type: nil,
+        # One of pending, processing, or completed.
         status: 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/bulk_results.rbi

@@ -3,44 +3,54 @@
 module ModernTreasury
   module Resources
     class BulkResults
+      # get bulk_result
       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::BulkResult)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # id
+        id,
+        request_options: {}
+      ); end
+      # list bulk_results
       sig do
         params(
           after_cursor: T.nilable(String),
           entity_id: String,
-          entity_type: Symbol,
+          entity_type: ModernTreasury::Models::BulkResultListParams::EntityType::OrSymbol,
           per_page: Integer,
           request_id: String,
-          request_type: Symbol,
-          status: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_type: ModernTreasury::Models::BulkResultListParams::RequestType::OrSymbol,
+          status: ModernTreasury::Models::BulkResultListParams::Status::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
-          .returns(ModernTreasury::Page[ModernTreasury::Models::BulkResult])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::BulkResult])
       end
       def list(
         after_cursor: nil,
+        # Unique identifier for the result entity object.
         entity_id: nil,
+        # The type of the request that created this result. bulk_request is the only
+        # supported `request_type`
         entity_type: nil,
         per_page: nil,
+        # Unique identifier for the request that created this bulk result. This is the ID
+        # of the bulk request when `request_type` is bulk_request
         request_id: nil,
+        # The type of the request that created this result. bulk_request is the only
+        # supported `request_type`
         request_type: nil,
+        # One of successful or failed.
         status: 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/connection_legal_entities.rbi

@@ -3,49 +3,68 @@
 module ModernTreasury
   module Resources
     class ConnectionLegalEntities
+      # Create a connection legal entity.
       sig do
         params(
           connection_id: String,
-          legal_entity: ModernTreasury::Models::ConnectionLegalEntityCreateParams::LegalEntity,
+          legal_entity: T.any(
+            ModernTreasury::Models::ConnectionLegalEntityCreateParams::LegalEntity,
+            ModernTreasury::Internal::AnyHash
+          ),
           legal_entity_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::ConnectionLegalEntity)
       end
-      def create(connection_id:, legal_entity: nil, legal_entity_id: nil, request_options: {})
-      end
-
+      def create(
+        # The ID of the connection.
+        connection_id:,
+        # The legal entity.
+        legal_entity: nil,
+        # The ID of the legal entity.
+        legal_entity_id: nil,
+        request_options: {}
+      ); end
+      # Get details on a single connection legal entity.
       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::ConnectionLegalEntity)
       end
-      def retrieve(id, request_options: {})
-      end
-
+      def retrieve(
+        # The id of an existing connection legal entity.
+        id,
+        request_options: {}
+      ); end
+      # Update a connection legal entity.
       sig do
         params(
           id: String,
-          status: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          status: ModernTreasury::Models::ConnectionLegalEntityUpdateParams::Status::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
           .returns(ModernTreasury::Models::ConnectionLegalEntity)
       end
-      def update(id, status: nil, request_options: {})
-      end
-
+      def update(
+        # The id of an existing connection legal entity.
+        id,
+        # The status of the connection legal entity.
+        status: nil,
+        request_options: {}
+      ); end
+      # Get a list of all connection legal entities.
       sig do
         params(
           after_cursor: T.nilable(String),
           connection_id: String,
           legal_entity_id: String,
           per_page: Integer,
-          status: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          status: ModernTreasury::Models::ConnectionLegalEntityListParams::Status::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
         )
-          .returns(ModernTreasury::Page[ModernTreasury::Models::ConnectionLegalEntity])
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::ConnectionLegalEntity])
       end
       def list(
         after_cursor: nil,
@@ -54,12 +73,10 @@ module ModernTreasury
         per_page: nil,
         status: 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/connections.rbi

@@ -3,22 +3,29 @@
 module ModernTreasury
   module Resources
     class Connections
+      # Get a list of all connections.
       sig do
         params(
           after_cursor: T.nilable(String),
           entity: String,
           per_page: Integer,
           vendor_customer_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::Connection])
-      end
-      def list(after_cursor: nil, entity: nil, per_page: nil, vendor_customer_id: nil, request_options: {})
-      end
-
-      sig { params(client: ModernTreasury::Client).void }
-      def initialize(client:)
+          .returns(ModernTreasury::Internal::Page[ModernTreasury::Models::Connection])
       end
+      def list(
+        after_cursor: nil,
+        # A string code representing the vendor (i.e. bank).
+        entity: nil,
+        per_page: nil,
+        # An identifier assigned by the vendor to your organization.
+        vendor_customer_id: nil,
+        request_options: {}
+      ); end
+      # @api private
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:); end
     end
   end
 end