couchbase 3.0.0.alpha.5-x86_64-linux → 3.5.0-x86_64-linux

data/lib/couchbase/search_options.rb

@@ -1,4 +1,4 @@
-#    Copyright 2020 Couchbase, Inc.
+#  Copyright 2020-2021 Couchbase, Inc.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -13,1480 +13,1610 @@
 #  limitations under the License.
 
 module Couchbase
-  class Cluster
-    class SearchQuery
-      # Prepare {MatchQuery} body
-      #
-      # @param [String] match
-      # @yieldparam [MatchQuery] query
-      #
-      # @return [MatchQuery]
-      def self.match(match, &block)
-        MatchQuery.new(match, &block)
+  class SearchRequest
+    # Creates a search request, used to perform operations against the Full Text Search (FTS) Couchbase service.
+    #
+    # @overload new(search_query)
+    #   Will run an FTS +SearchQuery+
+    #   @param [SearchQuery] search_query
+    #
+    # @overload new(vector_search)
+    #   Will run a +VectorSearch+
+    #   @param [VectorSearch] vector_search
+    #
+    #   @!macro uncommitted
+    def initialize(search)
+      case search
+      when SearchQuery
+        @search_query = search
+      when VectorSearch
+        @vector_search = search
+      else
+        raise Error::InvalidArgument, "Search type must be either SearchQuery or VectorSearch, #{search.class} given"
       end
+    end
 
-      # A match query analyzes the input text and uses that analyzed text to query the index.
-      class MatchQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+    # Can be used to run a +SearchQuery+ together with an existing +VectorSearch+
+    # Note that a maximum of one +SearchQuery+ can be provided.
+    #
+    # @param [SearchQuery] query
+    #
+    # @return [SearchRequest] for chaining purposes
+    def search_query(query)
+      raise Error::InvalidArgument, "A SearchQuery has already been specified" unless @search_query.nil?
+
+      @search_query = query
+      self
+    end
 
-        # @return [String]
-        attr_accessor :field
+    # Can be used to run a +VectorSearch+ together with an existing +SearchQuery+
+    # Note that a maximum of one +VectorSearch+ can be provided.
+    #
+    # @param [VectorSearch] query
+    #
+    # @return [SearchRequest] for chaining purposes
+    #
+    # @!macro uncommitted
+    def vector_search(query)
+      raise Error::InvalidArgument, "A VectorSearch has already been specified" unless @vector_search.nil?
+
+      @vector_search = query
+      self
+    end
 
-        # @return [String]
-        attr_accessor :analyzer
+    # @api private
+    def to_backend
+      [
+        (@search_query || SearchQuery.match_none).to_json,
+        {
+          vector_search: @vector_search&.to_backend,
+        },
+      ]
+    end
+  end
 
-        # @return [Integer]
-        attr_accessor :prefix_length
+  class SearchQuery
+    # @return [Hash<Symbol, #to_json>]
+    def to_h
+      {}
+    end
 
-        # @return [Integer]
-        attr_accessor :fuzziness
+    # @return [String]
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
 
-        # @param [String] match
-        # @yieldparam [MatchQuery] self
-        def initialize(match)
-          super()
-          @match = match
-          yield self if block_given?
-        end
+    # Prepare {MatchQuery} body
+    #
+    # @param [String] match
+    # @yieldparam [MatchQuery] query
+    #
+    # @return [MatchQuery]
+    def self.match(match, &block)
+      MatchQuery.new(match, &block)
+    end
 
-        # @return [String]
-        def to_json(*args)
-          data = {"match" => @match}
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          data["analyzer"] = analyzer if analyzer
-          if fuzziness
-            data["fuzziness"] = fuzziness
-            data["prefix_length"] = prefix_length if prefix_length
-          end
-          data.to_json(*args)
-        end
-      end
+    # A match query analyzes the input text and uses that analyzed text to query the index.
+    class MatchQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-      # Prepare {MatchPhraseQuery} body
-      #
-      # @param [String] match_phrase
-      # @yieldparam [MatchPhraseQuery] query
-      #
-      # @return [MatchPhraseQuery]
-      def self.match_phrase(match_phrase, &block)
-        MatchPhraseQuery.new(match_phrase, &block)
-      end
+      # @return [String]
+      attr_accessor :field
 
-      # The input text is analyzed and a phrase query is built with the terms resulting from the analysis.
-      class MatchPhraseQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+      # @return [String]
+      attr_accessor :analyzer
 
-        # @return [String]
-        attr_accessor :field
+      # @return [Integer]
+      attr_accessor :prefix_length
 
-        # @return [String]
-        attr_accessor :analyzer
+      # @return [Integer]
+      attr_accessor :fuzziness
 
-        # @param [String] match_phrase
-        #
-        # @yieldparam [MatchPhraseQuery] self
-        def initialize(match_phrase)
-          super()
-          @match_phrase = match_phrase
-          yield self if block_given?
-        end
+      # @return [nil, :or, :and]
+      attr_accessor :operator
 
-        # @return [String]
-        def to_json(*args)
-          data = {"match_phrase" => @match_phrase}
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          data["analyzer"] = analyzer if analyzer
-          data.to_json(*args)
-        end
+      # @param [String] match
+      # @yieldparam [MatchQuery] self
+      def initialize(match)
+        super()
+        @match = match
+        yield self if block_given?
       end
 
-      # Prepare {RegexpQuery} body
-      #
-      # @param [String] regexp
-      # @yieldparam [RegexpQuery] query
-      #
-      # @return [RegexpQuery]
-      def self.regexp(regexp, &block)
-        RegexpQuery.new(regexp, &block)
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {:match => @match}
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        data[:analyzer] = analyzer if analyzer
+        data[:operator] = operator if operator
+        data[:fuzziness] = fuzziness if fuzziness
+        data[:prefix_length] = prefix_length if prefix_length
+        data
       end
+    end
 
-      # Finds documents containing terms that match the specified regular expression.
-      class RegexpQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+    # Prepare {MatchPhraseQuery} body
+    #
+    # @param [String] match_phrase
+    # @yieldparam [MatchPhraseQuery] query
+    #
+    # @return [MatchPhraseQuery]
+    def self.match_phrase(match_phrase, &block)
+      MatchPhraseQuery.new(match_phrase, &block)
+    end
 
-        # @return [String]
-        attr_accessor :field
+    # The input text is analyzed and a phrase query is built with the terms resulting from the analysis.
+    class MatchPhraseQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-        # @param [String] regexp
-        #
-        # @yieldparam [RegexpQuery] self
-        def initialize(regexp)
-          super()
-          @regexp = regexp
-          yield self if block_given?
-        end
+      # @return [String]
+      attr_accessor :field
 
-        # @return [String]
-        def to_json(*args)
-          data = {"regexp" => @regexp}
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          data.to_json(*args)
-        end
-      end
+      # @return [String]
+      attr_accessor :analyzer
 
-      # Prepare {QueryStringQuery} body
-      #
-      # @param [String] query_string
-      # @yieldparam [QueryStringQuery] query
+      # @param [String] match_phrase
       #
-      # @return [QueryStringQuery]
-      def self.query_string(query_string, &block)
-        QueryStringQuery.new(query_string, &block)
+      # @yieldparam [MatchPhraseQuery] self
+      def initialize(match_phrase)
+        super()
+        @match_phrase = match_phrase
+        yield self if block_given?
       end
 
-      # The query string query allows humans to describe complex queries using a simple syntax.
-      class QueryStringQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {:match_phrase => @match_phrase}
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        data[:analyzer] = analyzer if analyzer
+        data
+      end
+    end
 
-        # @param [String] query_string
-        #
-        # @yieldparam [QueryStringQuery] self
-        def initialize(query_string)
-          super()
-          @query_string = query_string
-          yield self if block_given?
-        end
+    # Prepare {RegexpQuery} body
+    #
+    # @param [String] regexp
+    # @yieldparam [RegexpQuery] query
+    #
+    # @return [RegexpQuery]
+    def self.regexp(regexp, &block)
+      RegexpQuery.new(regexp, &block)
+    end
 
-        # @return [String]
-        def to_json(*args)
-          data = {"query" => @query_string}
-          data["boost"] = boost if boost
-          data.to_json(*args)
-        end
-      end
+    # Finds documents containing terms that match the specified regular expression.
+    class RegexpQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-      # Prepare {WildcardQuery} body
-      #
-      # @param [String] wildcard
-      # @yieldparam [WildcardQuery] query
+      # @return [String]
+      attr_accessor :field
+
+      # @param [String] regexp
       #
-      # @return [WildcardQuery]
-      def self.wildcard(wildcard, &block)
-        WildcardQuery.new(wildcard, &block)
+      # @yieldparam [RegexpQuery] self
+      def initialize(regexp)
+        super()
+        @regexp = regexp
+        yield self if block_given?
       end
 
-      # Interprets * and ? wildcards as found in a lot of applications, for an easy implementation of such a search feature.
-      class WildcardQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
-
-        # @return [String]
-        attr_accessor :field
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {:regexp => @regexp}
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        data
+      end
+    end
 
-        # @param [String] wildcard
-        #
-        # @yieldparam [WildcardQuery] self
-        def initialize(wildcard)
-          super()
-          @wildcard = wildcard
-          yield self if block_given?
-        end
+    # Prepare {QueryStringQuery} body
+    #
+    # @param [String] query_string
+    # @yieldparam [QueryStringQuery] query
+    #
+    # @return [QueryStringQuery]
+    def self.query_string(query_string, &block)
+      QueryStringQuery.new(query_string, &block)
+    end
 
