algolia 3.0.0.alpha.15 → 3.0.0.alpha.17

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

@@ -5,51 +5,19 @@ require 'time'
 
 module Algolia
   module Recommend
+    # Condition that triggers the rule. If not specified, the rule is triggered for all recommendations.
     class Condition
-      # Query pattern that triggers the rule.  You can use either a literal string, or a special pattern `{facet:ATTRIBUTE}`, where `ATTRIBUTE` is a facet name. The rule is triggered if the query matches the literal string or a value of the specified facet. For example, with `pattern: {facet:genre}`, the rule is triggered when users search for a genre, such as \"comedy\".
-      attr_accessor :pattern
-
-      attr_accessor :anchoring
-
-      # Whether the pattern should match plurals, synonyms, and typos.
-      attr_accessor :alternatives
+      # Filter expression to only include items that match the filter criteria in the response.  You can use these filter expressions:  - **Numeric filters.** `<facet> <op> <number>`, where `<op>` is one of `<`, `<=`, `=`, `!=`, `>`, `>=`. - **Ranges.** `<facet>:<lower> TO <upper>` where `<lower>` and `<upper>` are the lower and upper limits of the range (inclusive). - **Facet filters.** `<facet>:<value>` where `<facet>` is a facet attribute (case-sensitive) and `<value>` a facet value. - **Tag filters.** `_tags:<value>` or just `<value>` (case-sensitive). - **Boolean filters.** `<facet>: true | false`.  You can combine filters with `AND`, `OR`, and `NOT` operators with the following restrictions:  - You can only combine filters of the same type with `OR`.   **Not supported:** `facet:value OR num > 3`. - You can't use `NOT` with combinations of filters.   **Not supported:** `NOT(facet:value OR facet:value)` - You can't combine conjunctions (`AND`) with `OR`.   **Not supported:** `facet:value OR (facet:value AND facet:value)`  Use quotes around your filters, if the facet attribute name or facet value has spaces, keywords (`OR`, `AND`, `NOT`), or quotes. If a facet attribute is an array, the filter matches if it matches at least one element of the array.  For more information, see [Filters](https://www.algolia.com/doc/guides/managing-results/refine-results/filtering/).
+      attr_accessor :filters
 
       # An additional restriction that only triggers the rule, when the search has the same value as `ruleContexts` parameter. For example, if `context: mobile`, the rule is only triggered when the search request has a matching `ruleContexts: mobile`. A rule context must only contain alphanumeric characters.
       attr_accessor :context
 
-      # Filters that trigger the rule.  You can add add filters using the syntax `facet:value` so that the rule is triggered, when the specific filter is selected. You can use `filters` on its own or combine it with the `pattern` parameter.
-      attr_accessor :filters
-
-      class EnumAttributeValidator
-        attr_reader :datatype
-        attr_reader :allowable_values
-
-        def initialize(datatype, allowable_values)
-          @allowable_values = allowable_values.map do |value|
-            case datatype.to_s
-            when /Integer/i
-              value.to_i
-            when /Float/i
-              value.to_f
-            else
-              value
-            end
-          end
-        end
-
-        def valid?(value)
-          !value || allowable_values.include?(value)
-        end
-      end
-
       # Attribute mapping from ruby-style variable name to JSON key.
       def self.attribute_map
         {
-          :pattern => :pattern,
-          :anchoring => :anchoring,
-          :alternatives => :alternatives,
-          :context => :context,
-          :filters => :filters
+          :filters => :filters,
+          :context => :context
         }
       end
 
@@ -61,11 +29,8 @@ module Algolia
       # Attribute type mapping.
       def self.types_mapping
         {
-          :pattern => :String,
-          :anchoring => :Anchoring,
-          :alternatives => :Boolean,
-          :context => :String,
-          :filters => :String
+          :filters => :String,
+          :context => :String
         }
       end
 
@@ -91,25 +56,13 @@ module Algolia
           h[k.to_sym] = v
         end
 
-        if attributes.key?(:pattern)
-          self.pattern = attributes[:pattern]
-        end
-
-        if attributes.key?(:anchoring)
-          self.anchoring = attributes[:anchoring]
-        end
-
-        if attributes.key?(:alternatives)
-          self.alternatives = attributes[:alternatives]
+        if attributes.key?(:filters)
+          self.filters = attributes[:filters]
         end
 
         if attributes.key?(:context)
           self.context = attributes[:context]
         end
