algolia 3.30.0 → 3.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 698d0bf438f61272bc29420b92a6e6d3d7284810c99a915d58b7b28e6ef64061
-  data.tar.gz: a59ba07ae58c007bbf2c832b400cce0cca4e89fa3cdf9f80965d1b4eb93e3ddb
+  metadata.gz: 7fc0efa08965447a7c2772b827b9c01532be62407efce5e13c39abb5653f6df1
+  data.tar.gz: 724d31363790d71616659594e61b685dd97da85e593ffc47a222bc6d8322fedf
 SHA512:
-  metadata.gz: d196cc67966b88bd8ea0de06a9d4b4a8ebb54722d1716fd421de078eb64c8410475dc32fbaf67b1c50ae402e94923f59d15cdfd84fcc8e9c079283c06b81dfa9
-  data.tar.gz: 37fba20279d136c60e354072e8ecd05e2e079f9253579eba8b054b5feff8e3bd10722583aa888e0a49842a8cfa8354a53f13588dd78433524a7f5c6f16e199a3
+  metadata.gz: 914312d094561990bcc25ebe70c5c49cf9db7b86526074d6f145856c38b9b3eb141acb8b7af10f256341a9b0790e9be0604ea9b314984f5258d628f2adb060a3
+  data.tar.gz: ab97ed1e6fe928b454895d54b7401e144f9d142d760c18ad2af54d515f4a26491b866efb02eebabefbac2efbff75db01790a41fc365f37aae9a55b2afdcd07b0

data/.github/workflows/release.yml

@@ -24,6 +24,6 @@ jobs:
           ruby-version: 3.4.7
           bundler-cache: true
 