-        # @return [String]
-        def to_json(*args)
-          data = {"wildcard" => @wildcard}
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          data.to_json(*args)
-        end
-      end
+    # The query string query allows humans to describe complex queries using a simple syntax.
+    class QueryStringQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-      # Prepare {DocIdQuery} body
-      #
-      # @param [String...] doc_ids
-      # @yieldparam [DocIdQuery] query
+      # @param [String] query_string
       #
-      # @return [DocIdQuery]
-      def self.doc_id(*doc_ids)
-        DocIdQuery.new(*doc_ids)
+      # @yieldparam [QueryStringQuery] self
+      def initialize(query_string)
+        super()
+        @query_string = query_string
+        yield self if block_given?
       end
 
-      # Allows to restrict matches to a set of specific documents.
-      class DocIdQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {:query => @query_string}
+        data[:boost] = boost if boost
+        data
+      end
+    end
 
-        # @return [String]
-        attr_accessor :field
+    # Prepare {WildcardQuery} body
+    #
+    # @param [String] wildcard
+    # @yieldparam [WildcardQuery] query
+    #
+    # @return [WildcardQuery]
+    def self.wildcard(wildcard, &block)
+      WildcardQuery.new(wildcard, &block)
+    end
 
-        # @param [String...] doc_ids
-        #
-        # @yieldparam [DocIdQuery] self
-        def initialize(*doc_ids)
-          super()
-          @doc_ids = doc_ids
-          yield self if block_given?
-        end
+    # Interprets * and ? wildcards as found in a lot of applications, for an easy implementation of such a search feature.
+    class WildcardQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-        # @return [String]
-        def to_json(*args)
-          data = {"doc_ids" => @doc_ids.flatten.uniq}
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          data.to_json(*args)
-        end
-      end
+      # @return [String]
+      attr_accessor :field
 
-      # Prepare {BooleanFieldQuery} body
-      #
-      # @param [Boolean] value
-      # @yieldparam [BooleanFieldQuery] query
+      # @param [String] wildcard
       #
-      # @return [BooleanFieldQuery]
-      def self.boolean_field(value)
-        BooleanFieldQuery.new(value)
+      # @yieldparam [WildcardQuery] self
+      def initialize(wildcard)
+        super()
+        @wildcard = wildcard
+        yield self if block_given?
       end
 
-      # Allow to match `true`/`false` in a field mapped as boolean.
-      class BooleanFieldQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
-
-        # @return [String]
-        attr_accessor :field
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {:wildcard => @wildcard}
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        data
+      end
+    end
 
-        # @param [Boolean] value
-        #
-        # @yieldparam [BooleanFieldQuery] self
-        def initialize(value)
-          super()
-          @value = value
-          yield self if block_given?
-        end
+    # Prepare {DocIdQuery} body
+    #
+    # @param [String...] doc_ids
+    # @yieldparam [DocIdQuery] query
+    #
+    # @return [DocIdQuery]
+    def self.doc_id(*doc_ids)
+      DocIdQuery.new(*doc_ids)
+    end
 
-        # @return [String]
-        def to_json(*args)
-          data = {"bool" => @value}
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          data.to_json(*args)
-        end
-      end
+    # Allows to restrict matches to a set of specific documents.
+    class DocIdQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-      # Prepare {DateRangeQuery} body
-      #
-      # @yieldparam [DateRangeQuery] query
+      # @param [String...] doc_ids
       #
-      # @return [DateRangeQuery]
-      def self.date_range(&block)
-        DateRangeQuery.new(&block)
+      # @yieldparam [DocIdQuery] self
+      def initialize(*doc_ids)
+        super()
+        @doc_ids = doc_ids
+        yield self if block_given?
       end
 
-      # The date range query finds documents containing a date value in the specified field within the specified range.
-      class DateRangeQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
-
-        # @return [String]
-        attr_accessor :field
-
-        # @return [String]
-        attr_accessor :date_time_parser
-
-        # Sets the lower boundary of the range.
-        #
-        # @note The lower boundary is considered inclusive by default on the server side.
-        #
-        # @param [Time, String] time_point start time. When +Time+ object is passed {#date_time_parser} must be +nil+ (to use server default)
-        # @param [Boolean] inclusive
-        def start_time(time_point, inclusive = nil)
-          @start_time = time_point
-          @start_inclusive = inclusive
-        end
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {:ids => @doc_ids.flatten.uniq}
+        data[:boost] = boost if boost
+        data
+      end
+    end
 
-        # Sets the upper boundary of the range.
-        #
-        # @note The upper boundary is considered exclusive by default on the server side.
-        #
-        # @param [Time, String] time_point end time. When +Time+ object is passed {#date_time_parser} must be +nil+ (to use server default)
-        # @param [Boolean] inclusive
-        def end_time(time_point, inclusive = nil)
-          @end_time = time_point
-          @end_inclusive = inclusive
-        end
+    # Prepare {BooleanFieldQuery} body
+    #
+    # @param [Boolean] value
+    # @yieldparam [BooleanFieldQuery] query
+    #
+    # @return [BooleanFieldQuery]
+    def self.boolean_field(value)
+      BooleanFieldQuery.new(value)
+    end
 
-        # @yieldparam [DateRangeQuery] self
-        def initialize
-          super
-          @start_time = nil
-          @start_inclusive = nil
-          @end_time = nil
-          @end_inclusive = nil
-          yield self if block_given?
-        end
+    # Allow to match `true`/`false` in a field mapped as boolean.
+    class BooleanFieldQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-        DATE_FORMAT_RFC3339 = "%Y-%m-%dT%H:%M:%S%:z"
+      # @return [String]
+      attr_accessor :field
 
-        # @return [String]
-        def to_json(*args)
-          if @start_time.nil? && @end_time.nil?
-            raise ArgumentError, "either start_time or end_time must be set for DateRangeQuery"
-          end
-
-          data = {}
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          data["datetime_parser"] = date_time_parser if date_time_parser
-          if @start_time
-            data["start"] = if @start_time.respond_to?(:strftime)
-                              @start_time.strftime(DATE_FORMAT_RFC3339)
-                            else
-                              @start_time
-                            end
-            data["inclusive_start"] = @start_inclusive unless @start_inclusive.nil?
-          end
-          if @end_time
-            data["end"] = if @end_time.respond_to?(:strftime)
-                            @end_time.strftime(DATE_FORMAT_RFC3339)
-                          else
-                            @end_time
-                          end
-            data["inclusive_end"] = @end_inclusive unless @end_inclusive.nil?
-          end
-          data.to_json(*args)
-        end
+      # @param [Boolean] value
+      #
+      # @yieldparam [BooleanFieldQuery] self
+      def initialize(value)
+        super()
+        @value = value
+        yield self if block_given?
       end
 
-      # Prepare {NumericRangeQuery} body
-      #
-      # @yieldparam [NumericRangeQuery] query
-      #
-      # @return [NumericRangeQuery]
-      def self.numeric_range(&block)
-        NumericRangeQuery.new(&block)
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {:bool => @value}
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        data
       end
+    end
 
-      # The numeric range query finds documents containing a numeric value in the specified field within the specified range.
-      class NumericRangeQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+    # Prepare {DateRangeQuery} body
+    #
+    # @yieldparam [DateRangeQuery] query
+    #
+    # @return [DateRangeQuery]
+    def self.date_range(&block)
+      DateRangeQuery.new(&block)
+    end
 
-        # @return [String]
-        attr_accessor :field
-
-        # Sets lower bound of the range.
-        #
-        # The lower boundary is considered inclusive by default on the server side.
-        #
-        # @param [Numeric] lower_bound
-        # @param [Boolean] inclusive
-        def min(lower_bound, inclusive = nil)
-          @min = lower_bound
-          @min_inclusive = inclusive
-        end
+    # The date range query finds documents containing a date value in the specified field within the specified range.
+    class DateRangeQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-        # Sets upper bound of the range.
-        #
-        # The upper boundary is considered exclusive by default on the server side.
-        #
-        # @param [Numeric] upper_bound
-        # @param [Boolean] inclusive
-        def max(upper_bound, inclusive = nil)
-          @max = upper_bound
-          @max_inclusive = inclusive
-        end
+      # @return [String]
+      attr_accessor :field
 
-        # @yieldparam [NumericRangeQuery] self
-        def initialize
-          super
-          @min = nil
-          @min_inclusive = nil
-          @max = nil
-          @max_inclusive = nil
-          yield self if block_given?
-        end
+      # @return [String]
+      attr_accessor :date_time_parser
 
-        # @return [String]
-        def to_json(*args)
-          if @min.nil? && @max.nil?
-            raise ArgumentError, "either min or max must be set for NumericRangeQuery"
-          end
-
-          data = {}
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          if @min
-            data["min"] = @min
-            data["inclusive_min"] = @min_inclusive unless @min_inclusive.nil?
-          end
-          if @max
-            data["max"] = @max
-            data["inclusive_max"] = @max_inclusive unless @max_inclusive.nil?
-          end
-          data.to_json(*args)
-        end
+      # Sets the lower boundary of the range.
+      #
+      # @note The lower boundary is considered inclusive by default on the server side.
+      #
+      # @param [Time, String] time_point start time. When +Time+ object is passed {#date_time_parser} must be +nil+ (to use server
+      #   default)
+      # @param [Boolean] inclusive
+      def start_time(time_point, inclusive = nil)
+        @start_time = time_point
+        @start_inclusive = inclusive
       end
 
-      # Prepare {TermRangeQuery} body
+      # Sets the upper boundary of the range.
       #
-      # @yieldparam [TermRangeQuery] query
+      # @note The upper boundary is considered exclusive by default on the server side.
       #
