algolia 3.24.0 → 3.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98922e2955f34bbd0985980254a793abbf9d850500ca599bb873cc8527ace278
-  data.tar.gz: ffc863df89f0187c6d44fe1528e5d5bed7d1c1aa5b8249b9820a8849eab79579
+  metadata.gz: 1404975c1e5ba8114c39898c74721f95f8e5c20f9eb9d823c12257dff41808cc
+  data.tar.gz: 49e83567a7b8792318599f9615a3332aaa390a3a8796f2b8500d0c613df5338f
 SHA512:
-  metadata.gz: f68ad7647ec8f2b8b07322bf3cd93e561c8f320d22f710885720a5b7d3af911316a37ffbe939632794a7c48a200d5e1a64a3b355be732394a98873424e04f8f5
-  data.tar.gz: d520b06148c6b2229d38f1c4c9e2d94e6f5138e19b776e47b55b7eceaf43325262c815ffc54ce15efb44fae83adbdddcf70e169ecc7f917a63422590a9ba6dd6
+  metadata.gz: fd8fd30e11c95742f37123615223560666119959ad070b024a9aee73f9fca725fe0745d239900a7a4c85a37d5ab4050c16ffafe33eb16f23e4b6a15b4aaeaaa0
+  data.tar.gz: b2471b57a54330686b9fdf52e40f7999015d81e23befd8d712ec0f21f91c98e64f644ed22c3eb97e56f6cd6260002d484fadcafb7a5085273209f617976c12a1

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [3.25.0](https://github.com/algolia/algoliasearch-client-ruby/compare/3.24.0...3.25.0)
+
+- [8f4abf3a1](https://github.com/algolia/api-clients-automation/commit/8f4abf3a1) fix(specs): Cross-reference filerPromotes to relevant guide ([#5279](https://github.com/algolia/api-clients-automation/pull/5279)) by [@gazconroy](https://github.com/gazconroy/)
+- [1f4a3a9f7](https://github.com/algolia/api-clients-automation/commit/1f4a3a9f7) feat(specs): add put task endpoint to ingestion api ([#5281](https://github.com/algolia/api-clients-automation/pull/5281)) by [@shortcuts](https://github.com/shortcuts/)
+- [08e9d1888](https://github.com/algolia/api-clients-automation/commit/08e9d1888) fix(specs): add getVersion parameter to getSettings ([#5254](https://github.com/algolia/api-clients-automation/pull/5254)) by [@millotp](https://github.com/millotp/)
+- [f4eee1c4a](https://github.com/algolia/api-clients-automation/commit/f4eee1c4a) chore(website): exclude schema from generated variables file ([#5306](https://github.com/algolia/api-clients-automation/pull/5306)) by [@Fluf22](https://github.com/Fluf22/)
+- [2fa0389f8](https://github.com/algolia/api-clients-automation/commit/2fa0389f8) fix(clients): link to support/help center on unreachable hosts ([#5305](https://github.com/algolia/api-clients-automation/pull/5305)) by [@shortcuts](https://github.com/shortcuts/)
+
 ## [3.24.0](https://github.com/algolia/algoliasearch-client-ruby/compare/3.23.0...3.24.0)
 
 - [48672036c1](https://github.com/algolia/api-clients-automation/commit/48672036c1) refactor(specs): mutualise code between Search API & Comp API for search query parameters ([#5125](https://github.com/algolia/api-clients-automation/pull/5125)) by [@ClaraMuller](https://github.com/ClaraMuller/)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    algolia (3.24.0)
+    algolia (3.25.0)
       base64 (>= 0.2.0, < 1)
       faraday (>= 1.0.1, < 3.0)
       faraday-net_http_persistent (>= 0.15, < 3)

data/lib/algolia/api/ingestion_client.rb

@@ -2265,6 +2265,52 @@ module Algolia
       @api_client.deserialize(response.body, request_options[:debug_return_type] || "Ingestion::WatchResponse")
     end
 
+    # Fully updates a task by its ID, use partialUpdateTask if you only want to update a subset of fields.
+
+    # @param task_id [String] Unique identifier of a task. (required)
+    # @param task_replace [TaskReplace]  (required)
+    # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
+    # @return [Http::Response] the response
+    def replace_task_with_http_info(task_id, task_replace, request_options = {})
+      # verify the required parameter 'task_id' is set
+      if @api_client.config.client_side_validation && task_id.nil?
+        raise ArgumentError, "Parameter `task_id` is required when calling `replace_task`."
+      end
+      # verify the required parameter 'task_replace' is set
+      if @api_client.config.client_side_validation && task_replace.nil?
+        raise ArgumentError, "Parameter `task_replace` is required when calling `replace_task`."
+      end
+
+      path = "/2/tasks/{taskID}".sub("{" + "taskID" + "}", Transport.encode_uri(task_id.to_s))
+      query_params = {}
+      query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
+      header_params = {}
+      header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?
+
+      post_body = request_options[:debug_body] || @api_client.object_to_http_body(task_replace)
+
+      new_options = request_options.merge(
+        :operation => :"IngestionClient.replace_task",
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :use_read_transporter => false
+      )
+
+      @api_client.call_api(:PUT, path, new_options)
+    end
+
+    # Fully updates a task by its ID, use partialUpdateTask if you only want to update a subset of fields.
+
+    # @param task_id [String] Unique identifier of a task. (required)
+    # @param task_replace [TaskReplace]  (required)
+    # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
+    # @return [TaskUpdateResponse]
+    def replace_task(task_id, task_replace, request_options = {})
+      response = replace_task_with_http_info(task_id, task_replace, request_options)
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Ingestion::TaskUpdateResponse")
+    end
+
     # Runs all tasks linked to a source, only available for Shopify, BigCommerce and commercetools sources. Creates one run per task.
     #
     # Required API Key ACLs:
@@ -3046,7 +3092,7 @@ module Algolia
       @api_client.deserialize(response.body, request_options[:debug_return_type] || "Ingestion::SourceUpdateResponse")
     end
 
-    # Updates a task by its ID.
+    # Partially updates a task by its ID.
 
     # @param task_id [String] Unique identifier of a task. (required)
     # @param task_update [TaskUpdate]  (required)
@@ -3081,7 +3127,7 @@ module Algolia
       @api_client.call_api(:PATCH, path, new_options)
     end
 
-    # Updates a task by its ID.
+    # Partially updates a task by its ID.
 
     # @param task_id [String] Unique identifier of a task. (required)
     # @param task_update [TaskUpdate]  (required)

data/lib/algolia/api/search_client.rb

@@ -1503,9 +1503,10 @@ module Algolia
     # Required API Key ACLs:
     #   - settings
     # @param index_name [String] Name of the index on which to perform the operation. (required)
+    # @param get_version [Integer] When set to 2, the endpoint will not include `synonyms` in the response. This parameter is here for backward compatibility. (default to 1)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
-    def get_settings_with_http_info(index_name, request_options = {})
+    def get_settings_with_http_info(index_name, get_version = nil, request_options = {})
       # verify the required parameter 'index_name' is set
       if @api_client.config.client_side_validation && index_name.nil?
         raise ArgumentError, "Parameter `index_name` is required when calling `get_settings`."
@@ -1513,6 +1514,7 @@ module Algolia
 
       path = "/1/indexes/{indexName}/settings".sub("{" + "indexName" + "}", Transport.encode_uri(index_name.to_s))
       query_params = {}
+      query_params[:getVersion] = get_version unless get_version.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
       header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?
@@ -1535,10 +1537,11 @@ module Algolia
     # Required API Key ACLs:
     #   - settings
     # @param index_name [String] Name of the index on which to perform the operation. (required)
+    # @param get_version [Integer] When set to 2, the endpoint will not include `synonyms` in the response. This parameter is here for backward compatibility. (default to 1)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [SettingsResponse]
-    def get_settings(index_name, request_options = {})
-      response = get_settings_with_http_info(index_name, request_options)
+    def get_settings(index_name, get_version = nil, request_options = {})
+      response = get_settings_with_http_info(index_name, get_version, request_options)
       @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::SettingsResponse")
     end
 

data/lib/algolia/models/composition/external_injected_item.rb

@@ -0,0 +1,212 @@
+# 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 Composition
+    class ExternalInjectedItem
+      attr_accessor :items
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :items => :items
+        }
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :items => :"Array<ExternalInjection>"
+        }
+      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::ExternalInjectedItem` 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::ExternalInjectedItem`. 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?(:items)
+          if (value = attributes[:items]).is_a?(Array)
+            self.items = value
+          end
+        else
+          self.items = 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 &&
+          items == other.items
+      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
+        [items].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::Composition.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/composition/external_injection.rb

@@ -0,0 +1,223 @@
+# 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 Composition
+    class ExternalInjection
+      # An objectID injected into an external source.
+      attr_accessor :algolia_object_id
+
+      # User-defined key-values that will be added to the injected item in the response. This is identical to Hits metadata defined in Composition or Composition Rule, with the benefit of being set at runtime.
+      attr_accessor :metadata
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :algolia_object_id => :objectID,
+          :metadata => :metadata
+        }
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :algolia_object_id => :"String",
+          :metadata => :"Hash<String, Object>"
+        }
+      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::ExternalInjection` 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::ExternalInjection`. 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?(:algolia_object_id)
+          self.algolia_object_id = attributes[:algolia_object_id]
+        else
+          self.algolia_object_id = nil
+        end
+
+        if attributes.key?(:metadata)
+          if (value = attributes[:metadata]).is_a?(Hash)
+            self.metadata = value
+          end
+        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 &&
+          algolia_object_id == other.algolia_object_id &&
+          metadata == other.metadata
+      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
+        [algolia_object_id, metadata].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::Composition.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/composition/params.rb

@@ -80,6 +80,9 @@ module Algolia
       # Whether this search will use [Dynamic Re-Ranking](https://www.algolia.com/doc/guides/algolia-ai/re-ranking/) This setting only has an effect if you activated Dynamic Re-Ranking for this index in the Algolia dashboard.
       attr_accessor :enable_re_ranking
 
+      # A list of extenrally injected objectID groups into from an external source.
+      attr_accessor :injected_items
+
       # Attribute mapping from ruby-style variable name to JSON key.
       def self.attribute_map
         {
@@ -108,7 +111,8 @@ module Algolia
           :analytics => :analytics,
           :analytics_tags => :analyticsTags,
           :enable_ab_test => :enableABTest,
-          :enable_re_ranking => :enableReRanking
+          :enable_re_ranking => :enableReRanking,
+          :injected_items => :injectedItems
         }
       end
 
@@ -140,7 +144,8 @@ module Algolia
           :analytics => :"Boolean",
           :analytics_tags => :"Array<String>",
           :enable_ab_test => :"Boolean",
-          :enable_re_ranking => :"Boolean"
+          :enable_re_ranking => :"Boolean",
+          :injected_items => :"Hash<String, ExternalInjectedItem>"
         }
       end
 
@@ -286,6 +291,12 @@ module Algolia
         if attributes.key?(:enable_re_ranking)
           self.enable_re_ranking = attributes[:enable_re_ranking]
         end
+
+        if attributes.key?(:injected_items)
+          if (value = attributes[:injected_items]).is_a?(Hash)
+            self.injected_items = value
+          end
+        end
       end
 
       # Checks equality by comparing each attribute.
@@ -318,7 +329,8 @@ module Algolia
           analytics == other.analytics &&
           analytics_tags == other.analytics_tags &&
           enable_ab_test == other.enable_ab_test &&
-          enable_re_ranking == other.enable_re_ranking
+          enable_re_ranking == other.enable_re_ranking &&
+          injected_items == other.injected_items
       end
 
       # @see the `==` method
@@ -356,7 +368,8 @@ module Algolia
           analytics,
           analytics_tags,
           enable_ab_test,
-          enable_re_ranking
+          enable_re_ranking,
+          injected_items
         ].hash
       end
 

data/lib/algolia/models/ingestion/task_replace.rb

@@ -0,0 +1,310 @@
+# 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 Ingestion
+    # API request body for updating a task.
+    class TaskReplace
+      # Universally unique identifier (UUID) of a destination resource.
+      attr_accessor :destination_id
+
+      attr_accessor :action
+
+      attr_accessor :subscription_action
+
+      # Cron expression for the task's schedule.
+      attr_accessor :cron
+
+      # Whether the task is enabled.
+      attr_accessor :enabled
+
+      # Maximum accepted percentage of failures for a task run to finish successfully.
+      attr_accessor :failure_threshold
+
+      attr_accessor :input
+
+      # Date of the last cursor in RFC 3339 format.
+      attr_accessor :cursor
+
+      attr_accessor :notifications
+
+      attr_accessor :policies
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :destination_id => :destinationID,
+          :action => :action,
+          :subscription_action => :subscriptionAction,
+          :cron => :cron,
+          :enabled => :enabled,
+          :failure_threshold => :failureThreshold,
+          :input => :input,
+          :cursor => :cursor,
+          :notifications => :notifications,
+          :policies => :policies
+        }
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :destination_id => :"String",
+          :action => :"ActionType",
+          :subscription_action => :"ActionType",
+          :cron => :"String",
+          :enabled => :"Boolean",
+          :failure_threshold => :"Integer",
+          :input => :"TaskInput",
+          :cursor => :"String",
+          :notifications => :"Notifications",
+          :policies => :"Policies"
+        }
+      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::TaskReplace` 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::TaskReplace`. 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?(:destination_id)
+          self.destination_id = attributes[:destination_id]
+        else
+          self.destination_id = nil
+        end
+
+        if attributes.key?(:action)
+          self.action = attributes[:action]
+        else
+          self.action = nil
+        end
+
+        if attributes.key?(:subscription_action)
+          self.subscription_action = attributes[:subscription_action]
+        end
+
+        if attributes.key?(:cron)
+          self.cron = attributes[:cron]
+        end
+
+        if attributes.key?(:enabled)
+          self.enabled = attributes[:enabled]
+        end
+
+        if attributes.key?(:failure_threshold)
+          self.failure_threshold = attributes[:failure_threshold]
+        end
+
+        if attributes.key?(:input)
+          self.input = attributes[:input]
+        end
+
+        if attributes.key?(:cursor)
+          self.cursor = attributes[:cursor]
+        end
+
+        if attributes.key?(:notifications)
+          self.notifications = attributes[:notifications]
+        end
+
+        if attributes.key?(:policies)
+          self.policies = attributes[:policies]
+        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 &&
+          destination_id == other.destination_id &&
+          action == other.action &&
+          subscription_action == other.subscription_action &&
+          cron == other.cron &&
+          enabled == other.enabled &&
+          failure_threshold == other.failure_threshold &&
+          input == other.input &&
+          cursor == other.cursor &&
+          notifications == other.notifications &&
+          policies == other.policies
+      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
+        [
+          destination_id,
+          action,
+          subscription_action,
+          cron,
+          enabled,
+          failure_threshold,
+          input,
+          cursor,
+          notifications,
+          policies
+        ].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::Ingestion.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/ingestion/task_update.rb