-
-        if attributes.key?(:filters)
-          self.filters = attributes[:filters]
-        end
       end
 
       # Custom attribute writer method with validation
@@ -133,11 +86,8 @@ module Algolia
         return true if equal?(other)
 
         self.class == other.class &&
-          pattern == other.pattern &&
-          anchoring == other.anchoring &&
-          alternatives == other.alternatives &&
-          context == other.context &&
-          filters == other.filters
+          filters == other.filters &&
+          context == other.context
       end
 
       # @see the `==` method
@@ -149,7 +99,7 @@ module Algolia
       # Calculates hash code according to all attributes.
       # @return [Integer] Hash code
       def hash
-        [pattern, anchoring, alternatives, context, filters].hash
+        [filters, context].hash
       end
 
       # Builds the object from hash

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

@@ -5,30 +5,22 @@ require 'time'
 
 module Algolia
   module Recommend
-    # Effect of the rule.  For more information, see [Consequences](https://www.algolia.com/doc/guides/managing-results/rules/rules-overview/#consequences).
+    # Effect of the rule.
     class Consequence
-      attr_accessor :params
+      # Exclude items from recommendations.
+      attr_accessor :hide
 
-      # Records you want to pin to a specific position in the search results.  You can promote up to 300 records, either individually, or as groups of up to 100 records each.
+      # Place items at specific positions in the list of recommendations.
       attr_accessor :promote
 
-      # Whether promoted records must match an active filter for the consequence to be applied.  This ensures that user actions (filtering the search) are given a higher precendence. For example, if you promote a record with the `color: red` attribute, and the user filters the search for `color: blue`, the \"red\" record won't be shown.
-      attr_accessor :filter_promotes
-
-      # Records you want to hide from the search results.
-      attr_accessor :hide
-
-      # A JSON object with custom data that will be appended to the `userData` array in the response. This object isn't interpreted by the API and is limited to 1 kB of minified JSON.
-      attr_accessor :user_data
+      attr_accessor :params
 
       # Attribute mapping from ruby-style variable name to JSON key.
       def self.attribute_map
         {
-          :params => :params,
-          :promote => :promote,
-          :filter_promotes => :filterPromotes,
           :hide => :hide,
-          :user_data => :userData
+          :promote => :promote,
+          :params => :params
         }
       end
 
@@ -40,19 +32,15 @@ module Algolia
       # Attribute type mapping.
       def self.types_mapping
         {
-          :params => :ConsequenceParams,
-          :promote => :'Array<Promote>',
-          :filter_promotes => :Boolean,
-          :hide => :'Array<ConsequenceHide>',
-          :user_data => :Object
+          :hide => :'Array<HideConsequenceObject>',
+          :promote => :'Array<PromoteConsequenceObject>',
+          :params => :ParamsConsequence
         }
       end
 
       # List of attributes with nullable: true
       def self.openapi_nullable
-        Set.new([
-                  :user_data
-                ])
+        Set.new([])
       end
 
       # Initializes the object
@@ -72,8 +60,10 @@ module Algolia
           h[k.to_sym] = v
         end
 
-        if attributes.key?(:params)
-          self.params = attributes[:params]
+        if attributes.key?(:hide)
+          if (value = attributes[:hide]).is_a?(Array)
+            self.hide = value
+          end
         end
 
         if attributes.key?(:promote)
@@ -82,19 +72,23 @@ module Algolia
           end
         end
 
-        if attributes.key?(:filter_promotes)
-          self.filter_promotes = attributes[:filter_promotes]
+        if attributes.key?(:params)
+          self.params = attributes[:params]
         end
+      end
 
-        if attributes.key?(:hide)
-          if (value = attributes[:hide]).is_a?(Array)
-            self.hide = value
-          end
+      # Custom attribute writer method with validation
+      # @param [Object] hide Value to be assigned
+      def hide=(hide)
+        if hide.nil?
+          raise ArgumentError, 'hide cannot be nil'
         end
 
-        if attributes.key?(:user_data)
-          self.user_data = attributes[:user_data]
+        if hide.length < 1
+          raise ArgumentError, 'invalid value for "hide", number of items must be greater than or equal to 1.'
         end
+
+        @hide = hide
       end
 
       # Custom attribute writer method with validation
@@ -104,38 +98,22 @@ module Algolia
           raise ArgumentError, 'promote cannot be nil'
         end
 
