algolia 3.39.1 → 3.40.0

data/lib/algolia/configuration.rb

@@ -12,7 +12,8 @@ module Algolia
       :write_timeout,
       :connect_timeout,
       :compression_type,
-      :requester
+      :requester,
+      :transformation_options
     )
 
     # Set this to false to skip client side validation in the operation.
@@ -30,6 +31,7 @@ module Algolia
       @write_timeout = opts[:write_timeout]
       @compression_type = opts[:compression_type] || "none"
       @requester = opts[:requester]
+      @transformation_options = opts[:transformation_options]
 
       @user_agent = UserAgent.new.add(client_name, VERSION)
 

data/lib/algolia/models/abtesting/ab_test.rb

@@ -11,14 +11,19 @@ module Algolia
       # Unique A/B test identifier.
       attr_accessor :ab_test_id
 
+      # A/B test significance calculated from click events.  Values of 0.95 or higher can be considered significant, that is, the difference between A and B variants is _not_ due to random variations. Lower values have a.
       attr_accessor :click_significance
 
+      # A/B test significance calculated from conversion events.  Values of 0.95 or higher can be considered significant, that is, the difference between A and B variants is _not_ due to random variations.
       attr_accessor :conversion_significance
 
+      # A/B test significance calculated from add-to-cart events.  Values of 0.95 or higher can be considered significant, that is, the difference between A and B variants is _not_ due to random variations.
       attr_accessor :add_to_cart_significance
 
+      # A/B test significance calculated from purchase events.  Values of 0.95 or higher can be considered significant, that is, the difference between A and B variants is _not_ due to random variations.
       attr_accessor :purchase_significance
 
+      # A/B test significance calculated from revenue data.  Values of 0.95 or higher can be considered significant, that is, the difference between A and B variants is _not_ due to random variations.
       attr_accessor :revenue_significance
 
       # Date and time when the A/B test was last updated, in RFC 3339 format.

data/lib/algolia/models/query-suggestions/configuration.rb

@@ -14,6 +14,7 @@ module Algolia
 
       attr_accessor :languages
 
+      # Words or regular expressions to exclude from the suggestions.
       attr_accessor :exclude
 
       # Whether to turn on personalized query suggestions.

data/lib/algolia/models/query-suggestions/configuration_response.rb

@@ -20,6 +20,7 @@ module Algolia
 
       attr_accessor :languages
 
+      # Words or regular expressions to exclude from the suggestions.
       attr_accessor :exclude
 
       # Whether to turn on personalized query suggestions.

data/lib/algolia/models/query-suggestions/configuration_with_index.rb

@@ -14,6 +14,7 @@ module Algolia
 
       attr_accessor :languages
 
+      # Words or regular expressions to exclude from the suggestions.
       attr_accessor :exclude
 
       # Whether to turn on personalized query suggestions.

data/lib/algolia/models/query-suggestions/source_index.rb

@@ -15,8 +15,10 @@ module Algolia
       # If true, Query Suggestions uses all replica indices to find popular searches. If false, only the primary index is used.
       attr_accessor :replicas
 
+      # Analytics tags for filtering the popular searches. For more information, see [Segment your analytics data](https://www.algolia.com/doc/guides/search-analytics/guides/segments).
       attr_accessor :analytics_tags
 
+      # Facets to use as top categories with your suggestions.  If provided, Query Suggestions adds the top facet values to each suggestion.
       attr_accessor :facets
 
       # Minimum number of hits required to be included as a suggestion.  A search query must at least generate `minHits` search results to be included in the Query Suggestions index.
@@ -25,8 +27,10 @@ module Algolia
       # Minimum letters required to be included as a suggestion.  A search query must be at least `minLetters` long to be included in the Query Suggestions index.
       attr_accessor :min_letters
 
