algolia 3.0.0.alpha.16 → 3.0.0.alpha.17

data/lib/algolia/models/recommend/automatic_facet_filter.rb

@@ -1,220 +0,0 @@
-# Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on https://github.com/algolia/api-clients-automation. DO NOT EDIT.
-
-require 'date'
-require 'time'
-
-module Algolia
-  module Recommend
-    # Filter or optional filter to be applied to the search.
-    class AutomaticFacetFilter
-      # Facet name to be applied as filter. The name must match placeholders in the `pattern` parameter. For example, with `pattern: {facet:genre}`, `automaticFacetFilters` must be `genre`.
-      attr_accessor :facet
-
-      # Filter scores to give different weights to individual filters.
-      attr_accessor :score
-
-      # Whether the filter is disjunctive or conjunctive.  If true the filter has multiple matches, multiple occurences are combined with the logical `OR` operation. If false, multiple occurences are combined with the logical `AND` operation.
-      attr_accessor :disjunctive
-
-      # Attribute mapping from ruby-style variable name to JSON key.
-      def self.attribute_map
-        {
-          :facet => :facet,
-          :score => :score,
-          :disjunctive => :disjunctive
-        }
-      end
-
-      # Returns all the JSON keys this model knows about
-      def self.acceptable_attributes
-        attribute_map.values
-      end
-
-      # Attribute type mapping.
-      def self.types_mapping
-        {
-          :facet => :String,
-          :score => :Integer,
-          :disjunctive => :Boolean
-        }
-      end
-
-      # List of attributes with nullable: true
-      def self.openapi_nullable
-        Set.new([])
-      end
-
-      # Initializes the object
-      # @param [Hash] attributes Model attributes in the form of hash
-      def initialize(attributes = {})
-        unless attributes.is_a?(Hash)
-          raise ArgumentError, "The input argument (attributes) must be a hash in `Algolia::AutomaticFacetFilter` initialize method"
-        end
-
-        # check to see if the attribute exists and convert string to symbol for hash key
-        attributes = attributes.each_with_object({}) do |(k, v), h|
-          unless self.class.attribute_map.key?(k.to_sym)
-            raise ArgumentError,
-                  "`#{k}` is not a valid attribute in `Algolia::AutomaticFacetFilter`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
-          end
-
-          h[k.to_sym] = v
-        end
-
-        if attributes.key?(:facet)
-          self.facet = attributes[:facet]
-        else
-          self.facet = nil
-        end
-
-        if attributes.key?(:score)
-          self.score = attributes[:score]
-        end
-
-        if attributes.key?(:disjunctive)
-          self.disjunctive = attributes[:disjunctive]
-        end
-      end
-
-      # Checks equality by comparing each attribute.
-      # @param [Object] Object to be compared
-      def ==(other)
-        return true if equal?(other)
-
-        self.class == other.class &&
-          facet == other.facet &&
-          score == other.score &&
-          disjunctive == other.disjunctive
-      end
-
-      # @see the `==` method
-      # @param [Object] Object to be compared
-      def eql?(other)
-        self == other
-      end
-
-      # Calculates hash code according to all attributes.
-      # @return [Integer] Hash code
-      def hash
-        [facet, score, disjunctive].hash
-      end
-
-      # Builds the object from hash
-      # @param [Hash] attributes Model attributes in the form of hash
-      # @return [Object] Returns the model itself
-      def self.build_from_hash(attributes)
-        return nil unless attributes.is_a?(Hash)
-
-        attributes = attributes.transform_keys(&:to_sym)
-        transformed_hash = {}
-        types_mapping.each_pair do |key, type|
-          if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_sym] = nil
-          elsif type =~ /\AArray<(.*)>/i
-            # check to ensure the input is an array given that the attribute
-            # is documented as an array but the input is not
-            if attributes[attribute_map[key]].is_a?(Array)
-              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
-            end
-          elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
-          end
-        end
-        new(transformed_hash)
-      end
-
-      # Deserializes the data based on type
-      # @param string type Data type
-      # @param string value Value to be deserialized
-      # @return [Object] Deserialized data
-      def self._deserialize(type, value)
-        case type.to_sym
-        when :Time
-          Time.parse(value)
-        when :Date
-          Date.parse(value)
-        when :String
-          value.to_s
-        when :Integer
-          value.to_i
-        when :Float
-          value.to_f
-        when :Boolean
-          if value.to_s =~ /\A(true|t|yes|y|1)\z/i
-            true
-          else
-            false
-          end
-        when :Object
-          # generic object (usually a Hash), return directly
-          value
-        when /\AArray<(?<inner_type>.+)>\z/
-          inner_type = Regexp.last_match[:inner_type]
-          value.map { |v| _deserialize(inner_type, v) }
-        when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
-          k_type = Regexp.last_match[:k_type]
-          v_type = Regexp.last_match[:v_type]
-          {}.tap do |hash|
-            value.each do |k, v|
-              hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-            end
-          end
-        else # model
-          # models (e.g. Pet) or oneOf
-          klass = Algolia::Recommend.const_get(type)
-          klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
-        end
-      end
-
-      # Returns the string representation of the object
-      # @return [String] String presentation of the object
-      def to_s
-        to_hash.to_s
-      end
-
-      # to_body is an alias to to_hash (backward compatibility)
-      # @return [Hash] Returns the object in the form of hash
-      def to_body
-        to_hash
-      end
-
-      def to_json(*_args)
-        to_hash.to_json
-      end
-
-      # Returns the object in the form of hash
-      # @return [Hash] Returns the object in the form of hash
-      def to_hash
-        hash = {}
-        self.class.attribute_map.each_pair do |attr, param|
-          value = send(attr)
-          if value.nil?
-            is_nullable = self.class.openapi_nullable.include?(attr)
-            next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
-          end
-
-          hash[param] = _to_hash(value)
-        end
-        hash
-      end
-
-      # Outputs non-array value in the form of hash
-      # For object, use to_hash. Otherwise, just return the value
-      # @param [Object] value Any valid value
-      # @return [Hash] Returns the value in the form of hash
-      def _to_hash(value)
-        if value.is_a?(Array)
-          value.compact.map { |v| _to_hash(v) }
-        elsif value.is_a?(Hash)
-          {}.tap do |hash|
-            value.each { |k, v| hash[k] = _to_hash(v) }
-          end
-        elsif value.respond_to? :to_hash
-          value.to_hash
-        else
-          value
-        end
-      end
-    end
-  end
-end