@@ -7,7 +7,7 @@ require "time"
 
 module Algolia
   module Ingestion
-    # API request body for updating a task.
+    # API request body for partially updating a task.
     class TaskUpdate
       # Universally unique identifier (UUID) of a destination resource.
       attr_accessor :destination_id

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

@@ -14,7 +14,7 @@ module Algolia
       # 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.
       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.
+      # Determines whether promoted records must also match active filters for the consequence to apply.  This ensures user-applied filters take priority and irrelevant matches aren't shown. For example, if you promote a record with `color: red` but the user filters for `color: blue`, the \"red\" record won't be shown.  > In the Algolia dashboard, when you use the **Pin an item** consequence, `filterPromotes` appears as the checkbox: **Pinned items must match active filters to be displayed.** For examples, see [Promote results with rules](https://www.algolia.com/doc/guides/managing-results/rules/merchandising-and-promoting/how-to/promote-hits/#promote-results-matching-active-filters).
       attr_accessor :filter_promotes
 
       # Records you want to hide from the search results.

data/lib/algolia/transport/transport.rb

@@ -85,7 +85,12 @@ module Algolia
           end
         end
 
-        raise Algolia::AlgoliaUnreachableHostError.new("Unreachable hosts.", retry_errors)
+        raise(
+          Algolia::AlgoliaUnreachableHostError.new(
+            "Unreachable hosts. If the error persists, please visit our help center https://alg.li/support-unreachable-hosts or reach out to the Algolia Support team: https://alg.li/support",
+            retry_errors
+          )
+        )
       end
 
       private