-      # @return [TermRangeQuery]
-      def self.term_range(&block)
-        TermRangeQuery.new(&block)
+      # @param [Time, String] time_point end time. When +Time+ object is passed {#date_time_parser} must be +nil+ (to use server default)
+      # @param [Boolean] inclusive
+      def end_time(time_point, inclusive = nil)
+        @end_time = time_point
+        @end_inclusive = inclusive
       end
 
-      # The term range query finds documents containing a string value in the specified field within the specified range.
-      class TermRangeQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+      # @yieldparam [DateRangeQuery] self
+      def initialize
+        super
+        @start_time = nil
+        @start_inclusive = nil
+        @end_time = nil
+        @end_inclusive = nil
+        yield self if block_given?
+      end
 
-        # @return [String]
-        attr_accessor :field
-
-        # Sets lower bound of the range.
-        #
-        # The lower boundary is considered inclusive by default on the server side.
-        #
-        # @param [String] lower_bound
-        # @param [Boolean] inclusive
-        def min(lower_bound, inclusive = nil)
-          @min = lower_bound
-          @min_inclusive = inclusive
-        end
+      DATE_FORMAT_RFC3339 = "%Y-%m-%dT%H:%M:%S%:z".freeze
 
-        # Sets upper bound of the range.
-        #
-        # The upper boundary is considered exclusive by default on the server side.
-        #
-        # @param [String] upper_bound
-        # @param [Boolean] inclusive
-        def max(upper_bound, inclusive = nil)
-          @max = upper_bound
-          @max_inclusive = inclusive
-        end
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        raise ArgumentError, "either start_time or end_time must be set for DateRangeQuery" if @start_time.nil? && @end_time.nil?
 
-        # @yieldparam [TermRangeQuery] self
-        def initialize
-          super
-          @min = nil
-          @min_inclusive = nil
-          @max = nil
-          @max_inclusive = nil
-          yield self if block_given?
+        data = {}
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        data[:datetime_parser] = date_time_parser if date_time_parser
+        if @start_time
+          data[:start] = if @start_time.respond_to?(:strftime)
+                           @start_time.strftime(DATE_FORMAT_RFC3339)
+                         else
+                           @start_time
+                         end
+          data[:inclusive_start] = @start_inclusive unless @start_inclusive.nil?
         end
-
-        # @return [String]
-        def to_json(*args)
-          if @min.nil? && @max.nil?
-            raise ArgumentError, "either min or max must be set for TermRangeQuery"
-          end
-
-          data = {}
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          if @min
-            data["min"] = @min
-            data["inclusive_min"] = @min_inclusive unless @min_inclusive.nil?
-          end
-          if @max
-            data["max"] = @max
-            data["inclusive_max"] = @max_inclusive unless @max_inclusive.nil?
-          end
-          data.to_json(*args)
+        if @end_time
+          data[:end] = if @end_time.respond_to?(:strftime)
+                         @end_time.strftime(DATE_FORMAT_RFC3339)
+                       else
+                         @end_time
+                       end
+          data[:inclusive_end] = @end_inclusive unless @end_inclusive.nil?
         end
+        data
       end
+    end
 
-      # Prepare {GeoDistanceQuery} body
-      #
-      # @yieldparam [GeoDistanceQuery] query
-      #
-      # @param [Float] latitude location latitude
-      # @param [Float] longitude location longitude
-      # @param [String] distance how big is area (number with units)
-      #
-      # @return [GeoDistanceQuery]
-      def self.geo_distance(longitude, latitude, distance, &block)
-        GeoDistanceQuery.new(longitude, latitude, distance, &block)
-      end
-
-      # Finds `geopoint` indexed matches around a point with the given distance.
-      class GeoDistanceQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+    # Prepare {NumericRangeQuery} body
+    #
+    # @yieldparam [NumericRangeQuery] query
+    #
+    # @return [NumericRangeQuery]
+    def self.numeric_range(&block)
+      NumericRangeQuery.new(&block)
+    end
 
-        # @return [String]
-        attr_accessor :field
+    # The numeric range query finds documents containing a numeric value in the specified field within the specified range.
+    class NumericRangeQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-        # @yieldparam [GeoDistanceQuery] self
-        # @param [Float] longitude
-        # @param [Float] latitude
-        # @param [Float] distance
-        def initialize(longitude, latitude, distance)
-          super()
-          @longitude = longitude
-          @latitude = latitude
-          @distance = distance
-          yield self if block_given?
-        end
+      # @return [String]
+      attr_accessor :field
 
-        # @return [String]
-        def to_json(*args)
-          data = {
-              "location" => [@longitude, @latitude],
-              "distance" => @distance
-          }
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          data.to_json(*args)
-        end
+      # Sets lower bound of the range.
+      #
+      # The lower boundary is considered inclusive by default on the server side.
+      #
+      # @param [Numeric] lower_bound
+      # @param [Boolean] inclusive
+      def min(lower_bound, inclusive = nil)
+        @min = lower_bound
+        @min_inclusive = inclusive
       end
 
-      # Prepare {GeoBoundingBoxQuery} body
-      #
-      # @yieldparam [GeoDistanceQuery] query
+      # Sets upper bound of the range.
       #
-      # @param [Float] top_left_longitude
-      # @param [Float] top_left_latitude
-      # @param [Float] bottom_right_longitude
-      # @param [Float] bottom_right_latitude
+      # The upper boundary is considered exclusive by default on the server side.
       #
-      # @return [GeoBoundingBoxQuery]
-      def self.geo_bounding_box(top_left_longitude, top_left_latitude, bottom_right_longitude, bottom_right_latitude, &block)
-        GeoBoundingBoxQuery.new(top_left_longitude, top_left_latitude, bottom_right_longitude, bottom_right_latitude, &block)
+      # @param [Numeric] upper_bound
+      # @param [Boolean] inclusive
+      def max(upper_bound, inclusive = nil)
+        @max = upper_bound
+        @max_inclusive = inclusive
       end
 
-      # Finds `geopoint` indexed matches in a given bounding box.
-      class GeoBoundingBoxQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+      # @yieldparam [NumericRangeQuery] self
+      def initialize
+        super
+        @min = nil
+        @min_inclusive = nil
+        @max = nil
+        @max_inclusive = nil
+        yield self if block_given?
+      end
 
-        # @return [String]
-        attr_accessor :field
-
-        # @yieldparam [GeoBoundingBoxQuery] self
-        #
-        # @param [Float] top_left_longitude
-        # @param [Float] top_left_latitude
-        # @param [Float] bottom_right_longitude
-        # @param [Float] bottom_right_latitude
-        def initialize(top_left_longitude, top_left_latitude, bottom_right_longitude, bottom_right_latitude)
-          super()
-          @top_left_longitude = top_left_longitude
-          @top_left_latitude = top_left_latitude
-          @bottom_right_longitude = bottom_right_longitude
-          @bottom_right_latitude = bottom_right_latitude
-          yield self if block_given?
-        end
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        raise ArgumentError, "either min or max must be set for NumericRangeQuery" if @min.nil? && @max.nil?
 
-        # @return [String]
-        def to_json(*args)
-          data = {
-              "top_left" => [@top_left_longitude, @top_left_latitude],
-              "bottom_right" => [@bottom_right_longitude, @bottom_right_latitude]
-          }
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          data.to_json(*args)
+        data = {}
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        if @min
+          data[:min] = @min
+          data[:inclusive_min] = @min_inclusive unless @min_inclusive.nil?
         end
+        if @max
+          data[:max] = @max
+          data[:inclusive_max] = @max_inclusive unless @max_inclusive.nil?
+        end
+        data
       end
+    end
 
-      # Prepare {ConjunctionQuery} body
-      #
-      # @yieldparam [ConjunctionQuery] query
-      #
-      # @return [ConjunctionQuery]
-      def self.conjuncts(*queries, &block)
-        ConjunctionQuery.new(*queries, &block)
-      end
-
-      # Result documents must satisfy all of the child queries.
-      class ConjunctionQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
-
-        # @yieldparam [ConjunctionQuery] self
-        #
-        # @param [*SearchQuery] queries
-        def initialize(*queries)
-          super()
-          @queries = queries.flatten
-          yield self if block_given?
-        end
+    # Prepare {TermRangeQuery} body
+    #
+    # @yieldparam [TermRangeQuery] query
+    #
+    # @return [TermRangeQuery]
+    def self.term_range(&block)
+      TermRangeQuery.new(&block)
+    end
 
-        # @param [*SearchQuery] queries
-        def and_also(*queries)
-          @queries |= queries.flatten
-        end
+    # The term range query finds documents containing a string value in the specified field within the specified range.
+    class TermRangeQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-        def empty?
-          @queries.empty?
-        end
+      # @return [String]
+      attr_accessor :field
 
-        # @return [String]
-        def to_json(*args)
-          raise ArgumentError, "compound conjunction query must have sub-queries" if @queries.nil? || @queries.empty?
-          data = {"conjuncts" => @queries.uniq}
-          data["boost"] = boost if boost
-          data.to_json(*args)
-        end
+      # Sets lower bound of the range.
+      #
+      # The lower boundary is considered inclusive by default on the server side.
+      #
+      # @param [String] lower_bound
+      # @param [Boolean] inclusive
+      def min(lower_bound, inclusive = nil)
+        @min = lower_bound
+        @min_inclusive = inclusive
       end
 
-      # Prepare {ConjunctionQuery} body
+      # Sets upper bound of the range.
       #
-      # @yieldparam [ConjunctionQuery] query
+      # The upper boundary is considered exclusive by default on the server side.
       #