data/lib/algolia/models/recommend/automatic_facet_filters.rb

@@ -1,97 +0,0 @@
-# Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on https://github.com/algolia/api-clients-automation. DO NOT EDIT.
-
-require 'date'
-require 'time'
-
-module Algolia
-  module Recommend
-    # Filter to be applied to the search.  You can use this to respond to search queries that match a facet value. For example, if users search for \"comedy\", which matches a facet value of the \"genre\" facet, you can filter the results to show the top-ranked comedy movies.
-    module AutomaticFacetFilters
-      class << self
-        # List of class defined in oneOf (OpenAPI v3)
-        def openapi_one_of
-          [
-            :'Array<AutomaticFacetFilter>',
-            :'Array<String>'
-          ]
-        end
-
-        # Builds the object
-        # @param [Mixed] Data to be matched against the list of oneOf items
-        # @return [Object] Returns the model or the data itself
-        def build(data)
-          # Go through the list of oneOf items and attempt to identify the appropriate one.
-          # Note:
-          # - We do not attempt to check whether exactly one item matches.
-          # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 })
-          #   due to the way the deserialization is made in the base_object template (it just casts without verifying).
-          # - TODO: scalar values are de facto behaving as if they were nullable.
-          # - TODO: logging when debugging is set.
-          openapi_one_of.each do |klass|
-            next if klass == :AnyType # "nullable: true"
-
-            typed_data = find_and_cast_into_type(klass, data)
-            return typed_data if typed_data
-          rescue # rescue all errors so we keep iterating even if the current item lookup raises
-          end
-
-          openapi_one_of.include?(:AnyType) ? data : nil
-        end
-
-        private
-
-        SchemaMismatchError = Class.new(StandardError)
-
-        # NOTE: 'File' is missing here because in the regular case we get the data _after_ a call to JSON.parse.
-        def find_and_cast_into_type(klass, data)
-          return if data.nil?
-
-          case klass.to_s
-          when 'Boolean'
-            return data if data.instance_of?(TrueClass) || data.instance_of?(FalseClass)
-          when 'Float'
-            return data if data.instance_of?(Float)
-          when 'Integer'
-            return data if data.instance_of?(Integer)
-          when 'Time'
-            return Time.parse(data)
-          when 'Date'
-            return Date.parse(data)
-          when 'String'
-            return data if data.instance_of?(String)
-          when 'Object' # "type: object"
-            return data if data.instance_of?(Hash)
-          when /\AArray<(?<sub_type>.+)>\z/ # "type: array"
-            if data.instance_of?(Array)
-              sub_type = Regexp.last_match[:sub_type]
-              return data.map { |item| find_and_cast_into_type(sub_type, item) }
-            end
-          when /\AHash<String, (?<sub_type>.+)>\z/ # "type: object" with "additionalProperties: { ... }"
-            if data.instance_of?(Hash) && data.keys.all? { |k| k.instance_of?(Symbol) || k.instance_of?(String) }
-              sub_type = Regexp.last_match[:sub_type]
-              return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
-            end
-          else # model
-            const = Algolia::Recommend.const_get(klass)
-            if const
-              if const.respond_to?(:openapi_one_of) # nested oneOf model
-                model = const.build(data)
-              else
-                # raise if data contains keys that are not known to the model
-                raise unless (data.keys - const.acceptable_attributes).empty?
-
-                model = const.build_from_hash(data)
-              end
-
-              return model if model
-            end
-          end
-
-          raise # if no match by now, raise
-        rescue
-          raise SchemaMismatchError, "#{data} doesn't match the #{klass} type"
-        end
-      end
-    end
-  end
-end

