mailchimp-rest-api 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 428009c6c680a7c4bc6ec3b80fe5e4c1485df70e358928655fefabbf0b76637c
-  data.tar.gz: bd8307d56a558d64a4d7a7551a21cacf9dfe1e44036882191421c359c1b2682a
+  metadata.gz: 6bb470c7bf3ad957b57ec7bd7c19299e5594de1de05fc4a24b683da82ee3c998
+  data.tar.gz: d7951ce1b9194282a03b9cd1743b513c11003c3c50f9edce9e839ee38370d795
 SHA512:
-  metadata.gz: c3f2cc4b7561902a8ba1991b8acb68be65714a506854adea22cd3d0f1a7fa449aae6cea82267cb55d4b45a9ea7f11f6c4ba41b5e602d8a75ecb6f6f4df8a3102
-  data.tar.gz: f4bb0e6175805b8363ed59df417c4f103ee6b70c5bc40dd6003e7f8ac7eaef3ac5ac992a251b055d224981ab6142f9c460e2a0924ce7691bfbf0cc560e922f7f
+  metadata.gz: 3a59055a5853bd0d54741202c67029f6bbd4bc6f940a65f0fba3150fa36f747d54658aad02da3cd64b9840f51df88e06177af54f44aaaea7af057f877df0c935
+  data.tar.gz: e9b0b7630353f19c94ea8edaaad563288f4adb48c497ff05f2d40779c771d1a341d824eb2bdae1a6ca64dd544a1be0077af5bfbbc5ab9a6c6c658361ce69643c

data/README.md

@@ -1,99 +1,140 @@
 # Mailchimp REST API (Marketing)
 
+A Ruby gem for interacting with the Mailchimp Marketing API. This gem provides a clean, intuitive interface for working
+with Mailchimp's REST API, featuring automatic retries, pagination support, and comprehensive error handling.
+
+## Features
+
+- Supports Ruby versions: 2.6 through 3.3, head, jruby-9.4, truffleruby-24
+- Zero dependencies
+- Configurable auto-retries
+- Built-in pagination support
+- Comprehensive error handling
+- Clean, intuitive API interface
+
 ## Installation
 
-```bash
-bundle add mailchimp-rest-api
+Add this line to your application's Gemfile:
+
+```console
+gem 'mailchimp-rest-api'
 ```
 
-## Features
+And then execute:
 
-- Supported Ruby Versions - *(2.6 .. 3.3), head, jruby-9.4, truffleruby-24*
-- No dependencies;
-- Auto-retries (configured);
-- Pagination methods
+```console
+bundle install
+```
 
-## Usage
+## Quick Start
 
 ```ruby