-        if promote.length > 300
-          raise ArgumentError, 'invalid value for "promote", number of items must be less than or equal to 300.'
+        if promote.length < 1
+          raise ArgumentError, 'invalid value for "promote", number of items must be greater than or equal to 1.'
         end
 
         @promote = promote
       end
 
-      # Custom attribute writer method with validation
-      # @param [Object] hide Value to be assigned
-      def hide=(hide)
-        if hide.nil?
-          raise ArgumentError, 'hide cannot be nil'
-        end
-
-        if hide.length > 50
-          raise ArgumentError, 'invalid value for "hide", number of items must be less than or equal to 50.'
-        end
-
-        @hide = hide
-      end
-
       # Checks equality by comparing each attribute.
       # @param [Object] Object to be compared
       def ==(other)
         return true if equal?(other)
 
         self.class == other.class &&
-          params == other.params &&
-          promote == other.promote &&
-          filter_promotes == other.filter_promotes &&
           hide == other.hide &&
-          user_data == other.user_data
+          promote == other.promote &&
+          params == other.params
       end
 
       # @see the `==` method
@@ -147,7 +125,7 @@ module Algolia
       # Calculates hash code according to all attributes.
       # @return [Integer] Hash code
       def hash
-        [params, promote, filter_promotes, hide, user_data].hash
+        [hide, promote, params].hash
       end
 
       # Builds the object from hash

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

@@ -10,7 +10,7 @@ module Algolia
       # Unique identifier of a task.  A successful API response means that a task was added to a queue. It might not run immediately. You can check the task's progress with the [`task` operation](#tag/Indices/operation/getTask) and this `taskID`.
       attr_accessor :task_id
 
-      # Timestamp of deletion in [ISO 8601](https://wikipedia.org/wiki/ISO_8601) format.
+      # Date and time when the object was deleted, in RFC 3339 format.
       attr_accessor :deleted_at
 
       # Attribute mapping from ruby-style variable name to JSON key.

data/lib/algolia/models/recommend/{recommended_for_you_query_parameters.rb → fallback_params.rb}

@@ -5,14 +5,14 @@ require 'time'
 
 module Algolia
   module Recommend
-    class RecommendedForYouQueryParameters
+    class FallbackParams
       # Search query.
       attr_accessor :query
 
       # Keywords to be used instead of the search query to conduct a more broader search.  Using the `similarQuery` parameter changes other settings:  - `queryType` is set to `prefixNone`. - `removeStopWords` is set to true. - `words` is set as the first ranking criterion. - All remaining words are treated as `optionalWords`.  Since the `similarQuery` is supposed to do a broad search, they usually return many results. Combine it with `filters` to narrow down the list of results.
       attr_accessor :similar_query
 
-      # Filter the search so that only records with matching values are included in the results.  These filters are supported:  - **Numeric filters.** `<facet> <op> <number>`, where `<op>` is one of `<`, `<=`, `=`, `!=`, `>`, `>=`. - **Ranges.** `<facet>:<lower> TO <upper>` where `<lower>` and `<upper>` are the lower and upper limits of the range (inclusive). - **Facet filters.** `<facet>:<value>` where `<facet>` is a facet attribute (case-sensitive) and `<value>` a facet value. - **Tag filters.** `_tags:<value>` or just `<value>` (case-sensitive). - **Boolean filters.** `<facet>: true | false`.  You can combine filters with `AND`, `OR`, and `NOT` operators with the following restrictions:  - You can only combine filters of the same type with `OR`.   **Not supported:** `facet:value OR num > 3`. - You can't use `NOT` with combinations of filters.   **Not supported:** `NOT(facet:value OR facet:value)` - You can't combine conjunctions (`AND`) with `OR`.   **Not supported:** `facet:value OR (facet:value AND facet:value)`  Use quotes around your filters, if the facet attribute name or facet value has spaces, keywords (`OR`, `AND`, `NOT`), or quotes. If a facet attribute is an array, the filter matches if it matches at least one element of the array.  For more information, see [Filters](https://www.algolia.com/doc/guides/managing-results/refine-results/filtering/).
+      # Filter expression to only include items that match the filter criteria in the response.  You can use these filter expressions:  - **Numeric filters.** `<facet> <op> <number>`, where `<op>` is one of `<`, `<=`, `=`, `!=`, `>`, `>=`. - **Ranges.** `<facet>:<lower> TO <upper>` where `<lower>` and `<upper>` are the lower and upper limits of the range (inclusive). - **Facet filters.** `<facet>:<value>` where `<facet>` is a facet attribute (case-sensitive) and `<value>` a facet value. - **Tag filters.** `_tags:<value>` or just `<value>` (case-sensitive). - **Boolean filters.** `<facet>: true | false`.  You can combine filters with `AND`, `OR`, and `NOT` operators with the following restrictions:  - You can only combine filters of the same type with `OR`.   **Not supported:** `facet:value OR num > 3`. - You can't use `NOT` with combinations of filters.   **Not supported:** `NOT(facet:value OR facet:value)` - You can't combine conjunctions (`AND`) with `OR`.   **Not supported:** `facet:value OR (facet:value AND facet:value)`  Use quotes around your filters, if the facet attribute name or facet value has spaces, keywords (`OR`, `AND`, `NOT`), or quotes. If a facet attribute is an array, the filter matches if it matches at least one element of the array.  For more information, see [Filters](https://www.algolia.com/doc/guides/managing-results/refine-results/filtering/).
       attr_accessor :filters
 
       attr_accessor :facet_filters