data/lib/algolia/models/recommend/consequence_query.rb

@@ -1,97 +0,0 @@
-# Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on https://github.com/algolia/api-clients-automation. DO NOT EDIT.
-
-require 'date'
-require 'time'
-
-module Algolia
-  module Recommend
-    # Replace or edit the search query.  If `consequenceQuery` is a string, the entire search query is replaced with that string. If `consequenceQuery` is an object, it describes incremental edits made to the query.
-    module ConsequenceQuery
-      class << self
-        # List of class defined in oneOf (OpenAPI v3)
-        def openapi_one_of
-          [
-            :ConsequenceQueryObject,
-            :String
-          ]
-        end
-
-        # Builds the object
-        # @param [Mixed] Data to be matched against the list of oneOf items
-        # @return [Object] Returns the model or the data itself
-        def build(data)
-          # Go through the list of oneOf items and attempt to identify the appropriate one.
-          # Note:
-          # - We do not attempt to check whether exactly one item matches.
-          # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 })
-          #   due to the way the deserialization is made in the base_object template (it just casts without verifying).
-          # - TODO: scalar values are de facto behaving as if they were nullable.
-          # - TODO: logging when debugging is set.
-          openapi_one_of.each do |klass|
-            next if klass == :AnyType # "nullable: true"
-
-            typed_data = find_and_cast_into_type(klass, data)
-            return typed_data if typed_data
-          rescue # rescue all errors so we keep iterating even if the current item lookup raises
-          end
-
-          openapi_one_of.include?(:AnyType) ? data : nil
-        end
-
-        private
-
-        SchemaMismatchError = Class.new(StandardError)
-
-        # NOTE: 'File' is missing here because in the regular case we get the data _after_ a call to JSON.parse.
-        def find_and_cast_into_type(klass, data)
-          return if data.nil?
-
-          case klass.to_s
-          when 'Boolean'
-            return data if data.instance_of?(TrueClass) || data.instance_of?(FalseClass)
-          when 'Float'
-            return data if data.instance_of?(Float)
-          when 'Integer'
-            return data if data.instance_of?(Integer)
-          when 'Time'
-            return Time.parse(data)
-          when 'Date'
-            return Date.parse(data)
-          when 'String'
-            return data if data.instance_of?(String)
-          when 'Object' # "type: object"
-            return data if data.instance_of?(Hash)
-          when /\AArray<(?<sub_type>.+)>\z/ # "type: array"
-            if data.instance_of?(Array)
-              sub_type = Regexp.last_match[:sub_type]
-              return data.map { |item| find_and_cast_into_type(sub_type, item) }
-            end
-          when /\AHash<String, (?<sub_type>.+)>\z/ # "type: object" with "additionalProperties: { ... }"
-            if data.instance_of?(Hash) && data.keys.all? { |k| k.instance_of?(Symbol) || k.instance_of?(String) }
-              sub_type = Regexp.last_match[:sub_type]
-              return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
-            end
-          else # model
-            const = Algolia::Recommend.const_get(klass)
-            if const
-              if const.respond_to?(:openapi_one_of) # nested oneOf model
-                model = const.build(data)
-              else
-                # raise if data contains keys that are not known to the model
-                raise unless (data.keys - const.acceptable_attributes).empty?
-
-                model = const.build_from_hash(data)
-              end
-
-              return model if model
-            end
-          end
-
-          raise # if no match by now, raise
-        rescue
-          raise SchemaMismatchError, "#{data} doesn't match the #{klass} type"
-        end
-      end
-    end
-  end
-end