-      - uses: rubygems/release-gem@9fc8c0f9a461e67716cde28f188b9a5c029333a8
+      - uses: rubygems/release-gem@1c162a739e8b4cb21a676e97b087e8268d8fc40b
         with:
           await-release: false

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [3.31.0](https://github.com/algolia/algoliasearch-client-ruby/compare/3.30.0...3.31.0)
+
+- [ecfea56dc](https://github.com/algolia/api-clients-automation/commit/ecfea56dc) feat(clients): remove schedule capabilities ([#5552](https://github.com/algolia/api-clients-automation/pull/5552)) by [@cdhawke](https://github.com/cdhawke/)
+- [391059ed9](https://github.com/algolia/api-clients-automation/commit/391059ed9) chore(deps): dependencies 2025-11-03 ([#5553](https://github.com/algolia/api-clients-automation/pull/5553)) by [@algolia-bot](https://github.com/algolia-bot/)
+- [ff4b8f02c](https://github.com/algolia/api-clients-automation/commit/ff4b8f02c) feat(specs): add fallbackParameters to Frequently bought together [RECO-2443] ([#5579](https://github.com/algolia/api-clients-automation/pull/5579)) by [@raed667](https://github.com/raed667/)
+
 ## [3.30.0](https://github.com/algolia/algoliasearch-client-ruby/compare/3.29.0...3.30.0)
 
 - [d9b21b4b1](https://github.com/algolia/api-clients-automation/commit/d9b21b4b1) feat(specs): add `renderingContent` query parameter in Composition API main injection ([#5549](https://github.com/algolia/api-clients-automation/pull/5549)) by [@ClaraMuller](https://github.com/ClaraMuller/)

data/Gemfile.lock

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

data/lib/algolia/api/abtesting_client.rb

@@ -476,50 +476,6 @@ module Algolia
       @api_client.deserialize(response.body, request_options[:debug_return_type] || "Abtesting::ListABTestsResponse")
     end
 
-    # Schedule an A/B test to be started at a later time.
-    #
-    # Required API Key ACLs:
-    #   - editSettings
-    # @param schedule_ab_tests_request [ScheduleABTestsRequest]  (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 schedule_ab_test_with_http_info(schedule_ab_tests_request, request_options = {})
-      # verify the required parameter 'schedule_ab_tests_request' is set
-      if @api_client.config.client_side_validation && schedule_ab_tests_request.nil?
-        raise ArgumentError, "Parameter `schedule_ab_tests_request` is required when calling `schedule_ab_test`."
-      end
-
-      path = "/2/abtests/schedule"
-      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(schedule_ab_tests_request)
-
-      new_options = request_options.merge(
-        :operation => :"AbtestingClient.schedule_ab_test",
-        :header_params => header_params,
-        :query_params => query_params,
-        :body => post_body,
-        :use_read_transporter => false
-      )
-
-      @api_client.call_api(:POST, path, new_options)
-    end
-
-    # Schedule an A/B test to be started at a later time.
-    #
-    # Required API Key ACLs:
-    #   - editSettings
-    # @param schedule_ab_tests_request [ScheduleABTestsRequest]  (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 [ScheduleABTestResponse]
-    def schedule_ab_test(schedule_ab_tests_request, request_options = {})
-      response = schedule_ab_test_with_http_info(schedule_ab_tests_request, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Abtesting::ScheduleABTestResponse")
-    end
-
     # Stops an A/B test by its ID.  You can't restart stopped A/B tests.
     #
     # Required API Key ACLs:

data/lib/algolia/api/abtesting_v3_client.rb

@@ -543,53 +543,6 @@ module Algolia
       @api_client.deserialize(response.body, request_options[:debug_return_type] || "AbtestingV3::ListABTestsResponse")
     end
 
-    # Schedule an A/B test to be started at a later time.
-    #
-    # Required API Key ACLs:
-    #   - editSettings
-    # @param schedule_ab_tests_request [ScheduleABTestsRequest]  (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 schedule_ab_test_with_http_info(schedule_ab_tests_request, request_options = {})
-      # verify the required parameter 'schedule_ab_tests_request' is set
-      if @api_client.config.client_side_validation && schedule_ab_tests_request.nil?
-        raise ArgumentError, "Parameter `schedule_ab_tests_request` is required when calling `schedule_ab_test`."
-      end
-
-      path = "/3/abtests/schedule"
-      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(schedule_ab_tests_request)
-
-      new_options = request_options.merge(
-        :operation => :"AbtestingV3Client.schedule_ab_test",
-        :header_params => header_params,
-        :query_params => query_params,
-        :body => post_body,
-        :use_read_transporter => false
-      )
-
-      @api_client.call_api(:POST, path, new_options)
-    end
-
-    # Schedule an A/B test to be started at a later time.
-    #
-    # Required API Key ACLs:
-    #   - editSettings
-    # @param schedule_ab_tests_request [ScheduleABTestsRequest]  (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 [ScheduleABTestResponse]
-    def schedule_ab_test(schedule_ab_tests_request, request_options = {})
-      response = schedule_ab_test_with_http_info(schedule_ab_tests_request, request_options)
-      @api_client.deserialize(
-        response.body,
-        request_options[:debug_return_type] || "AbtestingV3::ScheduleABTestResponse"
-      )
-    end
-
     # Stops an A/B test by its ID.  You can't restart stopped A/B tests.
     #
     # Required API Key ACLs:

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

@@ -24,6 +24,8 @@ module Algolia
       # Unique record identifier.
       attr_accessor :algolia_object_id
 
+      attr_accessor :fallback_parameters
+
       # Attribute mapping from ruby-style variable name to JSON key.
       def self.attribute_map
         {
@@ -32,7 +34,8 @@ module Algolia
           :max_recommendations => :maxRecommendations,
           :query_parameters => :queryParameters,
           :model => :model,
-          :algolia_object_id => :objectID
+          :algolia_object_id => :objectID,
+          :fallback_parameters => :fallbackParameters
         }
       end
 
@@ -44,7 +47,8 @@ module Algolia
           :max_recommendations => :"Integer",
           :query_parameters => :"RecommendSearchParams",
           :model => :"FbtModel",
-          :algolia_object_id => :"String"
+          :algolia_object_id => :"String",
+          :fallback_parameters => :"FallbackParams"
         }
       end
 
@@ -117,6 +121,10 @@ module Algolia
         else
           self.algolia_object_id = nil
         end
+
+        if attributes.key?(:fallback_parameters)
+          self.fallback_parameters = attributes[:fallback_parameters]
+        end
       end
 
       # Checks equality by comparing each attribute.
@@ -129,7 +137,8 @@ module Algolia
           max_recommendations == other.max_recommendations &&
           query_parameters == other.query_parameters &&
           model == other.model &&
-          algolia_object_id == other.algolia_object_id
+          algolia_object_id == other.algolia_object_id &&
+          fallback_parameters == other.fallback_parameters
       end
 
       # @see the `==` method
@@ -141,7 +150,7 @@ module Algolia
       # Calculates hash code according to all attributes.
       # @return [Integer] Hash code
       def hash
-        [index_name, threshold, max_recommendations, query_parameters, model, algolia_object_id].hash
+        [index_name, threshold, max_recommendations, query_parameters, model, algolia_object_id, fallback_parameters].hash
       end
 
       # Builds the object from hash

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.30.0"
+  VERSION = "3.31.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: algolia
 version: !ruby/object:Gem::Version
-  version: 3.30.0
+  version: 3.31.0
 platform: ruby
 authors:
 - https://alg.li/support
@@ -171,8 +171,6 @@ files:
 - lib/algolia/models/abtesting-v3/metrics_filter.rb
 - lib/algolia/models/abtesting-v3/minimum_detectable_effect.rb
 - lib/algolia/models/abtesting-v3/outliers_filter.rb
-- lib/algolia/models/abtesting-v3/schedule_ab_test_response.rb
-- lib/algolia/models/abtesting-v3/schedule_ab_tests_request.rb
 - lib/algolia/models/abtesting-v3/status.rb
 - lib/algolia/models/abtesting-v3/timeseries.rb
 - lib/algolia/models/abtesting-v3/timeseries_variant.rb
@@ -198,8 +196,6 @@ files:
 - lib/algolia/models/abtesting/minimum_detectable_effect.rb
 - lib/algolia/models/abtesting/outliers.rb
 - lib/algolia/models/abtesting/outliers_filter.rb
-- lib/algolia/models/abtesting/schedule_ab_test_response.rb
-- lib/algolia/models/abtesting/schedule_ab_tests_request.rb
 - lib/algolia/models/abtesting/status.rb
 - lib/algolia/models/abtesting/variant.rb
 - lib/algolia/models/analytics/click_position.rb

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

@@ -1,209 +0,0 @@
-# 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 Abtesting
-    class ScheduleABTestResponse
-      # Unique scheduled A/B test identifier.
-      attr_accessor :ab_test_schedule_id
-
-      # Attribute mapping from ruby-style variable name to JSON key.
-      def self.attribute_map
-        {
-          :ab_test_schedule_id => :abTestScheduleID
-        }
-      end
-
-      # Attribute type mapping.
-      def self.types_mapping
-        {
-          :ab_test_schedule_id => :"Integer"
-        }
-      end
-
-      # List of attributes with nullable: true
-      def self.openapi_nullable
-        Set.new(
-          []
-        )
-      end
-
-      # Initializes the object
-      # @param [Hash] attributes Model attributes in the form of hash
-      def initialize(attributes = {})
-        if (!attributes.is_a?(Hash))
-          raise(
-            ArgumentError,
-            "The input argument (attributes) must be a hash in `Algolia::ScheduleABTestResponse` 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::ScheduleABTestResponse`. 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?(:ab_test_schedule_id)
-          self.ab_test_schedule_id = attributes[:ab_test_schedule_id]
-        else
-          self.ab_test_schedule_id = 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 &&
-          ab_test_schedule_id == other.ab_test_schedule_id
-      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
-        [ab_test_schedule_id].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::Abtesting.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/abtesting/schedule_ab_tests_request.rb

@@ -1,247 +0,0 @@
-# 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 Abtesting
-    class ScheduleABTestsRequest
-      # A/B test name.
-      attr_accessor :name
-
-      # A/B test variants.
-      attr_accessor :variants
-
-      # Date and time when the A/B test is scheduled to start, in RFC 3339 format.
-      attr_accessor :scheduled_at
-
-      # End date and time of the A/B test, in RFC 3339 format.
-      attr_accessor :end_at
-
-      # Attribute mapping from ruby-style variable name to JSON key.
-      def self.attribute_map
-        {
-          :name => :name,
-          :variants => :variants,
-          :scheduled_at => :scheduledAt,
-          :end_at => :endAt
-        }
-      end
-
-      # Attribute type mapping.
-      def self.types_mapping
-        {
-          :name => :"String",
-          :variants => :"Array<AddABTestsVariant>",
-          :scheduled_at => :"String",
-          :end_at => :"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::ScheduleABTestsRequest` 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::ScheduleABTestsRequest`. 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?(:name)
-          self.name = attributes[:name]
-        else
-          self.name = nil
-        end
-
-        if attributes.key?(:variants)
-          if (value = attributes[:variants]).is_a?(Array)
-            self.variants = value
-          end
-        else
-          self.variants = nil
-        end
-
-        if attributes.key?(:scheduled_at)
-          self.scheduled_at = attributes[:scheduled_at]
-        else
-          self.scheduled_at = nil
-        end
-
-        if attributes.key?(:end_at)
-          self.end_at = attributes[:end_at]
-        else
-          self.end_at = 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 &&
-          name == other.name &&
-          variants == other.variants &&
-          scheduled_at == other.scheduled_at &&
-          end_at == other.end_at
-      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
-        [name, variants, scheduled_at, end_at].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::Abtesting.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/abtesting-v3/schedule_ab_test_response.rb

@@ -1,209 +0,0 @@
-# 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 AbtestingV3
-    class ScheduleABTestResponse
-      # Unique scheduled A/B test identifier.
-      attr_accessor :ab_test_schedule_id
-
-      # Attribute mapping from ruby-style variable name to JSON key.
-      def self.attribute_map
-        {
-          :ab_test_schedule_id => :abTestScheduleID
-        }
-      end
-
-      # Attribute type mapping.
-      def self.types_mapping
-        {
-          :ab_test_schedule_id => :"Integer"
-        }
-      end
-
-      # List of attributes with nullable: true
-      def self.openapi_nullable
-        Set.new(
-          []
-        )
-      end
-
-      # Initializes the object
-      # @param [Hash] attributes Model attributes in the form of hash
-      def initialize(attributes = {})
-        if (!attributes.is_a?(Hash))
-          raise(
-            ArgumentError,
-            "The input argument (attributes) must be a hash in `Algolia::ScheduleABTestResponse` 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::ScheduleABTestResponse`. 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?(:ab_test_schedule_id)
-          self.ab_test_schedule_id = attributes[:ab_test_schedule_id]
-        else
-          self.ab_test_schedule_id = 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 &&
-          ab_test_schedule_id == other.ab_test_schedule_id
-      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
-        [ab_test_schedule_id].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::AbtestingV3.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/abtesting-v3/schedule_ab_tests_request.rb

@@ -1,270 +0,0 @@
-# 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 AbtestingV3
-    class ScheduleABTestsRequest
-      # A/B test name.
-      attr_accessor :name
-
-      # A/B test variants.
-      attr_accessor :variants
-
-      # A/B test metrics involved in the test. Only these metrics will be considered when calculating results.
-      attr_accessor :metrics
-
-      attr_accessor :configuration
-
-      # Date and time when the A/B test is scheduled to start, in RFC 3339 format.
-      attr_accessor :scheduled_at
-
-      # End date and time of the A/B test, in RFC 3339 format.
-      attr_accessor :end_at
-
-      # Attribute mapping from ruby-style variable name to JSON key.
-      def self.attribute_map
-        {
-          :name => :name,
-          :variants => :variants,
-          :metrics => :metrics,
-          :configuration => :configuration,
-          :scheduled_at => :scheduledAt,
-          :end_at => :endAt
-        }
-      end
-
-      # Attribute type mapping.
-      def self.types_mapping
-        {
-          :name => :"String",
-          :variants => :"Array<AddABTestsVariant>",
-          :metrics => :"Array<CreateMetric>",
-          :configuration => :"ABTestConfiguration",
-          :scheduled_at => :"String",
-          :end_at => :"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::ScheduleABTestsRequest` 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::ScheduleABTestsRequest`. 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?(:name)
-          self.name = attributes[:name]
-        else
-          self.name = nil
-        end
-
-        if attributes.key?(:variants)
-          if (value = attributes[:variants]).is_a?(Array)
-            self.variants = value
-          end
-        else
-          self.variants = nil
-        end
-
-        if attributes.key?(:metrics)
-          if (value = attributes[:metrics]).is_a?(Array)
-            self.metrics = value
-          end
-        else
-          self.metrics = nil
-        end
-
-        if attributes.key?(:configuration)
-          self.configuration = attributes[:configuration]
-        end
-
-        if attributes.key?(:scheduled_at)
-          self.scheduled_at = attributes[:scheduled_at]
-        else
-          self.scheduled_at = nil
-        end
-
-        if attributes.key?(:end_at)
-          self.end_at = attributes[:end_at]
-        else
-          self.end_at = 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 &&
-          name == other.name &&
-          variants == other.variants &&
-          metrics == other.metrics &&
-          configuration == other.configuration &&
-          scheduled_at == other.scheduled_at &&
-          end_at == other.end_at
-      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
-        [name, variants, metrics, configuration, scheduled_at, end_at].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::AbtestingV3.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