@@ -99,10 +99,10 @@ module Algolia
       # Attributes to include in the API response.  To reduce the size of your response, you can retrieve only some of the attributes.  - `*` retrieves all attributes, except attributes included in the `customRanking` and `unretrievableAttributes` settings. - To retrieve all attributes except a specific one, prefix the attribute with a dash and combine it with the `*`: `[\"*\", \"-ATTRIBUTE\"]`. - The `objectID` attribute is always included.
       attr_accessor :attributes_to_retrieve
 
-      # Determines the order in which Algolia returns your results.  By default, each entry corresponds to a [ranking criteria](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria/). The tie-breaking algorithm sequentially applies each criterion in the order they're specified. If you configure a replica index for [sorting by an attribute](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/how-to/sort-by-attribute/), you put the sorting attribute at the top of the list.  **Modifiers**  <dl> <dt><code>asc(\"ATTRIBUTE\")</code></dt> <dd>Sort the index by the values of an attribute, in ascending order.</dd> <dt><code>desc(\"ATTRIBUTE\")</code></dt> <dd>Sort the index by the values of an attribute, in descending order.</dd> </dl>  Before you modify the default setting, you should test your changes in the dashboard, and by [A/B testing](https://www.algolia.com/doc/guides/ab-testing/what-is-ab-testing/).
+      # Determines the order in which Algolia returns your results.  By default, each entry corresponds to a [ranking criteria](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria/). The tie-breaking algorithm sequentially applies each criterion in the order they're specified. If you configure a replica index for [sorting by an attribute](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/how-to/sort-by-attribute/), you put the sorting attribute at the top of the list.  **Modifiers**  - `asc(\"ATTRIBUTE\")`.   Sort the index by the values of an attribute, in ascending order. - `desc(\"ATTRIBUTE\")`.   Sort the index by the values of an attribute, in descending order.  Before you modify the default setting, you should test your changes in the dashboard, and by [A/B testing](https://www.algolia.com/doc/guides/ab-testing/what-is-ab-testing/).
       attr_accessor :ranking
 
-      # Attributes to use as [custom ranking](https://www.algolia.com/doc/guides/managing-results/must-do/custom-ranking/).  The custom ranking attributes decide which items are shown first if the other ranking criteria are equal.  Records with missing values for your selected custom ranking attributes are always sorted last. Boolean attributes are sorted based on their alphabetical order.  **Modifiers**  <dl> <dt><code>asc(\"ATTRIBUTE\")</code></dt> <dd>Sort the index by the values of an attribute, in ascending order.</dd> <dt><code>desc(\"ATTRIBUTE\")</code></dt> <dd>Sort the index by the values of an attribute, in descending order.</dd> </dl>  If you use two or more custom ranking attributes, [reduce the precision](https://www.algolia.com/doc/guides/managing-results/must-do/custom-ranking/how-to/controlling-custom-ranking-metrics-precision/) of your first attributes, or the other attributes will never be applied.
+      # Attributes to use as [custom ranking](https://www.algolia.com/doc/guides/managing-results/must-do/custom-ranking/).  The custom ranking attributes decide which items are shown first if the other ranking criteria are equal.  Records with missing values for your selected custom ranking attributes are always sorted last. Boolean attributes are sorted based on their alphabetical order.  **Modifiers**  - `asc(\"ATTRIBUTE\")`.   Sort the index by the values of an attribute, in ascending order.  - `desc(\"ATTRIBUTE\")`.   Sort the index by the values of an attribute, in descending order.  If you use two or more custom ranking attributes, [reduce the precision](https://www.algolia.com/doc/guides/managing-results/must-do/custom-ranking/how-to/controlling-custom-ranking-metrics-precision/) of your first attributes, or the other attributes will never be applied.
       attr_accessor :custom_ranking
 
       # Relevancy threshold below which less relevant results aren't included in the results.  You can only set `relevancyStrictness` on [virtual replica indices](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/in-depth/replicas/#what-are-virtual-replicas). Use this setting to strike a balance between the relevance and number of returned results.