data/lib/algolia/models/recommend/promote_object_ids.rb

@@ -1,228 +0,0 @@
-# Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on https://github.com/algolia/api-clients-automation. DO NOT EDIT.
-
-require 'date'
-require 'time'
-
-module Algolia
-  module Recommend
-    # Records to promote.
-    class PromoteObjectIDs
-      # Object IDs of the records you want to promote.  The records are placed as a group at the `position`. For example, if you want to promote four records to position `0`, they will be the first four search results.
-      attr_accessor :object_ids
-
-      # Position in the search results where you want to show the promoted records.
-      attr_accessor :position
-
-      # Attribute mapping from ruby-style variable name to JSON key.
-      def self.attribute_map
-        {
-          :object_ids => :objectIDs,
-          :position => :position
-        }
-      end
-
-      # Returns all the JSON keys this model knows about
-      def self.acceptable_attributes
-        attribute_map.values
-      end
-
-      # Attribute type mapping.
-      def self.types_mapping
-        {
-          :object_ids => :'Array<String>',
-          :position => :Integer
-        }
-      end
-
-      # List of attributes with nullable: true
-      def self.openapi_nullable
-        Set.new([])
-      end
-
-      # Initializes the object
-      # @param [Hash] attributes Model attributes in the form of hash
-      def initialize(attributes = {})
-        unless attributes.is_a?(Hash)
-          raise ArgumentError, "The input argument (attributes) must be a hash in `Algolia::PromoteObjectIDs` initialize method"
-        end
-
-        # check to see if the attribute exists and convert string to symbol for hash key
-        attributes = attributes.each_with_object({}) do |(k, v), h|
-          unless self.class.attribute_map.key?(k.to_sym)
-            raise ArgumentError,
-                  "`#{k}` is not a valid attribute in `Algolia::PromoteObjectIDs`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
-          end
-
-          h[k.to_sym] = v
-        end
-
-        if attributes.key?(:object_ids)
-          if (value = attributes[:object_ids]).is_a?(Array)
-            self.object_ids = value
-          end
-        else
-          self.object_ids = nil
-        end
-
-        if attributes.key?(:position)
-          self.position = attributes[:position]
-        else
-          self.position = nil
-        end
-      end
-
-      # Custom attribute writer method with validation
-      # @param [Object] object_ids Value to be assigned
-      def object_ids=(object_ids)
-        if object_ids.nil?
-          raise ArgumentError, 'object_ids cannot be nil'
-        end
-
-        if object_ids.length > 100
-          raise ArgumentError, 'invalid value for "object_ids", number of items must be less than or equal to 100.'
-        end
-
-        @object_ids = object_ids
-      end
-
-      # Checks equality by comparing each attribute.
-      # @param [Object] Object to be compared
-      def ==(other)
-        return true if equal?(other)
-
-        self.class == other.class &&
-          object_ids == other.object_ids &&
-          position == other.position
-      end
-
-      # @see the `==` method
-      # @param [Object] Object to be compared
-      def eql?(other)
-        self == other
-      end
-
-      # Calculates hash code according to all attributes.
-      # @return [Integer] Hash code
-      def hash
-        [object_ids, position].hash
-      end
-
-      # Builds the object from hash
-      # @param [Hash] attributes Model attributes in the form of hash
-      # @return [Object] Returns the model itself
-      def self.build_from_hash(attributes)
-        return nil unless attributes.is_a?(Hash)
-
-        attributes = attributes.transform_keys(&:to_sym)
-        transformed_hash = {}
-        types_mapping.each_pair do |key, type|
-          if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_sym] = nil
-          elsif type =~ /\AArray<(.*)>/i
-            # check to ensure the input is an array given that the attribute
-            # is documented as an array but the input is not
-            if attributes[attribute_map[key]].is_a?(Array)
-              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
-            end
-          elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
-          end
-        end
-        new(transformed_hash)
-      end
-
-      # Deserializes the data based on type
-      # @param string type Data type
-      # @param string value Value to be deserialized
-      # @return [Object] Deserialized data
-      def self._deserialize(type, value)
-        case type.to_sym
-        when :Time
-          Time.parse(value)
-        when :Date
-          Date.parse(value)
-        when :String
-          value.to_s
-        when :Integer
-          value.to_i
-        when :Float
-          value.to_f
-        when :Boolean
-          if value.to_s =~ /\A(true|t|yes|y|1)\z/i
-            true
-          else
-            false
-          end
-        when :Object
-          # generic object (usually a Hash), return directly
-          value
-        when /\AArray<(?<inner_type>.+)>\z/
-          inner_type = Regexp.last_match[:inner_type]
-          value.map { |v| _deserialize(inner_type, v) }
-        when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
-          k_type = Regexp.last_match[:k_type]
-          v_type = Regexp.last_match[:v_type]
-          {}.tap do |hash|
-            value.each do |k, v|
-              hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-            end
-          end
-        else # model
-          # models (e.g. Pet) or oneOf
-          klass = Algolia::Recommend.const_get(type)
-          klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
-        end
-      end
-
-      # Returns the string representation of the object
-      # @return [String] String presentation of the object
-      def to_s
-        to_hash.to_s
-      end
-
-      # to_body is an alias to to_hash (backward compatibility)
-      # @return [Hash] Returns the object in the form of hash
-      def to_body
-        to_hash
-      end
-
-      def to_json(*_args)
-        to_hash.to_json
-      end
-
-      # Returns the object in the form of hash
-      # @return [Hash] Returns the object in the form of hash
-      def to_hash
-        hash = {}
-        self.class.attribute_map.each_pair do |attr, param|
-          value = send(attr)
-          if value.nil?
-            is_nullable = self.class.openapi_nullable.include?(attr)
-            next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
-          end
-
-          hash[param] = _to_hash(value)
-        end
-        hash
-      end
-
-      # Outputs non-array value in the form of hash
-      # For object, use to_hash. Otherwise, just return the value
-      # @param [Object] value Any valid value
-      # @return [Hash] Returns the value in the form of hash
-      def _to_hash(value)
-        if value.is_a?(Array)
-          value.compact.map { |v| _to_hash(v) }
-        elsif value.is_a?(Hash)
-          {}.tap do |hash|
-            value.each { |k, v| hash[k] = _to_hash(v) }
-          end
-        elsif value.respond_to? :to_hash
-          value.to_hash
-        else
-          value
-        end
-      end
-    end
-  end
-end