-# Setup client
-MailchimpAPI.client = MailchimpAPI::Client.new(api_key: ENV['MAILCHIMP_API_KEY'])
-
-# Call any HTTP API
-MailchimpAPI.post(path, query: query, body: body, headers: headers)
-MailchimpAPI.get(path, query: query, body: body, headers: headers)
-MailchimpAPI.patch(path, query: query, body: body, headers: headers)
-MailchimpAPI.put(path, query: query, body: body, headers: headers)
-MailchimpAPI.delete(path, query: query, body: body, headers: headers)
-
-# Call any defined REST API (defined in lib/resources)
-MailchimpAPI::Audience::Members.show(audience_id, email, query: query)
-MailchimpAPI::Audience::Members.create(audience_id, body: body)
-
-# Or call it via shortcuts (defined in lib/client/api_methods.rb)
-MailchimpAPI.audience_members.show(audience_id, email, query: query)
-MailchimpAPI.audience_members.create(audience_id, body: body)
+# Configure the client
+MailchimpAPI.client = MailchimpAPI::Client.new(
+  api_key: ENV['MAILCHIMP_API_KEY']
+)
+
+# Example: Add a member to an audience
+response = MailchimpAPI.audience_members.create(
+  'audience_id',
+  body: {
+    email_address: 'user@example.com',
+    status: 'subscribed',
+    merge_fields: {
+      FNAME: 'John',
+      LNAME: 'Doe'
+    }
+  }
+)
+
+puts response.body[:status]
 ```
 
-### Response
+## Configuration
 
-`Response` object is returned after each `API` request.
+### Client Configuration
 
-#### Original HTTP response data
+The client accepts several configuration options:
 
-- `response.http_status` - response HTTP status as Integer
-- `response.http_body` - response body as String
-- `response.http_headers` - response headers as Hash with String keys
-- `response.http_response` - original Net::HTTP::Response object
-- `response.request` - Request object that was used to get this response
+```ruby
+client = MailchimpAPI::Client.new(
+  api_key: ENV['MAILCHIMP_API_KEY'],
+  retries: {
+    enabled: true,
+    count: 4,
+    sleep: [0, 0.25, 0.75, 1.5]  # Retry delays in seconds
+  },
+  http_opts: {
+    read_timeout: 30,
+    write_timeout: 30,
+    open_timeout: 30
+  }
+)
+```
+
+### Retry Configuration
+
+By default, the client will retry failed requests with the following configuration:
+
+- Enabled: true
+- Retry count: 4
+- Delay between retries: 0, 0.25, 0.75, 1.5 seconds
+
+Retries are triggered for:
+
+- Network errors
+- HTTP status codes: 409, 429, and 5xx responses
 
-#### Parsed JSON body methods
+### HTTP Options
 
-- `response.body` - parsed JSON body, keys are Symbols
-- `response[:field]` - gets `:field` attribute from parsed body,
-  returns nil if response have no such key
-- `response.fetch(:field)` - gets `:field` attribute from parsed body,
-  raises KeyError if response has no such key
+You can configure various HTTP options that are passed to `Net::HTTP.start`. Common options include:
 
-#### Error check methods
+- `read_timeout`
+- `write_timeout`
+- `open_timeout`
 
-- `response.success?` - checks HTTP status code is 2xx
-- `response.failed?` - checks HTTP status code is not 2xx
+## API Usage
 
-## Errors
+### Making Requests
+
+You can make HTTP requests directly:
+
+```ruby
+# GET request
+response = MailchimpAPI.get('/lists/<list_id>/members')
+
+# POST request
+response = MailchimpAPI.post(
+  '/lists/<list_id>/members',
+  body: { email_address: 'user@example.com' }
+)
+```
 
-All error classes inherit from `MailchimpAPI::Error` and provide:
+### Working with Responses
 
-- `error_type` - Error type returned by Mailchimp
-- `error_title` - Error title or response error class name
-- `error_status` - Error status or HTTP status
-- `error_detail` - Error description from Mailchimp
-- `error_fields` - Field-specific errors
-- `error_instance` - Error ID from Mailchimp
-- `response` - Response object
-- `request` - Request object
+The response object provides several useful methods:
 
-MailchimpAPI provides specific error classes for different types of errors:
+```ruby
+response = MailchimpAPI.get('/some/path')
 
-### Network Errors
+# Check response status
+response.success?  # true for 2xx status codes
+response.failed?   # true for non-2xx status codes
 
-- `MailchimpAPI::Errors::NetworkError` - Raised when a network error occurs
-  during request execution
+# Access response data
+response.body      # Parsed JSON body (symbolized keys)
+response[:field]   # Access specific field (returns nil if missing)
+response.fetch(:field)  # Access field (raises KeyError if missing)
 
-### HTTP Status Code Errors
+# Access HTTP details
+response.http_status
+response.http_body
+response.http_headers
+```
 
-- `MailchimpAPI::Errors::BadRequest` (400) - Invalid request parameters
-- `MailchimpAPI::Errors::Unauthorized` (401) - Invalid API key
-- `MailchimpAPI::Errors::Forbidden` (403) - Insufficient permissions
-- `MailchimpAPI::Errors::NotFound` (404) - Resource not found
-- `MailchimpAPI::Errors::MethodNotAllowed` (405) - HTTP method not allowed
-- `MailchimpAPI::Errors::RequestURITooLong` (414) - Request URI too long
-- `MailchimpAPI::Errors::UnprocessableEntity` (422) - Request validation failed
-- `MailchimpAPI::Errors::UpgradeRequired` (426) - API version upgrade required
-- `MailchimpAPI::Errors::TooManyRequests` (429) - Rate limit exceeded
-- `MailchimpAPI::Errors::ServerError` (5xx) - Mailchimp server error
+### Error Handling
 
-Example:
+The gem provides specific error classes for different types of errors:
 
 ```ruby
 begin
