code: def max_results(raw: false, on_batch: nil, discard_results: false)
        compiled_query = compile
        batch_size = 1_000
        results = []
        # determine if there is a user provided hard limit
        _limit = (@limit.is_a?(Numeric) && @limit > 0) ? @limit : nil
        compiled_query[:skip] ||= 0
  
        loop do
          # always reset the batch size
          compiled_query[:limit] = batch_size
  
          # if a hard limit was set by the user, then if the remaining amount
          # is less than the batch size, set the new limit to the remaining amount.
          unless _limit.nil?
            compiled_query[:limit] = _limit if _limit < batch_size
          end
  
          response = fetch!( compiled_query )
          break if response.error? || response.results.empty?
  
          items = response.results
          items = decode(items) unless raw
          # if a block is provided, we do not keep the results after processing.
          if block_given?
            items.each(&Proc.new)
          else
            # concat results unless discard_results is true
            results += items unless discard_results
          end
  
          on_batch.call(items) if on_batch.present?
          # if we get less than the maximum set of results, most likely the next
          # query will return emtpy results - no need to perform it.
          break if items.count < compiled_query[:limit]
  
          # if we have a set limit, then subtract from the total amount the user requested
          # from the total in the current result set. Break if we've reached our limit.
          unless _limit.nil?
            _limit -= items.count
            break if _limit < 1
          end
  
          # add to the skip count for the next iteration
          compiled_query[:skip] += batch_size
        end
        results
      end
docs: max_results is used to iterate through as many API requests as possible using
   :skip and :limit paramter.
   @!visibility private