@@ -181,10 +181,10 @@ module Algolia
 
       attr_accessor :exact_on_single_word_query
 
-      # Alternatives of query words that should be considered as exact matches by the Exact ranking criterion.  <dl> <dt><code>ignorePlurals</code></dt> <dd>  Plurals and similar declensions added by the `ignorePlurals` setting are considered exact matches.  </dd> <dt><code>singleWordSynonym</code></dt> <dd> Single-word synonyms, such as \"NY/NYC\" are considered exact matches. </dd> <dt><code>multiWordsSynonym</code></dt> <dd> Multi-word synonyms, such as \"NY/New York\" are considered exact matches. </dd> </dl>.
+      # Alternatives of query words that should be considered as exact matches by the Exact ranking criterion.  - `ignorePlurals`.   Plurals and similar declensions added by the `ignorePlurals` setting are considered exact matches.  - `singleWordSynonym`.   Single-word synonyms, such as \"NY/NYC\" are considered exact matches.  - `multiWordsSynonym`.   Multi-word synonyms, such as \"NY/New York\" are considered exact matches.
       attr_accessor :alternatives_as_exact
 
-      # Advanced search syntax features you want to support.  <dl> <dt><code>exactPhrase</code></dt> <dd>  Phrases in quotes must match exactly. For example, `sparkly blue \"iPhone case\"` only returns records with the exact string \"iPhone case\".  </dd> <dt><code>excludeWords</code></dt> <dd>  Query words prefixed with a `-` must not occur in a record. For example, `search -engine` matches records that contain \"search\" but not \"engine\".  </dd> </dl>  This setting only has an effect if `advancedSyntax` is true.
+      # Advanced search syntax features you want to support.  - `exactPhrase`.   Phrases in quotes must match exactly.   For example, `sparkly blue \"iPhone case\"` only returns records with the exact string \"iPhone case\".  - `excludeWords`.   Query words prefixed with a `-` must not occur in a record.   For example, `search -engine` matches records that contain \"search\" but not \"engine\".  This setting only has an effect if `advancedSyntax` is true.
       attr_accessor :advanced_syntax_features
 
       attr_accessor :distinct
@@ -204,7 +204,7 @@ module Algolia
       # Maximum number of facet values to return for each facet.
       attr_accessor :max_values_per_facet
 
-      # Order in which to retrieve facet values.  <dl> <dt><code>count</code></dt> <dd> Facet values are retrieved by decreasing count. The count is the number of matching records containing this facet value. </dd> <dt><code>alpha</code></dt> <dd>Retrieve facet values alphabetically.</dd> </dl>  This setting doesn't influence how facet values are displayed in your UI (see `renderingContent`). For more information, see [facet value display](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/facet-display/js/).
+      # Order in which to retrieve facet values.  - `count`.   Facet values are retrieved by decreasing count.   The count is the number of matching records containing this facet value.  - `alpha`.   Retrieve facet values alphabetically.  This setting doesn't influence how facet values are displayed in your UI (see `renderingContent`). For more information, see [facet value display](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/facet-display/js/).
       attr_accessor :sort_facet_values_by
 
       # Whether the best matching attribute should be determined by minimum proximity.  This setting only affects ranking if the Attribute ranking criterion comes before Proximity in the `ranking` setting. If true, the best matching attribute is selected based on the minimum proximity of multiple matches. Otherwise, the best matching attribute is determined by the order in the `searchableAttributes` setting.
