algolia 3.38.0 → 3.39.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04aeeacff2c4802f3be4f34616b67c94dda8985d3c3d8826b5f14e3dfd2331dd
-  data.tar.gz: bc1e57a05b971a50815a216fc8766e7c5d8d2b7361991d0c0644375e1cb88814
+  metadata.gz: 9af30b133648ba77c97995f139a563fd7a49766f0b6b6ccb7950686c2dddf1e9
+  data.tar.gz: 8c29863a7d1d74733008fbf3a9fed5ad6f3f69a24e87a5fd7530ccece272cf23
 SHA512:
-  metadata.gz: a87390e2e06bd7d0bf3fab4ba0d01d0c9192cd425b16f94fdcebca0af41022fcf85c16cc8a30a987065a262c5d52a2645ccaf943c973e39a1e77eb3612df5470
-  data.tar.gz: 510cb212c879552f742247000e36b9fe91e5ff069fb9d69858b92608152f2fd47700dab3e0fee2e8bdcde0cb1824f6b2858c110c6d6333ecb90bf6a157cbdc30
+  metadata.gz: 9acd1cdfaf66c07771e1e6bde51971db0ef2c0a7b6752d1e28e5b18483c53a8ec98f08bb0b71f7e88ab54daf19fe7d85c2817b937ce3243941001d1a2977c35d
+  data.tar.gz: 2f210ee7a66db3afa0a30223847b9515fe9e53717a1a51be6e988bbf39e9f3d1f4153d899bf024621c3c5ca0d0caf70e25edb0049c23e02b6e3a708d352f02b0

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [3.39.0](https://github.com/algolia/algoliasearch-client-ruby/compare/3.38.0...3.39.0)
+
+- [d275af4e18](https://github.com/algolia/api-clients-automation/commit/d275af4e18) feat(specs): add Algolia Index as a native connector in ingestion client ([#6290](https://github.com/algolia/api-clients-automation/pull/6290)) by [@morganleroi](https://github.com/morganleroi/)
+- [74e91c1cd3](https://github.com/algolia/api-clients-automation/commit/74e91c1cd3) fix(specs): compostion run payload example for external injected items ([#6291](https://github.com/algolia/api-clients-automation/pull/6291)) by [@gavinwade12](https://github.com/gavinwade12/)
+- [a98b7f7cd8](https://github.com/algolia/api-clients-automation/commit/a98b7f7cd8) feat(specs): add feedsOrder to composition run params ([#6314](https://github.com/algolia/api-clients-automation/pull/6314)) by [@gavinwade12](https://github.com/gavinwade12/)
+
 ## [3.38.0](https://github.com/algolia/algoliasearch-client-ruby/compare/3.37.1...3.38.0)
 
 BREAKING CHANGES: this minor version includes breaking changes in the Composition API. See below for more details.

data/Gemfile.lock

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

data/lib/algolia/api/search_client.rb

@@ -2618,11 +2618,11 @@ module Algolia
       @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdatedAtResponse")
     end
 
-    # Sends multiple search requests to one or more indices.  This can be useful in these cases:  - Different indices for different purposes, such as, one index for products, another one for marketing content. - Multiple searches to the same index—for example, with different filters.  Use the helper `searchForHits` or `searchForFacets` to get the results in a more convenient format, if you already know the return type you want.
+    # Runs multiple search queries against one or more indices in a single API request.  Use cases include:  - Searching different indices, such as products and marketing content. - Run multiple queries on the same index with different parameters or filters.  If you know the expected result type, use the `searchForHits` or `searchForFacets` helper to simplify the response format.
     #
     # Required API Key ACLs:
     #   - search
-    # @param search_method_params [SearchMethodParams] Muli-search request body. Results are returned in the same order as the requests. (required)
+    # @param search_method_params [SearchMethodParams] Multi-query search request body. Results are returned in the same order as the requests. (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 search_with_http_info(search_method_params, request_options = {})
@@ -2650,11 +2650,11 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Sends multiple search requests to one or more indices.  This can be useful in these cases:  - Different indices for different purposes, such as, one index for products, another one for marketing content. - Multiple searches to the same index—for example, with different filters.  Use the helper `searchForHits` or `searchForFacets` to get the results in a more convenient format, if you already know the return type you want.
+    # Runs multiple search queries against one or more indices in a single API request.  Use cases include:  - Searching different indices, such as products and marketing content. - Run multiple queries on the same index with different parameters or filters.  If you know the expected result type, use the `searchForHits` or `searchForFacets` helper to simplify the response format.
     #
     # Required API Key ACLs:
     #   - search
-    # @param search_method_params [SearchMethodParams] Muli-search request body. Results are returned in the same order as the requests. (required)
+    # @param search_method_params [SearchMethodParams] Multi-query search request body. Results are returned in the same order as the requests. (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 [SearchResponses]
     def search(search_method_params, request_options = {})

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

@@ -7,6 +7,7 @@ require "time"
 
 module Algolia
   module Composition
+    # Contains a list of objects to inject from an external source.
     class ExternalInjectedItem
       attr_accessor :items
 

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

@@ -8,7 +8,7 @@ require "time"
 module Algolia
   module Composition
     class ExternalInjection
-      # An objectID injected into an external source.
+      # An objectID injected from an external source and also present in the targeted index.
       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.

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

@@ -53,7 +53,7 @@ module Algolia
       # Number of hits per page.
       attr_accessor :hits_per_page
 
-      # A list of extenrally injected objectID groups into from an external source.
+      # An object containing keys corresponding to the `key`s from an injection's `injectedItems` and values containing a list of hits to inject.
       attr_accessor :injected_items
 
       attr_accessor :inside_bounding_box

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

@@ -10,17 +10,22 @@ module Algolia
     class RequestBody
       attr_accessor :params
 
+      # A list of Feed IDs that specifies the order in which to order the results in the response.  The IDs should be a subset of those in the `feeds` object of the targeted `multifeed` Composition / Composition Rule, and only those specified will be processed.   The value overrides the value in the defined behavior, and when unspecified, the value defined in the behavior is used. When neither value is present, all feeds are processed.
+      attr_accessor :feeds_order
+
       # Attribute mapping from ruby-style variable name to JSON key.
       def self.attribute_map
         {
-          :params => :params
+          :params => :params,
+          :feeds_order => :feedsOrder
         }
       end
 
       # Attribute type mapping.
       def self.types_mapping
         {
-          :params => :"Params"
+          :params => :"Params",
+          :feeds_order => :"Array<String>"
         }
       end
 
@@ -57,6 +62,12 @@ module Algolia
         if attributes.key?(:params)
           self.params = attributes[:params]
         end
+
+        if attributes.key?(:feeds_order)
+          if (value = attributes[:feeds_order]).is_a?(Array)
+            self.feeds_order = value
+          end
+        end
       end
 
       # Checks equality by comparing each attribute.
@@ -64,7 +75,8 @@ module Algolia
       def ==(other)
         return true if self.equal?(other)
         self.class == other.class &&
-          params == other.params
+          params == other.params &&
+          feeds_order == other.feeds_order
       end
 
       # @see the `==` method
@@ -76,7 +88,7 @@ module Algolia
       # Calculates hash code according to all attributes.
       # @return [Integer] Hash code
       def hash
-        [params].hash
+        [params, feeds_order].hash
       end
 
       # Builds the object from hash

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

@@ -0,0 +1,227 @@
+# 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
+    # Specific configuration attributes of an `algoliaIndex` source.
+    class SourceAlgoliaIndex
+      # Name of the Algolia index to read records from.
+      attr_accessor :index_name
+
+      # SQL-like filter expression applied while browsing the source index. See [filters](https://www.algolia.com/doc/api-reference/api-parameters/filters/).
+      attr_accessor :filters
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :index_name => :indexName,
+          :filters => :filters
+        }
+      end
+
+      # Returns the keys that uniquely identify this oneOf variant when present
+      def self.discriminator_attributes
+        [
+          :indexName
+        ]
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :index_name => :"String",
+          :filters => :"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::SourceAlgoliaIndex` 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::SourceAlgoliaIndex`. 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
+
+        if attributes.key?(:filters)
+          self.filters = attributes[:filters]
+        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 &&
+          filters == other.filters
+      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, filters].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/source_input.rb

@@ -12,6 +12,7 @@ module Algolia
       # List of class defined in oneOf (OpenAPI v3)
         def openapi_one_of
           [
+            :"SourceAlgoliaIndex",
             :"SourceBigCommerce",
             :"SourceBigQuery",
             :"SourceCSV",

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

@@ -8,6 +8,7 @@ require "time"
 module Algolia
   module Ingestion
     class SourceType
+      ALGOLIA_INDEX = "algoliaIndex".freeze
       BIGCOMMERCE = "bigcommerce".freeze
       BIGQUERY = "bigquery".freeze
       COMMERCETOOLS = "commercetools".freeze
@@ -19,7 +20,18 @@ module Algolia
       PUSH = "push".freeze
 
       def self.all_vars
-        @all_vars ||= [BIGCOMMERCE, BIGQUERY, COMMERCETOOLS, CSV, DOCKER, GA4_BIGQUERY_EXPORT, JSON, SHOPIFY, PUSH].freeze
+        @all_vars ||= [
+          ALGOLIA_INDEX,
+          BIGCOMMERCE,
+          BIGQUERY,
+          COMMERCETOOLS,
+          CSV,
+          DOCKER,
+          GA4_BIGQUERY_EXPORT,
+          JSON,
+          SHOPIFY,
+          PUSH
+        ].freeze
       end
 
       # Builds the enum from string

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

@@ -0,0 +1,218 @@
+# 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
+    # Specific configuration attributes of an `algoliaIndex` source.
+    class SourceUpdateAlgoliaIndex
+      # Name of the Algolia index to read records from.
+      attr_accessor :index_name
+
+      # SQL-like filter expression applied while browsing the source index. See [filters](https://www.algolia.com/doc/api-reference/api-parameters/filters/).
+      attr_accessor :filters
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :index_name => :indexName,
+          :filters => :filters
+        }
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :index_name => :"String",
+          :filters => :"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::SourceUpdateAlgoliaIndex` 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::SourceUpdateAlgoliaIndex`. 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]
+        end
+
+        if attributes.key?(:filters)
+          self.filters = attributes[:filters]
+        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 &&
+          filters == other.filters
+      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, filters].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/source_update_input.rb

@@ -16,6 +16,7 @@ module Algolia
             :"SourceCSV",
             :"SourceGA4BigQueryExport",
             :"SourceJSON",
+            :"SourceUpdateAlgoliaIndex",
             :"SourceUpdateCommercetools",
             :"SourceUpdateDocker",
             :"SourceUpdateShopify"

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.38.0"
+  VERSION = "3.39.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: algolia
 version: !ruby/object:Gem::Version
-  version: 3.38.0
+  version: 3.39.0
 platform: ruby
 authors:
 - https://alg.li/support
@@ -465,6 +465,7 @@ files:
 - lib/algolia/models/ingestion/shopify_market.rb
 - lib/algolia/models/ingestion/shopify_metafield.rb
 - lib/algolia/models/ingestion/source.rb
+- lib/algolia/models/ingestion/source_algolia_index.rb
 - lib/algolia/models/ingestion/source_big_commerce.rb
 - lib/algolia/models/ingestion/source_big_query.rb
 - lib/algolia/models/ingestion/source_commercetools.rb
@@ -480,6 +481,7 @@ files:
 - lib/algolia/models/ingestion/source_sort_keys.rb
 - lib/algolia/models/ingestion/source_type.rb
 - lib/algolia/models/ingestion/source_update.rb
+- lib/algolia/models/ingestion/source_update_algolia_index.rb
 - lib/algolia/models/ingestion/source_update_commercetools.rb
 - lib/algolia/models/ingestion/source_update_docker.rb
 - lib/algolia/models/ingestion/source_update_input.rb