@@ -106,123 +147,130 @@ rescue MailchimpAPI::Errors::NetworkError => e
 end
 ```
 
-## Configuration options
+Available error classes:
 
-MailchimpAPI client accepts this additional options:
+- `NetworkError` - Network-related issues
+- `BadRequest` (400) - Invalid request parameters
+- `Unauthorized` (401) - Invalid API key
+- `Forbidden` (403) - Insufficient permissions
+- `NotFound` (404) - Resource not found
+- `UnprocessableEntity` (422) - Request validation failed
+- `TooManyRequests` (429) - Rate limit exceeded
+- `ServerError` (5xx) - Mailchimp server error
 
-- `:retries`
-- `:http_opts`
+## Resources
 
-### Option `:retries`
+Most resources support this APIs:
 
-This is a Hash with retries configuration.
-By default retries are enabled, 4 retries with 0, 0.25, 0.75, 1.5 seconds delay.
-Default config: `{enabled: true, count: 4, sleep: [0, 0.25, 0.75, 1.5]}`.
-New options are merged with defaults.
-Please keep `sleep` array same size as `count`.
+- `list` - List items
+- `create` - Create new item
+- `show` - Get item details
+- `update` - Update item
+- `delete` - Delete item
+- `each` - Iterate through items
 
-Retries happen on any network error, on 409, 429, 5xx response status code.
+### MailchimpAPI.audience_members
 
-```ruby
-client = MailchimpAPI::Client.new(
-  retries: {enabled: !Rails.env.test?, count: 5, sleep: [0, 0.25, 0.75, 1.5, 2]}
-  # ...
-)
-```
+- `list(list_id)` - List members
+- `create(list_id, body: { email_address: 'x', status: 'x' })` - Add member
+- `show(list_id, email)` - Get member
+- `update(list_id, email, body: { status: 'x' })` - Update member
+- `archive(list_id, email)` - Archive member
+- `add_or_update(list_id, email, body: { status: 'x' })` - Upsert member
+- `delete_permanent(list_id, email)` - Permanently delete
+- `each(list_id)` - Iterate members
 
-### Option `:http_opts`
+### MailchimpAPI.audience_member_tags
 
-This are the options that are provided to the `Net::HTTP.start` method,
-like `:read_timeout`, `:write_timeout`, etc.
+- `list(list_id, email)` - List tags
+- `create(list_id, email, body: { tags: [{name: 'x'}] })` - Add tags
+- `each(list_id, email)` - Iterate tags
 
-You can find full list of available options here <https://docs.ruby-lang.org/en/master/Net/HTTP.html#method-c-start>
-(Please choose you version of ruby).
+### MailchimpAPI.audience_segments
 
-By default it is an empty hash.
+- `list(list_id)` - List segments
+- `create(list_id, body: { name: 'x' })` - Create segment
+- `show(list_id, segment_id)` - Get segment
+- `update(list_id, segment_id, body: { name: 'x' })` - Update segment
+- `delete(list_id, segment_id)` - Delete segment
+- `batch_add_or_remove_members(list_id, segment_id, body: { members_to_add: [] })` - Bulk modify
+- `each(list_id)` - Iterate segments
 
-```ruby
-client = MailchimpAPI::Client.new(
-  http_opts: {read_timeout: 30, write_timeout: 30, open_timeout: 30}
-  # ...
-)
-```
+### MailchimpAPI.audience_segment_members
 
-## Pagination
+- `list(list_id, segment_id)` - List segment members
+- `create(list_id, segment_id, body: { email_address: 'x' })` - Add segment member
+- `delete(list_id, segment_id, email)` - Remove segment member
+- `each(list_id, segment_id)` - Iterate segment members
 
-All REST resources have `#each` method. Example:
+### MailchimpAPI.audience_interest_categories
 
-```ruby
-MailchimpAPI.audience_members.each(list_id) { |member| ... }
-MailchimpAPI.audience_member_tags.each(list_id, member_id) { |tag| ... }
-```
+- `list(list_id)` - List categories
+- `create(list_id, body: { title: 'x', type: 'x' })` - Create category
+- `show(list_id, category_id)` - Get category
+- `update(list_id, category_id, body: { title: 'x' })` - Update category
+- `delete(list_id, category_id)` - Delete category
+- `each(list_id)` - Iterate categories
 
-`Each` method accepts `query`, `body` and `headers` as any other API.
-By default it requests 1000 items on each page, but it is configurable through
-`query` parameter. Example:
+### MailchimpAPI.audience_interests
 