@@ -418,7 +418,6 @@ module Algolia
       # List of class defined in allOf (OpenAPI v3)
       def self.openapi_all_of
         [
-          :BaseRecommendedForYouQueryParameters,
           :SearchParamsObject
         ]
       end
@@ -427,14 +426,14 @@ module Algolia
       # @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::RecommendedForYouQueryParameters` initialize method"
+          raise ArgumentError, "The input argument (attributes) must be a hash in `Algolia::FallbackParams` 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::RecommendedForYouQueryParameters`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+                  "`#{k}` is not a valid attribute in `Algolia::FallbackParams`. 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
@@ -550,8 +549,6 @@ module Algolia
 
         if attributes.key?(:user_token)
           self.user_token = attributes[:user_token]
-        else
-          self.user_token = nil
         end
 
         if attributes.key?(:get_ranking_info)

data/lib/algolia/models/recommend/{edit_type.rb → fbt_model.rb}

@@ -5,12 +5,11 @@ require 'time'
 
 module Algolia
   module Recommend
-    class EditType
-      REMOVE = "remove".freeze
-      REPLACE = "replace".freeze
+    class FbtModel
+      BOUGHT_TOGETHER = "bought-together".freeze
 
       def self.all_vars
-        @all_vars ||= [REMOVE, REPLACE].freeze
+        @all_vars ||= [BOUGHT_TOGETHER].freeze
       end
 
       # Builds the enum from string
@@ -24,9 +23,9 @@ module Algolia
       # @param [String] The enum value in the form of the string
       # @return [String] The enum value
       def build_from_hash(value)
-        return value if EditType.all_vars.include?(value)
+        return value if FbtModel.all_vars.include?(value)
 
-        raise "Invalid ENUM value #{value} for class #EditType"
+        raise "Invalid ENUM value #{value} for class #FbtModel"
       end
     end
   end

data/lib/algolia/models/recommend/{base_trending_facets_query.rb → frequently_bought_together.rb}

@@ -5,12 +5,12 @@ require 'time'
 
 module Algolia
   module Recommend
-    class BaseTrendingFacetsQuery
-      # Facet name for trending models.
-      attr_accessor :facet_name
-
+    class FrequentlyBoughtTogether
       attr_accessor :model
 
+      # Unique record identifier.
+      attr_accessor :object_id
+
       class EnumAttributeValidator
         attr_reader :datatype
         attr_reader :allowable_values
@@ -36,8 +36,8 @@ module Algolia
       # Attribute mapping from ruby-style variable name to JSON key.
       def self.attribute_map
         {
-          :facet_name => :facetName,
-          :model => :model
+          :model => :model,
+          :object_id => :objectID
         }
       end
 
@@ -49,8 +49,8 @@ module Algolia
       # Attribute type mapping.
       def self.types_mapping
         {
-          :facet_name => :String,
-          :model => :TrendingFacetsModel
+          :model => :FbtModel,
+          :object_id => :String
         }
       end
 
@@ -63,27 +63,29 @@ module Algolia
       # @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::BaseTrendingFacetsQuery` initialize method"
+          raise ArgumentError, "The input argument (attributes) must be a hash in `Algolia::FrequentlyBoughtTogether` 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::BaseTrendingFacetsQuery`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+                  "`#{k}` is not a valid attribute in `Algolia::FrequentlyBoughtTogether`. 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_name)
-          self.facet_name = attributes[:facet_name]
+        if attributes.key?(:model)
+          self.model = attributes[:model]
         else
-          self.facet_name = nil
+          self.model = nil
         end
 
-        if attributes.key?(:model)
-          self.model = attributes[:model]
+        if attributes.key?(:object_id)
+          self.object_id = attributes[:object_id]
+        else
+          self.object_id = nil
         end
       end
 
@@ -93,8 +95,8 @@ module Algolia
         return true if equal?(other)
 
         self.class == other.class &&
-          facet_name == other.facet_name &&
-          model == other.model
+          model == other.model &&
+          object_id == other.object_id
       end
 
       # @see the `==` method
@@ -106,7 +108,7 @@ module Algolia
       # Calculates hash code according to all attributes.
       # @return [Integer] Hash code
       def hash
-        [facet_name, model].hash
+        [model, object_id].hash
       end
 
       # Builds the object from hash

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

@@ -5,9 +5,9 @@ require 'time'
 
 module Algolia
   module Recommend