data/lib/algolia/version.rb

@@ -3,5 +3,5 @@
 # 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.
 
 module Algolia
-  VERSION = "3.24.0"
+  VERSION = "3.25.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: algolia
 version: !ruby/object:Gem::Version
-  version: 3.24.0
+  version: 3.25.0
 platform: ruby
 authors:
 - https://alg.li/support
@@ -270,6 +270,8 @@ files:
 - lib/algolia/models/composition/compositions_search_response.rb
 - lib/algolia/models/composition/error_base.rb
 - lib/algolia/models/composition/exhaustive.rb
+- lib/algolia/models/composition/external_injected_item.rb
+- lib/algolia/models/composition/external_injection.rb
 - lib/algolia/models/composition/facet_filters.rb
 - lib/algolia/models/composition/facet_hits.rb
 - lib/algolia/models/composition/facet_ordering.rb
@@ -433,6 +435,7 @@ files:
 - lib/algolia/models/ingestion/task_create_trigger.rb
 - lib/algolia/models/ingestion/task_create_v1.rb
 - lib/algolia/models/ingestion/task_input.rb
+- lib/algolia/models/ingestion/task_replace.rb
 - lib/algolia/models/ingestion/task_search.rb
 - lib/algolia/models/ingestion/task_sort_keys.rb
 - lib/algolia/models/ingestion/task_update.rb