-```ruby
-MailchimpAPI.audience_members.each(list_id, query: { count: 100 }) { |member| ... }
-```
+- `list(list_id, category_id)` - List interests
+- `create(list_id, category_id, body: { name: 'x' })` - Create interest
+- `show(list_id, category_id, interest_id)` - Get interest
+- `update(list_id, category_id, interest_id, body: { name: 'x' })` - Update interest
+- `delete(list_id, category_id, interest_id)` - Delete interest
+- `each(list_id, category_id)` - Iterate interests
 
-## Request
+### MailchimpAPI.audience_webhooks
 
-...
+- `list(list_id)` - List webhooks
+- `create(list_id, body: { url: 'x', events: {} })` - Create webhook
+- `show(list_id, webhook_id)` - Get webhook
+- `update(list_id, webhook_id, body: { events: {} })` - Update webhook
+- `delete(list_id, webhook_id)` - Delete webhook
+- `each(list_id)` - Iterate webhooks
 
-## APIs
+### Pagination
 
-### Audience Members
+Most resources support pagination through the `each` method:
 
-- List `MailchimpAPI.audience_members.get(audience_id)`
-- Create `MailchimpAPI.audience_members.create(audience_id, body: body)`
-- Show `MailchimpAPI.audience_members.show(audience_id, email)`
-- Update `MailchimpAPI.audience_members.update(audience_id, email, body: body)`
-- Add or Update `MailchimpAPI.audience_members.add_or_update(audience_id, email, body: body)`
-- Archive `MailchimpAPI.audience_members.delete(audience_id, email)`
-- Delete Permanently `MailchimpAPI.audience_members.delete(audience_id, email)`
-
-### Audience Member Tags
-
-- List `MailchimpAPI.audience_member_tags.get(audience_id, email)`
-- Create `MailchimpAPI.audience_member_tags.create(audience_id, email, body: body)`
+```ruby
+# Iterate through all members
+MailchimpAPI.audience_members.each(audience_id) do |member|
+  puts member['email_address']
+end
 
-### Audience Webhooks
+# Configure page size
+MailchimpAPI.audience_members.each(audience_id, query: { count: 100 }) do |member|
+  puts member['email_address']
+end
+```
 
-- List `MailchimpAPI.audience_webhooks.get(audience_id)`
-- Create `MailchimpAPI.audience_webhooks.create(audience_id, body: body)`
-- Show `MailchimpAPI.audience_webhooks.show(audience_id, webhook_id)`
-- Update `MailchimpAPI.audience_webhooks.update(audience_id, webhook_id, body: body)`
-- Delete `MailchimpAPI.audience_webhooks.delete(audience_id, webhook_id)`
+## Development
 
-### Audience Interest Categories
+After checking out the repo, run:
 
-- List `MailchimpAPI.audience_interest_categories.get(audience_id)`
-- Create `MailchimpAPI.audience_interest_categories.create(audience_id, body: body)`
-- Show `MailchimpAPI.audience_interest_categories.show(audience_id, webhook_id)`
-- Update `MailchimpAPI.audience_interest_categories.update(audience_id, webhook_id, body: body)`
-- Delete `MailchimpAPI.audience_interest_categories.delete(audience_id, webhook_id)`
+```bash
+bundle install
+```
 
-### Audience Interests
+To run tests:
 
-- List `MailchimpAPI.audience_interests.get(audience_id)`
-- Create `MailchimpAPI.audience_interests.create(audience_id, body: body)`
-- Show `MailchimpAPI.audience_interests.show(audience_id, webhook_id)`
-- Update `MailchimpAPI.audience_interests.update(audience_id, webhook_id, body: body)`
-- Delete `MailchimpAPI.audience_interests.delete(audience_id, webhook_id)`
+```bash
+bundle exec rspec
+```
 