-      # @return [ConjunctionQuery]
-      def self.disjuncts(*queries, &block)
-        DisjunctionQuery.new(*queries, &block)
+      # @param [String] upper_bound
+      # @param [Boolean] inclusive
+      def max(upper_bound, inclusive = nil)
+        @max = upper_bound
+        @max_inclusive = inclusive
       end
 
-      # Result documents must satisfy a configurable min number of child queries.
-      class DisjunctionQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
-
-        # @return [Integer]
-        attr_accessor :min
-
-        # @yieldparam [DisjunctionQuery] self
-        #
-        # @param [*SearchQuery] queries
-        def initialize(*queries)
-          super()
-          @queries = queries.flatten
-          yield self if block_given?
-        end
+      # @yieldparam [TermRangeQuery] self
+      def initialize
+        super
+        @min = nil
+        @min_inclusive = nil
+        @max = nil
+        @max_inclusive = nil
+        yield self if block_given?
+      end
 
-        # @param [*SearchQuery] queries
-        def or_else(*queries)
-          @queries |= queries.flatten
-        end
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        raise ArgumentError, "either min or max must be set for TermRangeQuery" if @min.nil? && @max.nil?
 
-        def empty?
-          @queries.empty?
+        data = {}
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        if @min
+          data[:min] = @min
+          data[:inclusive_min] = @min_inclusive unless @min_inclusive.nil?
         end
-
-        # @return [String]
-        def to_json(*args)
-          raise ArgumentError, "compound disjunction query must have sub-queries" if @queries.nil? || @queries.empty?
-          data = {"disjuncts" => @queries.uniq}
-          if min
-            raise ArgumentError, "disjunction query has fewer sub-queries than configured minimum" if @queries.size < min
-            data["min"] = min
-          end
-          data["boost"] = boost if boost
-          data.to_json(*args)
+        if @max
+          data[:max] = @max
+          data[:inclusive_max] = @max_inclusive unless @max_inclusive.nil?
         end
+        data
       end
+    end
 
-      # Prepare {BooleanQuery} body
-      #
-      # @yieldparam [BooleanQuery] query
-      #
-      # @return [BooleanQuery]
-      def self.booleans(&block)
-        BooleanQuery.new(&block)
-      end
+    # Prepare {GeoDistanceQuery} body
+    #
+    # @yieldparam [GeoDistanceQuery] query
+    #
+    # @param [Float] latitude location latitude
+    # @param [Float] longitude location longitude
+    # @param [String] distance how big is area (number with units)
+    #
+    # @return [GeoDistanceQuery]
+    def self.geo_distance(longitude, latitude, distance, &block)
+      GeoDistanceQuery.new(longitude, latitude, distance, &block)
+    end
 
-      # The boolean query is a useful combination of conjunction and disjunction queries.
-      class BooleanQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+    # Finds `geopoint` indexed matches around a point with the given distance.
+    class GeoDistanceQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-        # @yieldparam [BooleanQuery] self
-        def initialize
-          super()
-          @must = ConjunctionQuery.new
-          @must_not = DisjunctionQuery.new
-          @should = DisjunctionQuery.new
-          yield self if block_given?
-        end
+      # @return [String]
+      attr_accessor :field
 
-        # @param [Integer] min minimal value for "should" disjunction query
-        def should_min(min)
-          @should.min = min
-          self
-        end
+      # @yieldparam [GeoDistanceQuery] self
+      # @param [Float] longitude
+      # @param [Float] latitude
+      # @param [Float] distance
+      def initialize(longitude, latitude, distance)
+        super()
+        @longitude = longitude
+        @latitude = latitude
+        @distance = distance
+        yield self if block_given?
+      end
 
-        # @param [*SearchQuery] queries
-        def must(*queries)
-          @must.and_also(*queries)
-          self
-        end
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {
+          :location => [@longitude, @latitude],
+          :distance => @distance,
+        }
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        data
+      end
+    end
 
-        # @param [*SearchQuery] queries
-        def must_not(*queries)
-          @must_not.or_else(*queries)
-          self
-        end
+    # Prepare {GeoBoundingBoxQuery} body
+    #
+    # @yieldparam [GeoBoundingBoxQuery] query
+    #
+    # @param [Float] top_left_longitude
+    # @param [Float] top_left_latitude
+    # @param [Float] bottom_right_longitude
+    # @param [Float] bottom_right_latitude
+    #
+    # @return [GeoBoundingBoxQuery]
+    def self.geo_bounding_box(top_left_longitude, top_left_latitude, bottom_right_longitude, bottom_right_latitude, &block)
+      GeoBoundingBoxQuery.new(top_left_longitude, top_left_latitude, bottom_right_longitude, bottom_right_latitude, &block)
+    end
 
-        # @param [*SearchQuery] queries
-        def should(*queries)
-          @should.or_else(*queries)
-          self
-        end
+    # Finds `geopoint` indexed matches in a given bounding box.
+    class GeoBoundingBoxQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-        # @return [String]
-        def to_json(*args)
-          if @must.empty? && @must_not.empty? && @should.empty?
-            raise ArgumentError, "BooleanQuery must have at least one non-empty sub-query"
-          end
-          data = {}
-          data["must"] = @must unless @must.empty?
-          data["must_not"] = @must_not unless @must_not.empty?
-          data["should"] = @should unless @should.empty?
-          data["boost"] = boost if boost
-          data.to_json(*args)
-        end
-      end
+      # @return [String]
+      attr_accessor :field
 
-      # Prepare {TermQuery} body
+      # @yieldparam [GeoBoundingBoxQuery] self
       #
-      # @yieldparam [TermQuery] query
-      # @param [String] term
-      #
-      # @return [TermQuery]
-      def self.term(term, &block)
-        TermQuery.new(term, &block)
+      # @param [Float] top_left_longitude
+      # @param [Float] top_left_latitude
+      # @param [Float] bottom_right_longitude
+      # @param [Float] bottom_right_latitude
+      def initialize(top_left_longitude, top_left_latitude, bottom_right_longitude, bottom_right_latitude)
+        super()
+        @top_left_longitude = top_left_longitude
+        @top_left_latitude = top_left_latitude
+        @bottom_right_longitude = bottom_right_longitude
+        @bottom_right_latitude = bottom_right_latitude
+        yield self if block_given?
       end
 
-      # A query that looks for **exact** matches of the term in the index (no analyzer, no stemming). Useful to check what the actual content of the index is. It can also apply fuzziness on the term. Usual better alternative is `MatchQuery`.
-      class TermQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {
+          :top_left => [@top_left_longitude, @top_left_latitude],
+          :bottom_right => [@bottom_right_longitude, @bottom_right_latitude],
+        }
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        data
+      end
+    end
 
-        # @return [String]
-        attr_accessor :field
+    # A coordinate is a tuple of a latitude and a longitude.
+    #
+    # @see GeoPolygonQuery
+    # @see SearchQuery.geo_polygon
+    class Coordinate
+      # @return [Float]
+      attr_accessor :longitude
 
-        # @return [Integer]
-        attr_accessor :fuzziness
+      # @return [Float]
+      attr_accessor :latitude
 
-        # @return [Integer]
-        attr_accessor :prefix_length
+      def initialize(longitude, latitude)
+        @longitude = longitude
+        @latitude = latitude
+      end
+    end
 
-        # @yieldparam [TermQuery] self
-        #
-        # @param [String] term
-        def initialize(term)
-          super()
-          @term = term
-          yield self if block_given?
-        end
+    # Prepare {GeoPolygonQuery} body
+    #
+    # @yieldparam [GeoPolygonQuery] query
+    #
+    # @param [Array<Coordinate>] coordinates list of coordinates that forms polygon
+    #
+    # @return [GeoPolygonQuery]
+    #
+    # @!macro uncommitted
+    def self.geo_polygon(coordinates, &block)
+      GeoPolygonQuery.new(coordinates, &block)
+    end
 
-        # @return [String]
-        def to_json(*args)
-          data = {"term" => @term}
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          if fuzziness
-            data["fuzziness"] = fuzziness
-            data["prefix_length"] = prefix_length if prefix_length
-          end
-          data.to_json(*args)
-        end
-      end
+    # A search query which allows to match inside a geo polygon.
+    class GeoPolygonQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-      # Prepare {PrefixQuery} body
-      #
-      # @yieldparam [PrefixQuery] query
-      # @param [String] prefix
+      # @return [String]
+      attr_accessor :field
+
+      # @yieldparam [GeoPolygonQuery] self
       #
-      # @return [PrefixQuery]
-      def self.prefix(prefix, &block)
-        PrefixQuery.new(prefix, &block)
+      # @param [Array<Coordinate>] coordinates list of coordinates that forms polygon
+      def initialize(coordinates)
+        super()
+        @coordinates = coordinates
+        yield self if block_given?
       end
 
-      # The prefix query finds documents containing terms that start with the provided prefix. Usual better alternative is `MatchQuery`.
-      class PrefixQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {
+          :polygon_points => @coordinates.map { |coord| [coord.longitude, coord.latitude] },
+        }
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        data
+      end
+    end
 
-        # @return [String]
-        attr_accessor :field
+    # Prepare {ConjunctionQuery} body
+    #
+    # @yieldparam [ConjunctionQuery] query
+    #
+    # @return [ConjunctionQuery]
+    def self.conjuncts(...)
+      ConjunctionQuery.new(...)
+    end
 
-        # @yieldparam [PrefixQuery] self
-        #
-        # @param [String] prefix
-        def initialize(prefix)
-          super()
-          @prefix = prefix
-          yield self if block_given?
-        end
+    # Result documents must satisfy all of the child queries.
+    class ConjunctionQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-        # @return [String]
-        def to_json(*args)
-          data = {"prefix" => @prefix}
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          data.to_json(*args)
-        end
+      # @yieldparam [ConjunctionQuery] self
+      #
+      # @param [*SearchQuery] queries
+      def initialize(*queries)
+        super()
+        @queries = queries.flatten
+        yield self if block_given?
       end
 
