mindee 5.4.0 → 5.6.0

data/lib/mindee/v2/client.rb

@@ -18,26 +18,11 @@ module Mindee
         @mindee_api = Mindee::V2::HTTP::MindeeApiV2.new(api_key: api_key)
       end
 
-      # Retrieves a result from a given queue or URL to the result.
-      # @param product [Class<Mindee::V2::Product::BaseProduct>] The return class.
-      # @param resource [String] ID of the inference or URL to the result.
-      # @return [Mindee::V2::Parsing::BaseResponse]
-      def get_result(product, resource)
-        @mindee_api.req_get_result(product, resource)
-      end
-
-      # Retrieves an inference from a given queue or URL to the job.
-      # @param job_id [String] ID of the job.
-      # @return [Mindee::V2::Parsing::JobResponse]
-      def get_job(job_id)
-        @mindee_api.req_get_job(job_id)
-      end
-
-      # Enqueue a document for async parsing.
+      # Send a file to the asynchronous processing queue for inference.
       # @param product [Class<Mindee::V2::Product::BaseProduct>] The return class.
       # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
       #   The source of the input document (local file or URL).
-      # @param params [Hash, Input::BaseParameters] Parameters for the inference.
+      # @param params [Hash, ClientOptions::BaseProductParameters] Parameters for the inference.
       # @return [Mindee::V2::Parsing::JobResponse]
       def enqueue(
         product,
@@ -48,19 +33,51 @@ module Mindee
         normalized_params.validate_async_params
         logger.debug("Enqueueing document to model '#{normalized_params.model_id}'.")
 
-        @mindee_api.req_post_enqueue(input_source, normalized_params)
+        @mindee_api.req_post_product_enqueue(input_source, normalized_params)
+      end
+
+      # Get the status of an inference that was previously enqueued.
+      # Can be used for polling.
+      # @param url [String] HTTPS URL to the job.
+      # @return [Mindee::V2::Parsing::JobResponse]
+      def get_job_by_url(url)
+        @mindee_api.req_get_job_by_url(url)
+      end
+
+      # Get the result of an inference that was previously enqueued.
+      # @param product [Class<Mindee::V2::Product::BaseProduct>] The return class.
+      # @param url [String] HTTPS URL to the result.
+      # @return [Mindee::V2::Parsing::BaseResponse]
+      def get_result_by_url(product, url)
+        @mindee_api.req_get_result_by_url(product, url)
+      end
+
+      # Get the result of an inference that was previously enqueued.
+      # Prefer using `get_result_by_url` using the result URL returned by the Job.
+      # @param product [Class<Mindee::V2::Product::BaseProduct>] The return class.
+      # @param resource [String] ID of the inference or URL to the result.
+      # @return [Mindee::V2::Parsing::BaseResponse]
+      def get_result(product, resource)
+        @mindee_api.req_get_result_by_id(product, resource)
       end
 
-      # Enqueues to an asynchronous endpoint and automatically polls for a response.
-      #
+      # Get the status of an inference that was previously enqueued.
+      # Prefer using `get_job_by_url` with the polling URL returned by enqueue.
+      # @param job_id [String] ID of the job.
+      # @return [Mindee::V2::Parsing::JobResponse]
+      def get_job(job_id)
+        @mindee_api.req_get_job_by_id(job_id)
+      end
+
+      # Send a file to the inference queue and return the results when complete.
       # @param product [Class<Mindee::V2::Product::BaseProduct>] The return class.
       # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
       #   The source of the input document (local file or URL).
-      # @param params [Hash, Input::BaseParameters] Parameters for the inference.
+      # @param params [Hash, ClientOptions::BaseProductParameters] Parameters for the inference.
       # @param polling_options [Hash, PollingOptions, nil] Parameters for polling.
       # @param cancellation_token [Mindee::HTTP::CancellationToken, nil] Token for cancellation.
       # @return [Parsing::BaseResponse]
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
       def enqueue_and_get_result(
         product,
         input_source,
@@ -84,29 +101,31 @@ module Mindee
 
         sleep(normalized_params.polling_options.initial_delay_sec)
         retry_counter = 1
-        poll_results = get_job(job_id)
+        polling_url = enqueue_response.job.polling_url
+
+        job_response = get_job_by_url(polling_url)
 
         while retry_counter < normalized_params.polling_options.max_retries
-          if poll_results.job.status == 'Failed'
+          if job_response.job.status == 'Failed'
             break
-          elsif !poll_results.job.result_url.nil?
-            return get_result(product, poll_results.job.result_url)
+          elsif !job_response.job.result_url.nil?
+            return get_result_by_url(product, job_response.job.result_url)
           end
 
           logger.debug(
             "Successfully enqueued inference with job id: #{job_id}.\n" \
             "Attempt n°#{retry_counter}/#{normalized_params.polling_options.max_retries}.\n" \
-            "Job status: #{poll_results.job.status}."
+            "Job status: #{job_response.job.status}."
           )
 
           raise Mindee::Error::MindeeError, 'Enqueueing of the document was canceled.' if cancellation_token&.canceled?
 
           sleep(normalized_params.polling_options.delay_sec)
-          poll_results = get_job(job_id)
+          job_response = get_job_by_url(polling_url)
           retry_counter += 1
         end
 
-        error = poll_results.job.error
+        error = job_response.job.error
         unless error.nil?
           err_to_raise = Mindee::Error::MindeeHTTPErrorV2.new(error)
           # NOTE: purposefully decoupled from the line above, otherwise rubocop thinks `error` is a `message` param.
@@ -117,14 +136,21 @@ module Mindee
         raise Mindee::Error::MindeeError,
               "Asynchronous parsing request timed out after #{sec_count} seconds"
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      # Searches for a list of available models for the given API key.
-      # @param model_name [String]
-      # @param model_type [String]
-      # @return [Mindee::V2::Parsing::Search::SearchResponse]
+      # Search for resources matching the given criteria.
+      # @param params [ClientOptions::BaseSearchParameters] Search parameters.
+      # @return [Mindee::V2::Parsing::Search::BaseSearchResponse] A search response containing the matching resources.
+      def search(params)
+        @mindee_api.req_get_search(params)
+      end
+
+      # Returns a list of models matching a criteria for the given API key.
+      # @deprecated Use {#search} instead.
+      # @param model_name [String, nil] Name filter.
+      # @param model_type [String, nil] Model type filter.
+      # @return [Mindee::V2::Search::Models::ModelSearchResponse]
       def search_models(model_name, model_type)
-        @mindee_api.search_models(model_name, model_type)
+        search(Search::Models::ModelSearchParameters.new(name: model_name, model_type: model_type))
       end
 
       private
@@ -136,7 +162,7 @@ module Mindee
       def normalize_parameters(param_class, params, polling_options: nil)
         if params.is_a?(Hash)
           params[:polling_options] = polling_options if polling_options
-        elsif params.is_a?(Mindee::Input::BaseParameters) && !polling_options.nil?
+        elsif params.is_a?(Mindee::V2::ClientOptions::BaseProductParameters) && !polling_options.nil?
           params.polling_options = polling_options
         end
         return param_class.from_hash(params: params) if params.is_a?(Hash)

data/lib/mindee/v2/client_options/base_product_parameters.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V2
+    module ClientOptions
+      # Base class for parameters accepted by all V2 endpoints.
+      class BaseProductParameters
+        # @return [String] Model ID to use for the inference. Required.
+        attr_reader :model_id
+
+        # @return [String, nil] Optional: a free-form string to tag the request with your own identifier.
+        # For example, an internal document ID, reference number, or database key.
+        # If set, it will be included in the job and result responses.
+        attr_reader :file_alias
+
+        # @return [Array<String>, nil] Webhook IDs to call after all processing is finished.
+        # If empty, no webhooks will be used.
+        attr_reader :webhook_ids
+
+        # @return [Input::PollingOptions] Options for polling. Set only if having timeout issues.
+        attr_reader :polling_options
+
+        # @return [Boolean, nil] Whether to close the file after parsing.
+        attr_reader :close_file
+
+        # @param [String] model_id ID of the model
+        # @param [String, nil] file_alias File alias, if applicable.
+        # @param [Array<String>, nil] webhook_ids List of webhook IDs to propagate the API response to.
+        # @param [Hash, Input::PollingOptions, nil] polling_options Options for polling. Set only if having timeout
+        # issues.
+        # @param [Boolean, nil] close_file Whether to close the file after parsing.
+        def initialize(
+          model_id,
+          file_alias: nil,
+          webhook_ids: nil,
+          polling_options: nil,
+          close_file: true
+        )
+          raise Error::MindeeInputError, 'Model ID is required.' if model_id.nil? || model_id.empty?
+
+          @model_id = model_id
+          @file_alias = file_alias
+          @webhook_ids = webhook_ids || []
+          @polling_options = get_clean_polling_options(polling_options)
+          @close_file = close_file.nil? || close_file
+        end
+
+        # Sets polling options after normalizing hash inputs.
+        # @param [Hash, Input::PollingOptions, nil] polling_options
+        # @return [Input::PollingOptions]
+        def polling_options=(polling_options)
+          @polling_options = get_clean_polling_options(polling_options)
+        end
+
+        # @return [String] Slug for the endpoint.
+        def self.slug
+          if self == BaseProductParameters
+            raise NotImplementedError, 'Cannot access `slug` directly on the BaseProductParameters class.'
+          end
+
+          ''
+        end
+
+        # @return [String] Slug for the endpoint.
+        def slug
+          self.class.slug
+        end
+
+        # Load from a hash
+        # @param [Hash] params Parameters to provide as a hash.
+        # @return [BaseProductParameters]
+        def self.from_hash(params: {})
+          load_from_hash(params: params)
+          new(
+            params[:model_id],
+            file_alias: params[:file_alias],
+            webhook_ids: params[:webhook_ids],
+            polling_options: params[:polling_options],
+            close_file: params[:close_file]
+          )
+        end
+
+        # Loads a prediction from a Hash.
+        # @param [Hash] params Parameters to provide as a hash.
+        # @return [Hash]
+        def self.load_from_hash(params: {})
+          params.transform_keys!(&:to_sym)
+
+          if params.empty? || params[:model_id].nil? || params[:model_id].empty?
+            raise Error::MindeeInputError, 'Model ID is required.'
+          end
+
+          polling_options_input = params.fetch(:page_options, Input::PollingOptions.new)
+          if polling_options_input.is_a?(Hash)
+            polling_options_input = polling_options_input.transform_keys(&:to_sym)
+            Input::PollingOptions.new(
+              initial_delay_sec: polling_options_input.fetch(:initial_delay_sec, 2.0),
+              delay_sec: polling_options_input.fetch(:delay_sec, 1.5),
+              max_retries: polling_options_input.fetch(:max_retries, 80)
+            )
+          end
+          params
+        end
+
+        # Appends base form data to the provided array.
+        # @param [Array] form_data Array of form fields
+        # @return [Array]
+        def append_form_data(form_data)
+          form_data.push(['alias', @file_alias]) if @file_alias
+          webhook_ids = @webhook_ids || []
+          form_data.push(['webhook_ids', webhook_ids.join(',')]) unless @webhook_ids.nil? || webhook_ids.empty?
+          form_data
+        end
+
+        # Validates the parameters for async auto-polling
+        def validate_async_params
+          min_delay_sec = 1
+          min_initial_delay_sec = 1
+          min_retries = 2
+
+          if @polling_options.delay_sec < min_delay_sec
+            raise ArgumentError,
+                  "Cannot set auto-poll delay to less than #{min_delay_sec} second(s)"
+          end
+          if @polling_options.initial_delay_sec < min_initial_delay_sec
+            raise ArgumentError,
+                  "Cannot set initial parsing delay to less than #{min_initial_delay_sec} second(s)"
+          end
+          return unless @polling_options.max_retries < min_retries
+
+          raise ArgumentError,
+                "Cannot set auto-poll retries to less than #{min_retries}"
+        end
+
+        private
+
+        # Cleans a proper polling options object potentially from a hash.
+        # @param [Hash, Input::PollingOptions, nil] polling_options Polling options.
+        # @return [Input::PollingOptions] Valid polling options object.
+        def get_clean_polling_options(polling_options)
+          return Input::PollingOptions.new if polling_options.is_a?(Input::PollingOptions)
+
+          if polling_options.is_a?(Hash)
+            polling_options = polling_options.transform_keys(&:to_sym)
+            output_polling_options = Input::PollingOptions.new(
+              initial_delay_sec: polling_options.fetch(:initial_delay_sec, 2.0),
+              delay_sec: polling_options.fetch(:delay_sec, 1.5),
+              max_retries: polling_options.fetch(:max_retries, 80)
+            )
+          else
+            output_polling_options = if polling_options.is_a?(Input::PollingOptions)
+                                       polling_options || Input::PollingOptions.new
+                                     else
+                                       Input::PollingOptions.new
+                                     end
+          end
+          output_polling_options
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/client_options/base_search_parameters.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V2
+    module ClientOptions
+      # Base parameters for searches.
+      class BaseSearchParameters
+        # @return [Integer, nil] 1-based page index.
+        attr_reader :page
+        # @return [Integer, nil] Number of items per page.
+        attr_reader :per_page
+
+        # @param page [Integer, nil] 1-based page index.
+        # @param per_page [Integer, nil] Number of items per page.
+        def initialize(page: nil, per_page: nil)
+          @page = page
+          @per_page = per_page
+        end
+
+        # Gets the request parameters for the search request.
+        # @return [Hash{String => String, Array<String>}]
+        def request_parameters
+          params = {} # : Hash[String, String | Array[String]]
+          params['page'] = @page.to_s unless @page.nil?
+          params['per_page'] = @per_page.to_s unless @per_page.nil?
+          params
+        end
+
+        # @return [String] Slug of searchable resources.
+        def self.slug
+          raise NotImplementedError, 'Subclasses must implement the `slug` class method'
+        end
+
+        # @return [String] Slug of searchable resources.
+        def slug
+          self.class.slug
+        end
+
+        # @return [Class<Mindee::V2::Parsing::Search::BaseSearchResponse>] Response class for the search.
+        def self.response_class
+          raise NotImplementedError, 'Subclasses must implement the `response_class` class method'
+        end
+
+        # @return [Class<Mindee::V2::Parsing::Search::BaseSearchResponse>] Response class for the search.
+        def response_class
+          self.class.response_class
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/client_options.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'client_options/base_product_parameters'
+require_relative 'client_options/base_search_parameters'

data/lib/mindee/v2/http/mindee_api_v2.rb

@@ -17,13 +17,13 @@ module Mindee
           @settings = ApiV2Settings.new(api_key: api_key)
         end
 
-        # Sends a file to the queue.
+        # Send a file to the asynchronous processing queue for inference processing.
         #
         # @param input_source [Input::Source::LocalInputSource, Input::Source::URLInputSource]
-        # @param params [Input::BaseParameters]
+        # @param params [ClientOptions::BaseProductParameters]
         # @return [Mindee::V2::Parsing::JobResponse]
         # @raise [Mindee::Error::MindeeHttpErrorV2]
-        def req_post_enqueue(input_source, params)
+        def req_post_product_enqueue(input_source, params)
           @settings.check_api_key
           response = enqueue(
             input_source,
@@ -33,52 +33,53 @@ module Mindee
         end
 
         # Retrieves a result from a given queue.
-        # @param product [Class<Mindee::V2::Product::BaseProduct>] The return class.
-        # @param resource [String] ID of the inference or URL to the result.
+        # @param product [Class<Mindee::V2::Product::BaseProduct>]
+        # @param inference_id [String] ID of the inference or URL to the result.
         # @return [Mindee::V2::Parsing::BaseResponse]
-        def req_get_result(product, resource)
-          return req_get_result_url(product.response_type, resource) if uri?(resource)
-
-          @settings.check_api_key
-          response = result_req_get(
-            resource,
-            product
-          )
-          product.response_type.new(process_response(response))
+        def req_get_result_by_id(product, inference_id)
+          req_get_result_by_url(product, "#{@settings.base_url}/v2/products/#{product.slug}/results/#{inference_id}")
         end
 
         # Retrieves a queued job.
         #
         # @param job_id [String] ID of the job or URL to the job.
         # @return [Mindee::V2::Parsing::JobResponse]
-        def req_get_job(job_id)
+        def req_get_job_by_id(job_id)
+          req_get_job_by_url("#{@settings.base_url}/v2/jobs/#{job_id}")
+        end
+
+        # Retrieves a queued job from its polling URL.
+        #
+        # @param url [String] HTTPS URL to the job.
+        # @return [Mindee::V2::Parsing::JobResponse]
+        def req_get_job_by_url(url)
+          validate_https_url!(url)
           @settings.check_api_key
-          response = poll("#{@settings.base_url}/v2/jobs/#{job_id}")
+          response = poll(url)
           Mindee::V2::Parsing::JobResponse.new(process_response(response))
         end
 
-        # Retrieves a list of models.
-        # @param model_name [String, nil]
-        # @param model_type [String, nil]
-        # @return [Mindee::V2::Parsing::Search::SearchResponse]
-        def search_models(model_name, model_type)
-          Mindee::V2::Parsing::Search::SearchResponse.new(process_response(req_get_search_models(model_name,
-                                                                                                 model_type)))
+        # Retrieves a result from its URL.
+        #
+        # @param product [Class<Mindee::V2::Product::BaseProduct>]
+        # @param url [String] HTTPS URL to the result.
+        # @return [Mindee::V2::Parsing::BaseResponse]
+        def req_get_result_by_url(product, url)
+          validate_https_url!(url)
+          @settings.check_api_key
+          response = poll(url)
+          product.response_type.new(process_response(response))
         end
 
-        private
-
-        # Retrieves a list of models.
-        # @param model_name [String, nil]
-        # @param model_type [String, nil]
-        # @return [Net::HTTPResponse]
-        def req_get_search_models(model_name, model_type)
-          url = "#{@settings.base_url}/v2/search/models"
-          uri = URI(url)
+        # Retrieves a list of resources with the given criteria.
+        # @param params [ClientOptions::BaseSearchParameters] Search parameters.
+        # @return [Mindee::V2::Parsing::Search::BaseSearchResponse] A search response containing the matching
+        #   resources.
+        def req_get_search(params)
+          @settings.check_api_key
+          uri = URI("#{@settings.base_url}/v2/search/#{params.slug}")
 
-          query_params = {} # @type var query_params: Hash[Symbol, String | nil]
-          query_params[:name] = model_name if model_name
-          query_params[:model_type] = model_type if model_type
+          query_params = params.request_parameters
           uri.query = URI.encode_www_form(query_params) unless query_params.empty?
 
           headers = {
@@ -86,43 +87,27 @@ module Mindee
             'User-Agent' => @settings.user_agent,
           }
           req = Net::HTTP::Get.new(uri, headers)
-          req['Transfer-Encoding'] = 'chunked'
 
-          Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @settings.request_timeout) do |http|
-            return http.request(req)
+          response = Net::HTTP.start(uri.hostname, uri.port,
+                                     use_ssl: true,
+                                     open_timeout: @settings.request_timeout,
+                                     read_timeout: @settings.request_timeout) do |http|
+            http.request(req)
           end
-          raise Mindee::Error::MindeeError, 'Could not resolve server response.'
+          params.response_class.new(process_response(response))
         end
 
-        # @param resource [String] Resource to check.
-        # @return [Boolean]
-        def uri?(resource)
-          uri = URI.parse(resource)
-          throw Mindee::Error::MindeeError, 'HTTP is not supported.' if uri.scheme == 'http'
-          uri.scheme == 'https'
-        rescue URI::BadURIError, URI::InvalidURIError
-          false
-        end
-
-        # Retrieves a queued job.
-        #
-        # @param url [String]
-        # @return [Mindee::V2::Parsing::JobResponse]
-        def req_get_job_url(url)
-          @settings.check_api_key
-          response = poll(url)
-          Mindee::V2::Parsing::JobResponse.new(process_response(response))
-        end
+        private
 
-        # Retrieves a queued job.
+        # Validates that a URL uses HTTPS and includes a host.
         #
-        # @param result_class [Class<Mindee::V2::Parsing::BaseResponse>]
         # @param url [String]
-        # @return [Mindee::V2::Parsing::BaseResponse]
-        def req_get_result_url(result_class, url)
-          @settings.check_api_key
-          response = poll(url)
-          result_class.new(process_response(response))
+        # @return [void]
+        def validate_https_url!(url)
+          uri = URI.parse(url)
+          raise Mindee::Error::MindeeError, "Invalid URL: #{url}" unless uri.scheme == 'https' && !uri.host.to_s.empty?
+        rescue URI::BadURIError, URI::InvalidURIError
+          raise Mindee::Error::MindeeError, "Invalid URL: #{url}"
         end
 
         # Converts an HTTP response to a parsed response object.
@@ -155,23 +140,16 @@ module Mindee
             'User-Agent' => @settings.user_agent,
           }
           req = Net::HTTP::Get.new(uri, headers)
-          req['Transfer-Encoding'] = 'chunked'
 
-          Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @settings.request_timeout) do |http|
+          Net::HTTP.start(uri.hostname, uri.port,
+                          use_ssl: true,
+                          open_timeout: @settings.request_timeout,
+                          read_timeout: @settings.request_timeout) do |http|
             return http.request(req)
           end
           raise Mindee::Error::MindeeError, 'Could not resolve server response.'
         end
 