-## Development
+To run linters:
 
 ```bash
-  rubocop
-  rspec
-  mdl README.md CHANGELOG.md RELEASE.md
+bundle exec rubocop
+bundle exec mdl README.md CHANGELOG.md RELEASE.md
 ```
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at <https://github.com/aglushkov/mailchimp-rest-api>.
+Bug reports and pull requests are welcome on GitHub at [https://github.com/andreyruby/mailchimp-rest-api](https://github.com/andreyruby/mailchimp-rest-api).
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-[pagination]: #pagination

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.1

data/lib/mailchimp-api/batch_request.rb

@@ -1,18 +1,35 @@
 # frozen_string_literal: true
 
 module MailchimpAPI
+  # Internal class for constructing batch operation requests
+  # @api private
   class BatchRequest
+    # API version prefix to be removed from paths
     API_VERSION_PREFIX = "/#{MailchimpAPI::API_VERSION}"
 
-    attr_reader :request, :operation_id
+    # @return [MailchimpAPI::Request] The original request object
+    attr_reader :request
 
+    # @return [String, nil] Optional operation ID for tracking batch operations
+    attr_reader :operation_id
+
+    # Creates a new batch request
+    # @param request [MailchimpAPI::Request] The original request to be batched
+    # @param operation_id [String, nil] Optional operation ID for tracking
     def initialize(request, operation_id: nil)
       @request = request
       @operation_id = operation_id
     end
 
-    # Make a batch operation request
-    # https://mailchimp.com/developer/marketing/guides/run-async-requests-batch-endpoint/#make-a-batch-operations-request
+    # Converts the request into a batch operation format
+    # @return [Hash] The operation in format suitable for `/batch` request
+    # @example
+    #   {
+    #     method: "GET",
+    #     path: "/lists",
+    #     params: { count: 10 },
+    #     operation_id: "get_lists"
+    #   }
     def operation
       operation = {
         method: request.method, # "GET", "POST", "PUT", "PATCH", "DELETE"

data/lib/mailchimp-api/client/api_methods.rb

@@ -2,26 +2,60 @@
 
 module MailchimpAPI
   class Client
-    #
-    # Methods to access API resources
-    #
+    # Methods to access Mailchimp API resources
     module APIMethods
+      # Returns a new instance of Audience::InterestCategories
+      # @return [Audience::InterestCategories] Interest categories resource
+      # @example
+      #   client.audience_interest_categories # => #<MailchimpAPI::Audience::InterestCategories>
       def audience_interest_categories
         Audience::InterestCategories.new(self)
       end
 
+      # Returns a new instance of Audience::Interests
+      # @return [Audience::Interests] Interests resource
+      # @example
+      #   client.audience_interests # => #<MailchimpAPI::Audience::Interests>
       def audience_interests
         Audience::Interests.new(self)
       end
 
+      # Returns a new instance of Audience::MemberTags
+      # @return [Audience::MemberTags] Member tags resource
+      # @example
+      #   client.audience_member_tags # => #<MailchimpAPI::Audience::MemberTags>
       def audience_member_tags
         Audience::MemberTags.new(self)
       end
 
+      # Returns a new instance of Audience::Members
+      # @return [Audience::Members] Members resource
+      # @example
+      #   client.audience_members # => #<MailchimpAPI::Audience::Members>
       def audience_members
         Audience::Members.new(self)
       end
 
+      # Returns a new instance of Audience::Segments
+      # @return [Audience::Segments] Segments resource
+      # @example
+      #   client.audience_segments # => #<MailchimpAPI::Audience::Segments>
+      def audience_segments
+        Audience::Segments.new(self)
+      end
+
+      # Returns a new instance of Audience::SegmentMembers
+      # @return [Audience::SegmentMembers] Segment members resource
+      # @example
+      #   client.audience_segment_members # => #<MailchimpAPI::Audience::SegmentMembers>
+      def audience_segment_members
+        Audience::SegmentMembers.new(self)
+      end
+
+      # Returns a new instance of Audience::Webhooks
+      # @return [Audience::Webhooks] Webhooks resource
+      # @example
+      #   client.audience_webhooks # => #<MailchimpAPI::Audience::Webhooks>
       def audience_webhooks
         Audience::Webhooks.new(self)
       end

data/lib/mailchimp-api/client/batch_methods.rb

@@ -2,30 +2,83 @@
 
 module MailchimpAPI
   class Client
-    #
     # Methods to create and run batch requests
-    #
     module BatchMethods
+      # Creates a new batch GET request
+      # @param path [String] API endpoint path
+      # @param query [Hash] Optional query parameters
+      # @param body [Hash] Optional request body
+      # @param headers [Hash] Optional request headers
+      # @param operation_id [String] Optional operation ID
+      # @return [BatchRequest] New batch request
+      # @example
+      #   request = client.batch_get_request("/lists", operation_id: "get_lists")
       def batch_get_request(path, query: nil, body: nil, headers: nil, operation_id: nil)
         new_batch_request(Net::HTTP::Get, path, query: query, body: body, headers: headers, operation_id: operation_id)
       end
 
+      # Creates a new batch POST request
+      # @param path [String] API endpoint path
+      # @param query [Hash] Optional query parameters
+      # @param body [Hash] Optional request body
+      # @param headers [Hash] Optional request headers
+      # @param operation_id [String] Optional operation ID
+      # @return [BatchRequest] New batch request
+      # @example
+      #   request = client.batch_post_request("/lists", body: { name: "New List" }, operation_id: "create_list")
       def batch_post_request(path, query: nil, body: nil, headers: nil, operation_id: nil)
         new_batch_request(Net::HTTP::Post, path, query: query, body: body, headers: headers, operation_id: operation_id)
       end
 
+      # Creates a new batch PUT request
+      # @param path [String] API endpoint path
+      # @param query [Hash] Optional query parameters
+      # @param body [Hash] Optional request body
+      # @param headers [Hash] Optional request headers
+      # @param operation_id [String] Optional operation ID
+      # @return [BatchRequest] New batch request
+      # @example
+      #   request = client.batch_put_request("/lists/123", body: { name: "Updated List" }, operation_id: "update_list")
       def batch_put_request(path, query: nil, body: nil, headers: nil, operation_id: nil)
         new_batch_request(Net::HTTP::Put, path, query: query, body: body, headers: headers, operation_id: operation_id)
       end
 
+      # Creates a new batch PATCH request
+      # @param path [String] API endpoint path
+      # @param query [Hash] Optional query parameters
+      # @param body [Hash] Optional request body
+      # @param headers [Hash] Optional request headers
+      # @param operation_id [String] Optional operation ID
+      # @return [BatchRequest] New batch request
+      # @example
+      #   request = client.batch_patch_request("/lists/123", body: { name: "Updated List" }, operation_id: "update_list")
       def batch_patch_request(path, query: nil, body: nil, headers: nil, operation_id: nil)
         new_batch_request(Net::HTTP::Patch, path, query: query, body: body, headers: headers, operation_id: operation_id)
       end
 
+      # Creates a new batch DELETE request
+      # @param path [String] API endpoint path
+      # @param query [Hash] Optional query parameters
+      # @param body [Hash] Optional request body
+      # @param headers [Hash] Optional request headers
+      # @param operation_id [String] Optional operation ID
+      # @return [BatchRequest] New batch request
+      # @example
+      #   request = client.batch_delete_request("/lists/123", operation_id: "delete_list")
       def batch_delete_request(path, query: nil, body: nil, headers: nil, operation_id: nil)
         new_batch_request(Net::HTTP::Delete, path, query: query, body: body, headers: headers, operation_id: operation_id)
       end
 
+      # Executes a batch of requests
+      # @param batch_requests [Array<BatchRequest>] Array of batch requests to execute
+      # @param query [Hash] Optional query parameters
+      # @return [Response] API response
+      # @example
+      #   requests = [
+      #     client.batch_get_request("/lists", operation_id: "get_lists"),
+      #     client.batch_post_request("/lists", body: { name: "New List" }, operation_id: "create_list")
+      #   ]
+      #   response = client.batch(requests)
       def batch(batch_requests, query: nil)
         operations = batch_requests.map(&:operation)
         post("batches", query: query, body: {operations: operations})
@@ -33,12 +86,18 @@ module MailchimpAPI
 
       private
 
-      # rubocop:disable Metrics/ParameterLists
+      # Creates a new batch request
+      # @param http_method [Net::HTTP::Request] HTTP method class
+      # @param path [String] API endpoint path
+      # @param query [Hash] Optional query parameters
+      # @param body [Hash] Optional request body
+      # @param headers [Hash] Optional request headers
+      # @param operation_id [String] Optional operation ID
+      # @return [BatchRequest] New batch request
       def new_batch_request(http_method, path, query: nil, body: nil, headers: nil, operation_id: nil)
         request = new_request(http_method, path: path, query: query, body: body, headers: headers)
         BatchRequest.new(request, operation_id: operation_id)
       end
-      # rubocop:enable Metrics/ParameterLists
     end
   end
 end