-      # Prepare {PhraseQuery} body
-      #
-      # @yieldparam [PhraseQuery] query
-      # @param [*String] terms
-      #
-      # @return [PhraseQuery]
-      def self.phrase(*terms, &block)
-        PhraseQuery.new(*terms, &block)
+      # @param [*SearchQuery] queries
+      def and_also(*queries)
+        @queries |= queries.flatten
       end
 
-      # A query that looks for **exact** match of several terms (in the exact order) in the index. Usual better alternative is {MatchPhraseQuery}.
-      class PhraseQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+      def empty?
+        @queries.empty?
+      end
 
-        # @return [String]
-        attr_accessor :field
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        raise ArgumentError, "compound conjunction query must have sub-queries" if @queries.nil? || @queries.empty?
 
-        # @yieldparam [PhraseQuery] self
-        #
-        # @param [*String] terms
-        def initialize(*terms)
-          super()
-          @terms = terms.flatten
-          yield self if block_given?
-        end
-
-        # @return [String]
-        def to_json(*args)
-          data = {"terms" => @terms.flatten.uniq}
-          data["boost"] = boost if boost
-          data["field"] = field if field
-          data.to_json(*args)
-        end
+        data = {:conjuncts => @queries.uniq.map(&:to_h)}
+        data[:boost] = boost if boost
+        data
       end
+    end
 
-      # Prepare {MatchAllQuery} body
-      #
-      # @yieldparam [MatchAllQuery] query
-      #
-      # @return [MatchAllQuery]
-      def self.match_all(&block)
-        MatchAllQuery.new(&block)
-      end
+    # Prepare {ConjunctionQuery} body
+    #
+    # @yieldparam [DisjunctionQuery] query
+    #
+    # @return [DisjunctionQuery]
+    def self.disjuncts(...)
+      DisjunctionQuery.new(...)
+    end
 
-      # A query that matches all indexed documents.
-      class MatchAllQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+    # Result documents must satisfy a configurable min number of child queries.
+    class DisjunctionQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-        # @yieldparam [MatchAllQuery] self
-        def initialize
-          super()
-          yield self if block_given?
-        end
+      # @return [Integer]
+      attr_accessor :min
 
-        # @return [String]
-        def to_json(*args)
-          data = {"match_all" => nil}
-          data["boost"] = boost if boost
-          data.to_json(*args)
-        end
+      # @yieldparam [DisjunctionQuery] self
+      #
+      # @param [*SearchQuery] queries
+      def initialize(*queries)
+        super()
+        @queries = queries.flatten
+        yield self if block_given?
+      end
+
+      # @param [*SearchQuery] queries
+      def or_else(*queries)
+        @queries |= queries.flatten
       end
 
-      # Prepare {MatchNoneQuery} body
-      #
-      # @yieldparam [MatchNoneQuery] query
-      #
-      # @return [MatchNoneQuery]
-      def self.match_none(&block)
-        MatchNoneQuery.new(&block)
+      def empty?
+        @queries.empty?
       end
 
-      # A query that matches nothing.
-      class MatchNoneQuery < SearchQuery
-        # @return [Float]
-        attr_accessor :boost
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        raise ArgumentError, "compound disjunction query must have sub-queries" if @queries.nil? || @queries.empty?
 
-        # @yieldparam [MatchNoneQuery] self
-        def initialize
-          super()
-          yield self if block_given?
-        end
+        data = {:disjuncts => @queries.uniq.map(&:to_h)}
+        if min
+          raise ArgumentError, "disjunction query has fewer sub-queries than configured minimum" if @queries.size < min
 
-        # @return [String]
-        def to_json(*args)
-          data = {"match_none" => nil}
-          data["boost"] = boost if boost
-          data.to_json(*args)
+          data[:min] = min
         end
+        data[:boost] = boost if boost
+        data
       end
     end
 
-    class SearchSort
-      # @yieldparam [SearchSortScore]
-      # @return [SearchSortScore]
-      def self.score(&block)
-        SearchSortScore.new(&block)
-      end
+    # Prepare {BooleanQuery} body
+    #
+    # @yieldparam [BooleanQuery] query
+    #
+    # @return [BooleanQuery]
+    def self.booleans(&block)
+      BooleanQuery.new(&block)
+    end
 
-      # @yieldparam [SearchSortId]
-      # @return [SearchSortScore]
-      def self.id(&block)
-        SearchSortId.new(&block)
-      end
+    # The boolean query is a useful combination of conjunction and disjunction queries.
+    class BooleanQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-      # @param [String] name field name
-      # @yieldparam [SearchSortField]
-      # @return [SearchSortField]
-      def self.field(name, &block)
-        SearchSortField.new(name, &block)
+      # @yieldparam [BooleanQuery] self
+      def initialize
+        super()
+        @must = ConjunctionQuery.new
+        @must_not = DisjunctionQuery.new
+        @should = DisjunctionQuery.new
+        yield self if block_given?
       end
 
-      # @param [String] name field name
-      # @param [Float] longitude
-      # @param [Float] latitude
-      # @yieldparam [SearchSortField]
-      # @return [SearchSortGeoDistance]
-      def self.geo_distance(name, longitude, latitude, &block)
-        SearchSortGeoDistance.new(name, longitude, latitude, &block)
+      # @param [Integer] min minimal value for "should" disjunction query
+      def should_min(min)
+        @should.min = min
+        self
       end
 
-      class SearchSortScore < SearchSort
-        # @return [Boolean] if descending order should be applied
-        attr_accessor :desc
-
-        # @yieldparam [SearchSortScore]
-        def initialize
-          yield self if block_given?
-        end
+      # @param [*SearchQuery] queries
+      def must(*queries)
+        @must.and_also(*queries)
+        self
+      end
 
-        # @api private
-        def to_json(*args)
-          {by: :score, desc: desc}.to_json(*args)
-        end
+      # @param [*SearchQuery] queries
+      def must_not(*queries)
+        @must_not.or_else(*queries)
+        self
       end
 
-      class SearchSortId < SearchSort
-        # @return [Boolean] if descending order should be applied
-        attr_accessor :desc
+      # @param [*SearchQuery] queries
+      def should(*queries)
+        @should.or_else(*queries)
+        self
+      end
 
-        # @yieldparam [SearchSortId]
-        def initialize
-          yield self if block_given?
-        end
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        raise ArgumentError, "BooleanQuery must have at least one non-empty sub-query" if @must.empty? && @must_not.empty? && @should.empty?
 
-        # @api private
-        def to_json(*args)
-          {by: :id, desc: desc}.to_json(*args)
-        end
+        data = {}
+        data[:must] = @must.to_h unless @must.empty?
+        data[:must_not] = @must_not.to_h unless @must_not.empty?
+        data[:should] = @should.to_h unless @should.empty?
+        data[:boost] = boost if boost
+        data
       end
+    end
 
-      class SearchSortField < SearchSort
-        # @return [String] name of the field to sort by
-        attr_reader :field
+    # Prepare {TermQuery} body
+    #
+    # @yieldparam [TermQuery] query
+    # @param [String] term
+    #
+    # @return [TermQuery]
+    def self.term(term, &block)
+      TermQuery.new(term, &block)
+    end
 
-        # @return [Boolean] if descending order should be applied
-        attr_accessor :desc
+    # A query that looks for **exact** matches of the term in the index (no analyzer, no stemming). Useful to check what the actual
+    # content of the index is. It can also apply fuzziness on the term. Usual better alternative is `MatchQuery`.
+    class TermQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-        # @return [:auto, :string, :number, :date]
-        attr_accessor :type
+      # @return [String]
+      attr_accessor :field
 
-        # @return [:first, :last] where the documents with missing field should be placed
-        attr_accessor :missing
+      # @return [Integer]
+      attr_accessor :fuzziness
 
-        # @return [:default, :min, :max]
-        attr_accessor :mode
+      # @return [Integer]
+      attr_accessor :prefix_length
 
-        # @param [String] field the name of the filed for ordering
-        # @yieldparam [SearchSortField]
-        def initialize(field)
-          @field = field
-          yield self if block_given?
-        end
+      # @yieldparam [TermQuery] self
+      #
+      # @param [String] term
+      def initialize(term)
+        super()
+        @term = term
+        yield self if block_given?
+      end
 
-        # @api private
-        def to_json(*args)
-          {by: :field, field: field, desc: desc, type: type, missing: missing, mode: mode}.to_json(*args)
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {:term => @term}
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        if fuzziness
+          data[:fuzziness] = fuzziness
+          data[:prefix_length] = prefix_length if prefix_length
         end
+        data
       end
+    end
 
-      class SearchSortGeoDistance < SearchSort
-        # @return [String] name of the field to sort by
-        attr_reader :field
-
-        # @return [Boolean] if descending order should be applied
-        attr_accessor :desc
+    # Prepare {PrefixQuery} body
+    #
+    # @yieldparam [PrefixQuery] query
+    # @param [String] prefix
+    #
+    # @return [PrefixQuery]
+    def self.prefix(prefix, &block)
+      PrefixQuery.new(prefix, &block)
+    end
 
-        # @return [Float]
-        attr_reader :longitude
+    # The prefix query finds documents containing terms that start with the provided prefix. Usual better alternative is `MatchQuery`.
+    class PrefixQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-        # @return [Float]
-        attr_reader :latitude
+      # @return [nil, :or, :and]
+      attr_accessor :operator
 