-        # Polls the API for the result of an inference.
-        #
-        # @param queue_id [String] ID of the queue.
-        # @param product [Class<Mindee::V2::Product::BaseProduct>] The return class.
-        # @return [Net::HTTPResponse]
-        def result_req_get(queue_id, product)
-          poll("#{@settings.base_url}/v2/products/#{product.slug}/results/#{queue_id}")
-        end
-
         # Handle parameters for the enqueue form
         # @param form_data [Array] Array of form fields
         # @param params [V2::Product::Extraction::Params::ExtractionParameters] Inference options.
@@ -191,7 +169,7 @@ module Mindee
         end
 
         # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
-        # @param params [Input::BaseParameters] Inference options.
+        # @param params [ClientOptions::BaseProductParameters] Inference options.
         # @return [Net::HTTPResponse, nil]
         def enqueue(input_source, params)
           uri = URI("#{@settings.base_url}/v2/products/#{params.slug}/enqueue")
@@ -218,7 +196,10 @@ module Mindee
           req.set_form(form_data, 'multipart/form-data')
           req['Transfer-Encoding'] = 'chunked'
 
-          Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @settings.request_timeout) do |http|
+          Net::HTTP.start(uri.hostname, uri.port,
+                          use_ssl: true,
+                          open_timeout: @settings.request_timeout,
+                          read_timeout: @settings.request_timeout) do |http|
             return http.request(req)
           end
           raise Mindee::Error::MindeeError, 'Could not resolve server response.'