-    # Recommend parameters.
+    # Recommend request body.
     class GetRecommendationsParams
-      # Request parameters depend on the model (recommendations or trending).
+      # Recommendation request with parameters depending on the requested model.
       attr_accessor :requests
 
       # Attribute mapping from ruby-style variable name to JSON key.

data/lib/algolia/models/recommend/{consequence_hide.rb → hide_consequence_object.rb}

@@ -5,8 +5,8 @@ require 'time'
 
 module Algolia
   module Recommend
-    # Object ID of the record to hide.
-    class ConsequenceHide
+    # Object ID of the recommendation you want to exclude.
+    class HideConsequenceObject
       # Unique record identifier.
       attr_accessor :object_id
 
@@ -38,14 +38,14 @@ module Algolia
       # @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::ConsequenceHide` initialize method"
+          raise ArgumentError, "The input argument (attributes) must be a hash in `Algolia::HideConsequenceObject` 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::ConsequenceHide`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+                  "`#{k}` is not a valid attribute in `Algolia::HideConsequenceObject`. 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
@@ -53,8 +53,6 @@ module Algolia
 
         if attributes.key?(:object_id)
           self.object_id = attributes[:object_id]
-        else
-          self.object_id = nil
         end
       end
 

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

@@ -9,10 +9,10 @@ module Algolia
       # Attributes to include in the API response.  To reduce the size of your response, you can retrieve only some of the attributes.  - `*` retrieves all attributes, except attributes included in the `customRanking` and `unretrievableAttributes` settings. - To retrieve all attributes except a specific one, prefix the attribute with a dash and combine it with the `*`: `[\"*\", \"-ATTRIBUTE\"]`. - The `objectID` attribute is always included.
       attr_accessor :attributes_to_retrieve
 
-      # Determines the order in which Algolia returns your results.  By default, each entry corresponds to a [ranking criteria](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria/). The tie-breaking algorithm sequentially applies each criterion in the order they're specified. If you configure a replica index for [sorting by an attribute](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/how-to/sort-by-attribute/), you put the sorting attribute at the top of the list.  **Modifiers**  <dl> <dt><code>asc(\"ATTRIBUTE\")</code></dt> <dd>Sort the index by the values of an attribute, in ascending order.</dd> <dt><code>desc(\"ATTRIBUTE\")</code></dt> <dd>Sort the index by the values of an attribute, in descending order.</dd> </dl>  Before you modify the default setting, you should test your changes in the dashboard, and by [A/B testing](https://www.algolia.com/doc/guides/ab-testing/what-is-ab-testing/).
+      # Determines the order in which Algolia returns your results.  By default, each entry corresponds to a [ranking criteria](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria/). The tie-breaking algorithm sequentially applies each criterion in the order they're specified. If you configure a replica index for [sorting by an attribute](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/how-to/sort-by-attribute/), you put the sorting attribute at the top of the list.  **Modifiers**  - `asc(\"ATTRIBUTE\")`.   Sort the index by the values of an attribute, in ascending order. - `desc(\"ATTRIBUTE\")`.   Sort the index by the values of an attribute, in descending order.  Before you modify the default setting, you should test your changes in the dashboard, and by [A/B testing](https://www.algolia.com/doc/guides/ab-testing/what-is-ab-testing/).
       attr_accessor :ranking
 
-      # Attributes to use as [custom ranking](https://www.algolia.com/doc/guides/managing-results/must-do/custom-ranking/).  The custom ranking attributes decide which items are shown first if the other ranking criteria are equal.  Records with missing values for your selected custom ranking attributes are always sorted last. Boolean attributes are sorted based on their alphabetical order.  **Modifiers**  <dl> <dt><code>asc(\"ATTRIBUTE\")</code></dt> <dd>Sort the index by the values of an attribute, in ascending order.</dd> <dt><code>desc(\"ATTRIBUTE\")</code></dt> <dd>Sort the index by the values of an attribute, in descending order.</dd> </dl>  If you use two or more custom ranking attributes, [reduce the precision](https://www.algolia.com/doc/guides/managing-results/must-do/custom-ranking/how-to/controlling-custom-ranking-metrics-precision/) of your first attributes, or the other attributes will never be applied.
+      # Attributes to use as [custom ranking](https://www.algolia.com/doc/guides/managing-results/must-do/custom-ranking/).  The custom ranking attributes decide which items are shown first if the other ranking criteria are equal.  Records with missing values for your selected custom ranking attributes are always sorted last. Boolean attributes are sorted based on their alphabetical order.  **Modifiers**  - `asc(\"ATTRIBUTE\")`.   Sort the index by the values of an attribute, in ascending order.  - `desc(\"ATTRIBUTE\")`.   Sort the index by the values of an attribute, in descending order.  If you use two or more custom ranking attributes, [reduce the precision](https://www.algolia.com/doc/guides/managing-results/must-do/custom-ranking/how-to/controlling-custom-ranking-metrics-precision/) of your first attributes, or the other attributes will never be applied.
       attr_accessor :custom_ranking
 
       # Relevancy threshold below which less relevant results aren't included in the results.  You can only set `relevancyStrictness` on [virtual replica indices](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/in-depth/replicas/#what-are-virtual-replicas). Use this setting to strike a balance between the relevance and number of returned results.