-        # @return [:meters, :miles, :centimeters, :millimeters, :kilometers, :nauticalmiles, :feet, :yards, :inch]
-        attr_accessor :unit
+      # @return [String]
+      attr_accessor :field
 
-        # @param [String] field field name
-        # @param [Float] longitude
-        # @param [Float] latitude
-        # @yieldparam [SearchSortGeoDistance]
-        def initialize(field, longitude, latitude)
-          @field = field
-          @longitude = longitude
-          @latitude = latitude
-          yield self if block_given?
-        end
+      # @yieldparam [PrefixQuery] self
+      #
+      # @param [String] prefix
+      def initialize(prefix)
+        super()
+        @prefix = prefix
+        yield self if block_given?
+      end
 
-        # @api private
-        def to_json(*args)
-          {by: :geo_distance, field: field, desc: desc, location: [longitude, latitude], unit: unit}.to_json(*args)
-        end
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {:prefix => @prefix}
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        data
       end
     end
 
-    class SearchFacet
-      # @param [String] field_name
-      # @return [SearchFacetTerm]
-      def self.term(field_name, &block)
-        SearchFacetTerm.new(field_name, &block)
-      end
+    # Prepare {PhraseQuery} body
+    #
+    # Creates a new instances {PhraseQuery} passing all parameters into {PhraseQuery#initialize}.
+    #
+    # @return [PhraseQuery]
+    def self.phrase(...)
+      PhraseQuery.new(...)
+    end
+
+    # A query that looks for **exact** match of several terms (in the exact order) in the index. Usual better alternative is
+    # {MatchPhraseQuery}.
+    class PhraseQuery < SearchQuery
+      # @return [Float]
+      attr_accessor :boost
 
-      # @param [String] field_name
-      # @return [SearchFacetNumericRange]
-      def self.numeric_range(field_name, &block)
-        SearchFacetNumericRange.new(field_name, &block)
+      # @return [String]
+      attr_accessor :field
+
+      # @yieldparam [PhraseQuery] self
+      #
+      # @param [*String] terms
+      def initialize(*terms)
+        super()
+        @terms = terms.flatten
+        yield self if block_given?
       end
 
-      # @param [String] field_name
-      # @return [SearchFacetDateRange]
-      def self.date_range(field_name, &block)
-        SearchFacetDateRange.new(field_name, &block)
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        data = {:terms => @terms.flatten.uniq}
+        data[:boost] = boost if boost
+        data[:field] = field if field
+        data
       end
+    end
 
-      class SearchFacetTerm
-        # @return [String]
-        attr_reader :field
+    # Prepare {MatchAllQuery} body
+    #
+    # @yieldparam [MatchAllQuery] query
+    #
+    # @return [MatchAllQuery]
+    def self.match_all(&block)
+      MatchAllQuery.new(&block)
+    end
 
-        # @return [Integer]
-        attr_accessor :size
+    # A query that matches all indexed documents.
+    class MatchAllQuery < SearchQuery
+      # @yieldparam [MatchAllQuery] self
+      def initialize
+        super()
+        yield self if block_given?
+      end
 
-        # @param [String] field name of the field
-        def initialize(field)
-          @field = field
-          yield self if block_given?
-        end
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        {:match_all => nil}
+      end
+    end
 
-        # @api private
-        def to_json(*args)
-          {field: field, size: size}.to_json(*args)
-        end
+    # Prepare {MatchNoneQuery} body
+    #
+    # @yieldparam [MatchNoneQuery] query
+    #
+    # @return [MatchNoneQuery]
+    def self.match_none(&block)
+      MatchNoneQuery.new(&block)
+    end
+
+    # A query that matches nothing.
+    class MatchNoneQuery < SearchQuery
+      # @yieldparam [MatchNoneQuery] self
+      def initialize
+        super()
+        yield self if block_given?
       end
 
-      class SearchFacetNumericRange
-        # @return [String]
-        attr_reader :field
+      # @return [Hash<Symbol, #to_json>]
+      def to_h
+        {:match_none => nil}
+      end
+    end
+  end
 
-        # @return [Integer]
-        attr_accessor :size
+  # @!macro uncommitted
+  class VectorSearch
+    # Constructs a +VectorSearch+ instance, which allows one or more individual vector queries to be executed.
+    #
+    # @param [VectorQuery, Array<VectorQuery>] vector_queries vector queries/query to execute
+    # @param [Options::VectorSearch] options
+    def initialize(vector_queries, options = Options::VectorSearch::DEFAULT)
+      @vector_queries = vector_queries.respond_to?(:each) ? vector_queries : [vector_queries]
+      @options = options
+    end
 
-        # @param [String] field name of the field
-        def initialize(field)
-          @field = field
-          @ranges = []
-          yield self if block_given?
-        end
+    # @api private
+    def to_backend
+      {vector_queries: @vector_queries.map(&:to_h).to_json}.merge(@options.to_backend)
+    end
+  end
 
-        # @param [String] name the name of the range
-        # @param [Integer, Float, nil] min lower bound of the range (pass +nil+ if there is no lower bound)
-        # @param [Integer, Float, nil] max upper bound of the range (pass +nil+ if there is no upper bound)
-        def add(name, min, max)
-          @ranges.append({name: name, min: min, max: max})
-        end
+  # @!macro uncommitted
+  class VectorQuery
+    # @return [Integer, nil]
+    attr_accessor :num_candidates
+
+    # @return [Float, nil]
+    attr_accessor :boost
+
+    # Constructs a +VectorQuery+ instance
+    #
+    # @param [String] vector_field_name the document field that contains the vector.
+    # @param [Array<Float>] vector_query the vector query to run.
+    #
+    # @yieldparam [MatchPhraseQuery] self
+    def initialize(vector_field_name, vector_query)
+      @vector_field_name = vector_field_name
+      @vector_query = vector_query
+
+      yield self if block_given?
+    end
 
-        # @api private
-        def to_json(*args)
-          {field: field, size: size, numeric_ranges: @ranges}.to_json(*args)
-        end
+    # @api private
+    def to_h
+      if !num_candidates.nil? && num_candidates < 1
+        raise Error::InvalidArgument,
+              "Number of candidates must be at least 1, #{num_candidates} given"
       end
 
-      class SearchFacetDateRange
-        # @return [String]
-        attr_reader :field
+      {
+        field: @vector_field_name,
+        vector: @vector_query,
+        k: num_candidates || 3,
+        boost: boost,
+      }.compact
+    end
 
-        # @return [Integer]
-        attr_accessor :size
+    # @api private
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+  end
 
-        # @param [String] field name of the field
-        def initialize(field)
-          @field = field
-          @ranges = []
-          yield self if block_given?
-        end
+  class SearchSort
+    # @yieldparam [SearchSortScore]
+    # @return [SearchSortScore]
+    def self.score(&block)
+      SearchSortScore.new(&block)
+    end
 
-        DATE_FORMAT_RFC3339 = "%Y-%m-%dT%H:%M:%S%:z"
+    # @yieldparam [SearchSortId]
+    # @return [SearchSortScore]
+    def self.id(&block)
+      SearchSortId.new(&block)
+    end
 
-        # @param [String] name the name of the range
-        # @param [Time, String, nil] start_time lower bound of the range (pass +nil+ if there is no lower bound)
-        # @param [Time, String, nil] end_time lower bound of the range (pass +nil+ if there is no lower bound)
-        def add(name, start_time, end_time)
-          start_time = start_time.strftime(DATE_FORMAT_RFC3339) if start_time && start_time.respond_to?(:strftime)
-          end_time = end_time.strftime(DATE_FORMAT_RFC3339) if end_time && end_time.respond_to?(:strftime)
-          @ranges.append({name: name, start: start_time, end: end_time})
-        end
+    # @param [String] name field name
+    # @yieldparam [SearchSortField]
+    # @return [SearchSortField]
+    def self.field(name, &block)
+      SearchSortField.new(name, &block)
+    end
 
-        # @api private
-        def to_json(*args)
-          {field: field, size: size, date_ranges: @ranges}.to_json(*args)
-        end
+    # @param [String] name field name
+    # @param [Float] longitude
+    # @param [Float] latitude
+    # @yieldparam [SearchSortField]
+    # @return [SearchSortGeoDistance]
+    def self.geo_distance(name, longitude, latitude, &block)
+      SearchSortGeoDistance.new(name, longitude, latitude, &block)
+    end
+
+    class SearchSortScore < SearchSort
+      # @return [Boolean] if descending order should be applied
+      attr_accessor :desc
+
+      # @yieldparam [SearchSortScore]
+      def initialize
+        super
+        yield self if block_given?
+      end
+
+      # @api private
+      def to_json(*args)
+        {by: :score, desc: desc}.to_json(*args)
       end
     end
 
-    class SearchOptions
-      # @return [Integer] Timeout in milliseconds
-      attr_accessor :timeout
+    class SearchSortId < SearchSort
+      # @return [Boolean] if descending order should be applied
+      attr_accessor :desc
 
-      # @return [Integer] limits the number of matches returned from the complete result set.
-      attr_accessor :limit
+      # @yieldparam [SearchSortId]
+      def initialize
+        super
+        yield self if block_given?
+      end
 
-      # @return [Integer] indicates how many matches are skipped on the result set before starting to return the matches
-      attr_accessor :skip
+      # @api private
+      def to_json(*args)
+        {by: :id, desc: desc}.to_json(*args)
+      end
+    end
 
-      # @return [Boolean] triggers inclusion of additional search result score explanations. (Default: +false+)
-      attr_accessor :explain
+    class SearchSortField < SearchSort
+      # @return [String] name of the field to sort by
+      attr_reader :field
 