data/lib/mindee/v2/parsing/search/base_search_response.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V2
+    module Parsing
+      module Search
+        # Base class for search responses.
+        class BaseSearchResponse < CommonResponse
+          # Pagination metadata.
+          # @return [Mindee::V2::Parsing::Search::PaginationMetadata]
+          attr_reader :pagination
+
+          # @param http_response [Hash] The parsed JSON payload from the API.
+          def initialize(http_response)
+            super
+
+            @pagination = PaginationMetadata.new(http_response['pagination'])
+          end
+
+          # Lines composing the response-specific body (header + items).
+          # @return [Array<String>]
+          def body_lines
+            raise NotImplementedError, 'body_lines must be implemented in subclasses'
+          end
+
+          # Pagination metadata (Obsolete).
+          # @deprecated Use {#pagination} instead.
+          # @return [Mindee::V2::Parsing::Search::PaginationMetadata]
+          def pagination_metadata
+            pagination
+          end
+
+          # String representation of the search response.
+          # @return [String]
+          def to_s
+            lines = body_lines
+            lines.push('Pagination Metadata')
+            lines.push('###################')
+            lines.push(@pagination.to_s)
+
+            lines.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/parsing/search/model_webhook.rb

@@ -4,7 +4,7 @@ module Mindee
   module V2
     module Parsing
       module Search
-        # Individual webhook information.
+        # Information about a model's webhook.
         class ModelWebhook
           # @return [String] ID of the webhook.
           attr_reader :id
@@ -15,14 +15,14 @@ module Mindee
           # @return [String] URL of the webhook.
           attr_reader :url
 
-          # @param payload [Hash] The parsed JSON payload mapping to the search model.
+          # @param payload [Hash] The parsed JSON payload mapping to the webhook.
           def initialize(payload)
             @id = payload['id']
             @name = payload['name']
             @url = payload['url']
           end
 
-          # String representation of the model.
+          # String representation of the webhook.
           # @return [String]
           def to_s
             [

data/lib/mindee/v2/parsing/search/pagination_metadata.rb

@@ -4,7 +4,7 @@ module Mindee
   module V2
     module Parsing
       module Search
-        # Pagination Metadata data associated with model search.
+        # Pagination metadata associated with searches.
         class PaginationMetadata
           # @return [Integer] Number of items per page.
           attr_reader :per_page