+      # Facets used for generating query suggestions from facet values.  For example, if you set `generate: [\"color\", \"brand\"]`, combinations from the facet values are added as query suggestions, such as \"blue adidas\", \"red adidas\", \"blue nike\", \"red nike\", etc.  You can include nested lists.
       attr_accessor :generate
 
+      # Algolia indices with popular searches to use as query suggestions.  Records of these indices must have these attributes:  - `query`: search query which will be added as a suggestion - `count`: measure of popularity of that search query  For example, you can export popular searches from an external analytics provider, such as Google Analytics or Adobe Analytics, and feed this data into an Algolia index. You can use this index to generate query suggestions until your Algolia Analytics has collected enough data.
       attr_accessor :external
 
       # Attribute mapping from ruby-style variable name to JSON key.

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

@@ -444,7 +444,8 @@ module Algolia
           [
             :inside_bounding_box,
             :user_data,
-            :optional_words
+            :optional_words,
+            :re_ranking_apply_filter
           ]
         )
       end

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

@@ -445,7 +445,8 @@ module Algolia
           [
             :inside_bounding_box,
             :user_data,
-            :optional_words
+            :optional_words,
+            :re_ranking_apply_filter
           ]
         )
       end

data/lib/algolia/models/search/browse_params_object.rb

@@ -376,7 +376,8 @@ module Algolia
         Set.new(
           [
             :inside_bounding_box,
-            :optional_words
+            :optional_words,
+            :re_ranking_apply_filter
           ]
         )
       end

data/lib/algolia/models/search/consequence_params.rb

@@ -378,7 +378,8 @@ module Algolia
         Set.new(
           [
             :inside_bounding_box,
-            :optional_words
+            :optional_words,
+            :re_ranking_apply_filter
           ]
         )
       end

data/lib/algolia/models/search/fetched_index.rb

@@ -44,6 +44,11 @@ module Algolia
       # Only present if the index is a [virtual replica](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/how-to/sort-an-index-alphabetically/#virtual-replicas).
       attr_accessor :virtual
 
+      attr_accessor :ab_test
+
+      # Name of the index that owns the A/B test configuration. Only present when this index participates in an A/B test configured on another index.
+      attr_accessor :source_ab_test
+
       # Attribute mapping from ruby-style variable name to JSON key.
       def self.attribute_map
         {
@@ -58,7 +63,9 @@ module Algolia
           :pending_task => :pendingTask,
           :primary => :primary,
           :replicas => :replicas,
-          :virtual => :virtual
+          :virtual => :virtual,
+          :ab_test => :abTest,
+          :source_ab_test => :sourceABTest
         }
       end
 
@@ -76,7 +83,9 @@ module Algolia
           :pending_task => :"Boolean",
           :primary => :"String",
           :replicas => :"Array<String>",
-          :virtual => :"Boolean"
+          :virtual => :"Boolean",
+          :ab_test => :"FetchedIndexAbTest",
+          :source_ab_test => :"String"
         }
       end
 
@@ -177,6 +186,14 @@ module Algolia
         if attributes.key?(:virtual)
           self.virtual = attributes[:virtual]
         end
+
+        if attributes.key?(:ab_test)
+          self.ab_test = attributes[:ab_test]
+        end
+
+        if attributes.key?(:source_ab_test)
+          self.source_ab_test = attributes[:source_ab_test]
+        end
       end
 
       # Checks equality by comparing each attribute.
@@ -195,7 +212,9 @@ module Algolia
           pending_task == other.pending_task &&
           primary == other.primary &&
           replicas == other.replicas &&
-          virtual == other.virtual
+          virtual == other.virtual &&
+          ab_test == other.ab_test &&
+          source_ab_test == other.source_ab_test
       end
 
       # @see the `==` method
@@ -219,7 +238,9 @@ module Algolia
           pending_task,
           primary,
           replicas,
-          virtual
+          virtual,
+          ab_test,
+          source_ab_test
         ].hash
       end
 