-      # @return [:html, :ansi] the style of highlighting in the result excerpts (if not specified, the server default will be used)
-      attr_accessor :highlight_style
+      # @return [Boolean] if descending order should be applied
+      attr_accessor :desc
 
-      # @return [Array<String>] list of the fields to highlight
-      attr_accessor :highlight_fields
+      # @return [:auto, :string, :number, :date]
+      attr_accessor :type
 
-      # @return [Array<String>] list of field values which should be retrieved for result documents, provided they were stored while indexing
-      attr_accessor :fields
+      # @return [:first, :last] where the documents with missing field should be placed
+      attr_accessor :missing
 
-      # Customizes the consistency guarantees for this query
-      #
-      # @note overrides consistency level set by {#consistent_with}
-      #
-      # [+:not_bounded+] The engine will return whatever state it has at the time of query
-      #
-      # @param [:not_bounded] level the scan consistency to be used for this query
-      #
-      # @return [void]
-      def scan_consistency=(level)
-        @mutation_state = nil if @mutation_state
-        @scan_consistency = level
+      # @return [:default, :min, :max]
+      attr_accessor :mode
+
+      # @param [String] field the name of the filed for ordering
+      # @yieldparam [SearchSortField]
+      def initialize(field)
+        super()
+        @field = field
+        yield self if block_given?
       end
 
-      # Sets the mutation tokens this query should be consistent with
-      #
-      # @note overrides consistency level set by {#scan_consistency=}
-      #
-      # @param [MutationState] mutation_state the mutation state containing the mutation tokens
-      #
-      # @return [void]
-      def consistent_with(mutation_state)
-        @scan_consistency = nil if @scan_consistency
-        @mutation_state = mutation_state
+      # @api private
+      def to_json(*args)
+        {by: :field, field: field, desc: desc, type: type, missing: missing, mode: mode}.to_json(*args)
       end
+    end
 
-      # Ordering rules to apply to the results
-      #
-      # The list might contain either strings or special objects, that derive from {SearchSort}.
-      #
-      # In case of String, the value represents the name of the field with optional +-+ in front of the name, which will turn on descending mode for this field. One field is special is +"_score"+ which will sort results by their score.
-      #
-      # When nothing specified, the Server will order results by their score descending, which is equivalent of +"-_score"+.
-      #
-      # @return [Array<String, SearchSort>] list of ordering object
-      attr_accessor :sort
+    class SearchSortGeoDistance < SearchSort
+      # @return [String] name of the field to sort by
+      attr_reader :field
 
-      # Facets allow to aggregate information collected on a particular result set
-      #
-      # @return [Hash<String => SearchFacet>]
-      attr_accessor :facets
+      # @return [Boolean] if descending order should be applied
+      attr_accessor :desc
+
+      # @return [Float]
+      attr_reader :longitude
+
+      # @return [Float]
+      attr_reader :latitude
 
-      # @return [JsonTranscoder] transcoder to use for the results
-      attr_accessor :transcoder
+      # @return [:meters, :miles, :centimeters, :millimeters, :kilometers, :nauticalmiles, :feet, :yards, :inch]
+      attr_accessor :unit
 
-      # @yieldparam [SearchOptions] self
-      def initialize
-        @explain = false
-        @transcoder = JsonTranscoder.new
-        @scan_consistency = nil
-        @mutation_state = nil
+      # @param [String] field field name
+      # @param [Float] longitude
+      # @param [Float] latitude
+      # @yieldparam [SearchSortGeoDistance]
+      def initialize(field, longitude, latitude)
+        super()
+        @field = field
+        @longitude = longitude
+        @latitude = latitude
         yield self if block_given?
       end
+
+      # @api private
+      def to_json(*args)
+        {by: :geo_distance, field: field, desc: desc, location: [longitude, latitude], unit: unit}.to_json(*args)
+      end
     end
+  end
 
-    class SearchRowLocation
-      # @return [String]
-      attr_accessor :field
+  class SearchFacet
+    # @param [String] field_name
+    # @return [SearchFacetTerm]
+    def self.term(field_name, &block)
+      SearchFacetTerm.new(field_name, &block)
+    end
 
-      # @return [String]
-      attr_accessor :term
+    # @param [String] field_name
+    # @return [SearchFacetNumericRange]
+    def self.numeric_range(field_name, &block)
+      SearchFacetNumericRange.new(field_name, &block)
+    end
+
+    # @param [String] field_name
+    # @return [SearchFacetDateRange]
+    def self.date_range(field_name, &block)
+      SearchFacetDateRange.new(field_name, &block)
+    end
 
-      # @return [Integer] the position of the term within the field, starting at 1
-      attr_accessor :position
+    class SearchFacetTerm
+      # @return [String]
+      attr_reader :field
 
-      # @return [Integer] start byte offset of the term in the field
-      attr_accessor :start_offset
+      # @return [Integer]
+      attr_accessor :size
 
-      # @return [Integer] end byte offset of the term in the field
-      attr_accessor :end_offset
+      # @param [String] field name of the field
+      def initialize(field)
+        @field = field
+        yield self if block_given?
+      end
 
-      # @return [Array<Integer>] the positions of the term within any elements.
-      attr_accessor :array_positions
+      # @api private
+      def to_json(*args)
+        {field: field, size: size}.to_json(*args)
+      end
     end
 
-    class SearchRowLocations
-      # Lists all locations (any field, any term)
-      #
-      # @return [Array<SearchRowLocation>]
-      def get_all
-        @locations
-      end
+    class SearchFacetNumericRange
+      # @return [String]
+      attr_reader :field
 
-      # Lists all locations for a given field (any term)
-      #
-      # @return [Array<SearchRowLocation>]
-      def get_for_field(name)
-        @locations.select { |location| location.field == name }
+      # @return [Integer]
+      attr_accessor :size
+
+      # @param [String] field name of the field
+      def initialize(field)
+        @field = field
+        @ranges = []
+        yield self if block_given?
       end
 
-      # Lists all locations for a given field and term
-      #
-      # @return [Array<SearchRowLocation>]
-      def get_for_field_and_term(name, term)
-        @locations.select { |location| location.field == name && location.term == term }
+      # @param [String] name the name of the range
+      # @param [Integer, Float, nil] min lower bound of the range (pass +nil+ if there is no lower bound)
+      # @param [Integer, Float, nil] max upper bound of the range (pass +nil+ if there is no upper bound)
+      def add(name, min, max)
+        @ranges.append({name: name, min: min, max: max})
       end
 
-      # Lists the fields in this location
-      #
-      # @return [Array<String>]
-      def fields
-        @locations.map { |location| location.field }.uniq
+      # @api private
+      def to_json(*args)
+        {field: field, size: size, numeric_ranges: @ranges}.to_json(*args)
       end
+    end
 
-      # Lists all terms in this locations, considering all fields
-      #
-      # @return [Array<String>]
-      def terms
-        @locations.map { |location| location.term }.uniq
+    class SearchFacetDateRange
+      # @return [String]
+      attr_reader :field
+
+      # @return [Integer]
+      attr_accessor :size
+
+      # @param [String] field name of the field
+      def initialize(field)
+        super()
+        @field = field
+        @ranges = []
+        yield self if block_given?
       end
 
-      # Lists the terms for a given field
-      #
-      # @return [Array<String>]
-      def terms_for_field(name)
-        get_for_field(name).map { |location| location.term }.uniq
+      DATE_FORMAT_RFC3339 = "%Y-%m-%dT%H:%M:%S%:z".freeze
+
+      # @param [String] name the name of the range
+      # @param [Time, String, nil] start_time lower bound of the range (pass +nil+ if there is no lower bound)
+      # @param [Time, String, nil] end_time lower bound of the range (pass +nil+ if there is no lower bound)
+      def add(name, start_time, end_time)
+        start_time = start_time.strftime(DATE_FORMAT_RFC3339) if start_time.respond_to?(:strftime)
+        end_time = end_time.strftime(DATE_FORMAT_RFC3339) if end_time.respond_to?(:strftime)
+        @ranges.append({name: name, start: start_time, end: end_time})
       end
 
-      # @param [Array<SearchRowLocation>] locations
-      def initialize(locations)
-        @locations = locations
+      # @api private
+      def to_json(*args)
+        {field: field, size: size, date_ranges: @ranges}.to_json(*args)
       end
     end
+  end
 
-    # An individual facet result has both metadata and details, as each facet can define ranges into which results are
-    # categorized
-    class SearchFacetResult
-      # @return [String]
-      attr_accessor :name
+  class SearchRowLocation
+    # @return [String]
+    attr_accessor :field
 
-      # @return [String]
-      attr_accessor :field
+    # @return [String]
+    attr_accessor :term
 
-      # @return [Integer]
-      attr_accessor :total
+    # @return [Integer] the position of the term within the field, starting at 1
+    attr_accessor :position
 
-      # @return [Integer]
-      attr_accessor :missing
+    # @return [Integer] start byte offset of the term in the field
+    attr_accessor :start_offset
 
-      # @return [Integer]
-      attr_accessor :other
+    # @return [Integer] end byte offset of the term in the field
+    attr_accessor :end_offset
 
-      class TermFacetResult < SearchFacetResult
-        # @return [Array<TermFacet>]
-        attr_accessor :terms
+    # @return [Array<Integer>] the positions of the term within any elements.
+    attr_accessor :array_positions
 
-        def type
-          :term_facet
-        end
+    # @yieldparam [SearchRowLocation] self
+    def initialize
+      yield self if block_given?
+    end
+  end
 
-        # @yieldparam [TermFacetResult] self
-        def initialize
-          yield self if block_given?
-        end
+  class SearchRowLocations
+    # Lists all locations (any field, any term)
+    #
+    # @return [Array<SearchRowLocation>]
+    def get_all
+      @locations
+    end
 