@@ -91,10 +91,10 @@ module Algolia
 
       attr_accessor :exact_on_single_word_query
 
-      # Alternatives of query words that should be considered as exact matches by the Exact ranking criterion.  <dl> <dt><code>ignorePlurals</code></dt> <dd>  Plurals and similar declensions added by the `ignorePlurals` setting are considered exact matches.  </dd> <dt><code>singleWordSynonym</code></dt> <dd> Single-word synonyms, such as \"NY/NYC\" are considered exact matches. </dd> <dt><code>multiWordsSynonym</code></dt> <dd> Multi-word synonyms, such as \"NY/New York\" are considered exact matches. </dd> </dl>.
+      # Alternatives of query words that should be considered as exact matches by the Exact ranking criterion.  - `ignorePlurals`.   Plurals and similar declensions added by the `ignorePlurals` setting are considered exact matches.  - `singleWordSynonym`.   Single-word synonyms, such as \"NY/NYC\" are considered exact matches.  - `multiWordsSynonym`.   Multi-word synonyms, such as \"NY/New York\" are considered exact matches.
       attr_accessor :alternatives_as_exact
 
-      # Advanced search syntax features you want to support.  <dl> <dt><code>exactPhrase</code></dt> <dd>  Phrases in quotes must match exactly. For example, `sparkly blue \"iPhone case\"` only returns records with the exact string \"iPhone case\".  </dd> <dt><code>excludeWords</code></dt> <dd>  Query words prefixed with a `-` must not occur in a record. For example, `search -engine` matches records that contain \"search\" but not \"engine\".  </dd> </dl>  This setting only has an effect if `advancedSyntax` is true.
+      # Advanced search syntax features you want to support.  - `exactPhrase`.   Phrases in quotes must match exactly.   For example, `sparkly blue \"iPhone case\"` only returns records with the exact string \"iPhone case\".  - `excludeWords`.   Query words prefixed with a `-` must not occur in a record.   For example, `search -engine` matches records that contain \"search\" but not \"engine\".  This setting only has an effect if `advancedSyntax` is true.
       attr_accessor :advanced_syntax_features
 
       attr_accessor :distinct
@@ -114,7 +114,7 @@ module Algolia
       # Maximum number of facet values to return for each facet.
       attr_accessor :max_values_per_facet
 
-      # Order in which to retrieve facet values.  <dl> <dt><code>count</code></dt> <dd> Facet values are retrieved by decreasing count. The count is the number of matching records containing this facet value. </dd> <dt><code>alpha</code></dt> <dd>Retrieve facet values alphabetically.</dd> </dl>  This setting doesn't influence how facet values are displayed in your UI (see `renderingContent`). For more information, see [facet value display](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/facet-display/js/).
+      # Order in which to retrieve facet values.  - `count`.   Facet values are retrieved by decreasing count.   The count is the number of matching records containing this facet value.  - `alpha`.   Retrieve facet values alphabetically.  This setting doesn't influence how facet values are displayed in your UI (see `renderingContent`). For more information, see [facet value display](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/facet-display/js/).
       attr_accessor :sort_facet_values_by
 
       # Whether the best matching attribute should be determined by minimum proximity.  This setting only affects ranking if the Attribute ranking criterion comes before Proximity in the `ranking` setting. If true, the best matching attribute is selected based on the minimum proximity of multiple matches. Otherwise, the best matching attribute is determined by the order in the `searchableAttributes` setting.