data/lib/algolia/models/search/fetched_index_ab_test.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+# 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 Search
+    # A/B test metadata. Only present if the index is part of an active A/B test.
+    class FetchedIndexAbTest
+      # A/B test ID.
+      attr_accessor :id
+
+      # A/B test schema version. Only present for v2 and later tests.
+      attr_accessor :version
+
+      # A/B test type. Only present for v2 and later tests. Currently always `index-configuration`.
+      attr_accessor :type
+
+      attr_accessor :target
+
+      # A/B test variants.
+      attr_accessor :variants
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :id => :id,
+          :version => :version,
+          :type => :type,
+          :target => :target,
+          :variants => :variants
+        }
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :id => :"Integer",
+          :version => :"Integer",
+          :type => :"String",
+          :target => :"FetchedIndexAbTestTarget",
+          :variants => :"Array<FetchedIndexAbTestVariant>"
+        }
+      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 = {})
+        if (!attributes.is_a?(Hash))
+          raise(
+            ArgumentError,
+            "The input argument (attributes) must be a hash in `Algolia::FetchedIndexAbTest` initialize method"
+          )
+        end
+
+        # check to see if the attribute exists and convert string to symbol for hash key
+        attributes = attributes.each_with_object({}) { |(k, v), h|
+          if (!self.class.attribute_map.key?(k.to_sym))
+            raise(
+              ArgumentError,
+              "`#{k}` is not a valid attribute in `Algolia::FetchedIndexAbTest`. 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
+        }
+
+        if attributes.key?(:id)
+          self.id = attributes[:id]
+        else
+          self.id = nil
+        end
+
+        if attributes.key?(:version)
+          self.version = attributes[:version]
+        end
+
+        if attributes.key?(:type)
+          self.type = attributes[:type]
+        end
+
+        if attributes.key?(:target)
+          self.target = attributes[:target]
+        end
+
+        if attributes.key?(:variants)
+          if (value = attributes[:variants]).is_a?(Array)
+            self.variants = value
+          end
+        else
+          self.variants = nil
+        end
+      end
+
+      # Checks equality by comparing each attribute.
+      # @param [Object] Object to be compared
+      def ==(other)
+        return true if self.equal?(other)
+        self.class == other.class &&
+          id == other.id &&
+          version == other.version &&
+          type == other.type &&
+          target == other.target &&
+          variants == other.variants
+      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
+        [id, version, type, target, variants].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
+          # model
+        else
+          # models (e.g. Pet) or oneOf
+          klass = Algolia::Search.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/search/fetched_index_ab_test_target.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+# 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 Search
+    # A/B test target criteria. Only present for v2 and later tests.
+    class FetchedIndexAbTestTarget
+      # Index name to match. Use `*` to target the entire application.
+      attr_accessor :index_name
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :index_name => :indexName
+        }
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :index_name => :"String"
+        }
+      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 = {})
+        if (!attributes.is_a?(Hash))
+          raise(
+            ArgumentError,
+            "The input argument (attributes) must be a hash in `Algolia::FetchedIndexAbTestTarget` initialize method"
+          )
+        end
+
+        # check to see if the attribute exists and convert string to symbol for hash key
+        attributes = attributes.each_with_object({}) { |(k, v), h|
+          if (!self.class.attribute_map.key?(k.to_sym))
+            raise(
+              ArgumentError,
+              "`#{k}` is not a valid attribute in `Algolia::FetchedIndexAbTestTarget`. 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
+        }
+
+        if attributes.key?(:index_name)
+          self.index_name = attributes[:index_name]
+        else
+          self.index_name = nil
+        end
+      end
+
+      # Checks equality by comparing each attribute.
+      # @param [Object] Object to be compared
+      def ==(other)
+        return true if self.equal?(other)
+        self.class == other.class &&
+          index_name == other.index_name
+      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
+        [index_name].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
+          # model
+        else
+          # models (e.g. Pet) or oneOf
+          klass = Algolia::Search.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