-        class TermFacet
-          # @return [String]
-          attr_reader :term
+    # Lists all locations for a given field (any term)
+    #
+    # @return [Array<SearchRowLocation>]
+    def get_for_field(name)
+      @locations.select { |location| location.field == name }
+    end
 
-          # @return [Integer]
-          attr_reader :count
+    # Lists all locations for a given field and term
+    #
+    # @return [Array<SearchRowLocation>]
+    def get_for_field_and_term(name, term)
+      @locations.select { |location| location.field == name && location.term == term }
+    end
 
-          def initialize(term, count)
-            @term = term
-            @count = count
-          end
-        end
+    # Lists the fields in this location
+    #
+    # @return [Array<String>]
+    def fields
+      @locations.map(&:field).uniq
+    end
+
+    # Lists all terms in this locations, considering all fields
+    #
+    # @return [Array<String>]
+    def terms
+      @locations.map(&:term).uniq
+    end
+
+    # Lists the terms for a given field
+    #
+    # @return [Array<String>]
+    def terms_for_field(name)
+      get_for_field(name).map(&:term).uniq
+    end
+
+    # @param [Array<SearchRowLocation>] locations
+    def initialize(locations)
+      super()
+      @locations = locations
+    end
+  end
+
+  # An individual facet result has both metadata and details, as each facet can define ranges into which results are categorized
+  class SearchFacetResult
+    # @return [String]
+    attr_accessor :name
+
+    # @return [String]
+    attr_accessor :field
+
+    # @return [Integer]
+    attr_accessor :total
+
+    # @return [Integer]
+    attr_accessor :missing
+
+    # @return [Integer]
+    attr_accessor :other
+
+    class TermFacetResult < SearchFacetResult
+      # @return [Array<TermFacet>]
+      attr_accessor :terms
+
+      def type
+        :term_facet
+      end
+
+      # @yieldparam [TermFacetResult] self
+      def initialize
+        super
+        yield self if block_given?
       end
 
-      class DateRangeFacetResult < SearchFacetResult
-        # @return [Array<DateRangeFacet>]
-        attr_accessor :date_ranges
+      class TermFacet
+        # @return [String]
+        attr_reader :term
 
-        def type
-          :date_range_facet
-        end
+        # @return [Integer]
+        attr_reader :count
 
-        # @yieldparam [DateRangeFacetResult] self
-        def initialize
-          yield self if block_given?
+        def initialize(term, count)
+          super()
+          @term = term
+          @count = count
         end
+      end
+    end
+
+    class DateRangeFacetResult < SearchFacetResult
+      # @return [Array<DateRangeFacet>]
+      attr_accessor :date_ranges
+
+      def type
+        :date_range_facet
+      end
+
+      # @yieldparam [DateRangeFacetResult] self
+      def initialize
+        super
+        yield self if block_given?
+      end
 
-        class DateRangeFacet
-          # @return [String]
-          attr_reader :name
+      class DateRangeFacet
+        # @return [String]
+        attr_reader :name
 
-          # @return [Integer]
-          attr_reader :count
+        # @return [Integer]
+        attr_reader :count
 
-          # @return [String]
-          attr_reader :start_time
+        # @return [String]
+        attr_reader :start_time
 
-          # @return [String]
-          attr_reader :end_time
+        # @return [String]
+        attr_reader :end_time
 
-          def initialize(name, count, start_time, end_time)
-            @name = name
-            @count = count
-            @start_time = start_time
-            @end_time = end_time
-          end
+        def initialize(name, count, start_time, end_time)
+          @name = name
+          @count = count
+          @start_time = start_time
+          @end_time = end_time
         end
       end
+    end
 
-      class NumericRangeFacetResult < SearchFacetResult
-        # @return [Array<NumericRangeFacet>]
-        attr_accessor :numeric_ranges
+    class NumericRangeFacetResult < SearchFacetResult
+      # @return [Array<NumericRangeFacet>]
+      attr_accessor :numeric_ranges
 
-        def type
-          :numeric_range_facet
-        end
+      def type
+        :numeric_range_facet
+      end
 
-        # @yieldparam [NumericRangeFacetResult] self
-        def initialize
-          yield self if block_given?
-        end
+      # @yieldparam [NumericRangeFacetResult] self
+      def initialize
+        super
+        yield self if block_given?
+      end
 
-        class NumericRangeFacet
-          # @return [String]
-          attr_reader :name
+      class NumericRangeFacet
+        # @return [String]
+        attr_reader :name
 
-          # @return [Integer]
-          attr_reader :count
+        # @return [Integer]
+        attr_reader :count
 
-          # @return [Integer, Float, nil]
-          attr_reader :min
+        # @return [Integer, Float, nil]
+        attr_reader :min
 
-          # @return [Integer, Float, nil]
-          attr_reader :max
+        # @return [Integer, Float, nil]
+        attr_reader :max
 
-          def initialize(name, count, min, max)
-            @name = name
-            @count = count
-            @min = min
-            @max = max
-          end
+        def initialize(name, count, min, max)
+          @name = name
+          @count = count
+          @min = min
+          @max = max
         end
       end
     end
+  end
 
-    class SearchRow
-      # @return [String] name of the index
-      attr_accessor :index
+  class SearchRow
+    # @return [String] name of the index
+    attr_accessor :index
 
-      # @return [String] document identifier
-      attr_accessor :id
+    # @return [String] document identifier
+    attr_accessor :id
 
-      # @return [Float]
-      attr_accessor :score
+    # @return [Float]
+    attr_accessor :score
 
-      # @return [SearchRowLocations]
-      attr_accessor :locations
+    # @return [SearchRowLocations]
+    attr_accessor :locations
 
-      # @return [Hash]
-      attr_accessor :explanation
+    # @return [Hash]
+    attr_accessor :explanation
 
-      # @return [Hash<String => Array<String>>]
-      attr_accessor :fragments
+    # @return [Hash<String => Array<String>>]
+    attr_accessor :fragments
 
-      # @return [JsonTranscoder] transcoder to use for the fields
-      attr_accessor :transcoder
+    # @return [JsonTranscoder] transcoder to use for the fields
+    attr_accessor :transcoder
 
-      def fields
-        @transcoder.decode(@fields, :json) if @fields && @transcoder
-      end
+    def fields
+      @transcoder.decode(@fields, :json) if @fields && @transcoder
+    end
 
-      # @yieldparam [SearchRow] self
-      def initialize
-        @fields = nil
-        yield self if block_given?
-      end
+    # @yieldparam [SearchRow] self
+    def initialize
+      @fields = nil
+      yield self if block_given?
     end
+  end
 
-    class SearchMetrics
-      # @return [Integer] time spent executing the query (in milliseconds)
-      attr_accessor :took
+  class SearchMetrics
+    # @return [Integer] time spent executing the query (in milliseconds)
+    attr_accessor :took
 
-      # @return [Integer]
-      attr_accessor :total_rows
+    # @return [Integer]
+    attr_accessor :total_rows
 
-      # @return [Float]
-      attr_accessor :max_score
+    # @return [Float]
+    attr_accessor :max_score
 
-      # @return [Integer]
-      attr_accessor :success_partition_count
+    # @return [Integer]
+    attr_accessor :success_partition_count
 
-      # @return [Integer]
-      attr_accessor :error_partition_count
+    # @return [Integer]
+    attr_accessor :error_partition_count
 
-      # @return [Integer]
-      def total_partition_count
-        success_partition_count + error_partition_count
-      end
+    # @return [Integer]
+    def total_partition_count
+      success_partition_count + error_partition_count
     end
+  end
 
-    class SearchMetaData
-      # @return [SearchMetrics]
-      attr_accessor :metrics
+  class SearchMetaData
+    # @return [SearchMetrics]
+    attr_accessor :metrics
 
-      # @return [Hash<String => String>]
-      attr_accessor :errors
+    # @return [Hash<String => String>]
+    attr_accessor :errors
 
-      # @yieldparam [SearchMetaData] self
-      def initialize
-        @metrics = SearchMetrics.new
-        yield self if block_given?
-      end
+    # @yieldparam [SearchMetaData] self
+    def initialize
+      @metrics = SearchMetrics.new
+      yield self if block_given?
     end
+  end
 
-    class SearchResult
-      # @return [Array<SearchRow>]
-      attr_accessor :rows
+  class SearchResult
+    # @return [Array<SearchRow>]
+    attr_accessor :rows
 
-      # @return [Hash<String => SearchFacetResult>]
-      attr_accessor :facets
+    # @return [Hash<String => SearchFacetResult>]
+    attr_accessor :facets
 
-      # @return [SearchMetaData]
-      attr_accessor :meta_data
+    # @return [SearchMetaData]
+    attr_accessor :meta_data
 
-      # @yieldparam [SearchResult] self
-      def initialize
-        yield self if block_given?
-      end
+    def success?
+      meta_data.errors.nil? || meta_data.errors.empty?
+    end
+
+    # @yieldparam [SearchResult] self
+    def initialize
+      yield self if block_given?
     end
   end
+
+  class Cluster
+    SearchQuery = Couchbase::SearchQuery
+    SearchSort = Couchbase::SearchSort
+    SearchFacet = Couchbase::SearchFacet
+    SearchRowLocation = Couchbase::SearchRowLocation
+    SearchRowLocations = Couchbase::SearchRowLocations
+    SearchFacetResult = Couchbase::SearchFacetResult
+    SearchRow = Couchbase::SearchRow
+    SearchResult = Couchbase::SearchResult
+    SearchMetaData = Couchbase::SearchMetaData
+    SearchMetrics = Couchbase::SearchMetrics
+  end
 end