algolia 3.7.1 → 3.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52c757fd33261a345c28764b6415188abafbd782d8adaed5ffc7a284291519fa
-  data.tar.gz: e05a6ed2689c8509aef0dcf62318d79ae6a47d4dd35192316f0cc496b3c4c544
+  metadata.gz: 78f8f133aabc7a4e26ef0d03cec1bf249668e8ca3f2262dfe3651f2cc3a03f3d
+  data.tar.gz: 4cf06a16860371429af9a5135b491c294ba68f9e162a7b5418fd03eca409bc3d
 SHA512:
-  metadata.gz: 2c710af9d2873404f720049a4572536d259a09a5416785247e50911b53689542a755af34d6a93d2d44cb8378e2f243a2496702d97d122d010f91e6d3571d6254
-  data.tar.gz: '09f66bd5a9aac13e16d2fbc812afef3b1b9de0c25ff692921a84a0888c6e74479225a100ad7d90506119e810680e2f812a77aca62a9f7dfe9241559c85dbaea2'
+  metadata.gz: 2012ce78d9c053ee7512de20223f274522b38986bf2064278aa00b157ba220a5339cd1a9bdb7e5c80d5ed14df80757fce5b2f312ff22492cece79309a3178fbd
+  data.tar.gz: 9a626f040e6ee439bcaad40d61e1dc8cf4455f536edc06986cbcafcb3d5ca85dda8efed0ac8fc0e9cdea82f81a64cca51004577aa78340953702ae4792799d84

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [3.8.0](https://github.com/algolia/algoliasearch-client-ruby/compare/3.7.1...3.8.0)
+
+- [4c73f4c9a](https://github.com/algolia/api-clients-automation/commit/4c73f4c9a) feat(specs): add estimate path and responses ([#4057](https://github.com/algolia/api-clients-automation/pull/4057)) by [@cdhawke](https://github.com/cdhawke/)
+- [39ad05495](https://github.com/algolia/api-clients-automation/commit/39ad05495) feat(specs): update estimate response type ([#4101](https://github.com/algolia/api-clients-automation/pull/4101)) by [@cdhawke](https://github.com/cdhawke/)
+
 ## [3.7.1](https://github.com/algolia/algoliasearch-client-ruby/compare/3.7.0...3.7.1)
 
 - [801241e12](https://github.com/algolia/api-clients-automation/commit/801241e12) fix(specs): add secrets payload for updates ([#4061](https://github.com/algolia/api-clients-automation/pull/4061)) by [@shortcuts](https://github.com/shortcuts/)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    algolia (3.7.1)
+    algolia (3.8.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

@@ -319,6 +319,50 @@ module Algolia
       @api_client.deserialize(response.body, request_options[:debug_return_type] || "Abtesting::ABTestResponse")
     end
 
+    # Given the traffic percentage and the expected effect size, this endpoint estimates the sample size and duration of an A/B test based on historical traffic.
+    #
+    # Required API Key ACLs:
+    #   - analytics
+    # @param estimate_ab_test_request [EstimateABTestRequest]  (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 estimate_ab_test_with_http_info(estimate_ab_test_request, request_options = {})
+      # verify the required parameter 'estimate_ab_test_request' is set
+      if @api_client.config.client_side_validation && estimate_ab_test_request.nil?
+        raise ArgumentError, "Parameter `estimate_ab_test_request` is required when calling `estimate_ab_test`."
+      end
+
+      path = "/2/abtests/estimate"
+      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(estimate_ab_test_request)
+
+      new_options = request_options.merge(
+        :operation => :"AbtestingClient.estimate_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
+
+    # Given the traffic percentage and the expected effect size, this endpoint estimates the sample size and duration of an A/B test based on historical traffic.
+    #
+    # Required API Key ACLs:
+    #   - analytics
+    # @param estimate_ab_test_request [EstimateABTestRequest]  (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 [EstimateABTestResponse]
+    def estimate_ab_test(estimate_ab_test_request, request_options = {})
+      response = estimate_ab_test_with_http_info(estimate_ab_test_request, request_options)
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Abtesting::EstimateABTestResponse")
+    end
+
     # Retrieves the details for an A/B test by its ID.
     #
     # Required API Key ACLs:

data/lib/algolia/models/abtesting/{effect.rb → effect_metric.rb}

@@ -5,7 +5,7 @@ require "time"
 
 module Algolia
   module Abtesting
-    class Effect
+    class EffectMetric
       ADD_TO_CART_RATE = "addToCartRate".freeze
       CLICK_THROUGH_RATE = "clickThroughRate".freeze
       CONVERSION_RATE = "conversionRate".freeze
@@ -26,8 +26,8 @@ module Algolia
       # @param [String] The enum value in the form of the string
       # @return [String] The enum value
       def build_from_hash(value)
-        return value if Effect.all_vars.include?(value)
-        raise "Invalid ENUM value #{value} for class #Effect"
+        return value if EffectMetric.all_vars.include?(value)
+        raise "Invalid ENUM value #{value} for class #EffectMetric"
       end
     end
   end

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

@@ -0,0 +1,227 @@
+# 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 EstimateABTestRequest
+      attr_accessor :configuration
+
+      # A/B test variants.
+      attr_accessor :variants
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :configuration => :configuration,
+          :variants => :variants
+        }
+      end
+
+      # Returns all the JSON keys this model knows about
+      def self.acceptable_attributes
+        attribute_map.values
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :configuration => :"EstimateConfiguration",
+          :variants => :"Array<AddABTestsVariant>"
+        }
+      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::EstimateABTestRequest` 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::EstimateABTestRequest`. 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?(:configuration)
+          self.configuration = attributes[:configuration]
+        else
+          self.configuration = nil
+        end
+
+        if attributes.key?(:variants)
+          if (value = attributes[:variants]).is_a?(Array)
+            self.variants = value
+          end
+        else
+          self.variants = nil
+        end
+      end
+
+      # Checks equality by comparing each attribute.
+      # @param [Object] Object to be compared
+      def ==(other)
+        return true if self.equal?(other)
+        self.class == other.class &&
+          configuration == other.configuration &&
+          variants == other.variants
+      end
+
+      # @see the `==` method
+      # @param [Object] Object to be compared
+      def eql?(other)
+        self == other
+      end
+
+      # Calculates hash code according to all attributes.
+      # @return [Integer] Hash code
+      def hash
+        [configuration, variants].hash
+      end
+
+      # Builds the object from hash
+      # @param [Hash] attributes Model attributes in the form of hash
+      # @return [Object] Returns the model itself
+      def self.build_from_hash(attributes)
+        return nil unless attributes.is_a?(Hash)
+        attributes = attributes.transform_keys(&:to_sym)
+        transformed_hash = {}
+        types_mapping.each_pair do |key, type|
+          if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+            transformed_hash[key.to_sym] = nil
+          elsif type =~ /\AArray<(.*)>/i
+            # check to ensure the input is an array given that the attribute
+            # is documented as an array but the input is not
+            if attributes[attribute_map[key]].is_a?(Array)
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v|
+                _deserialize(::Regexp.last_match(1), v)
+              }
+            end
+          elsif !attributes[attribute_map[key]].nil?
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
+          end
+        end
+
+        new(transformed_hash)
+      end
+
+      # Deserializes the data based on type
+      # @param string type Data type
+      # @param string value Value to be deserialized
+      # @return [Object] Deserialized data
+      def self._deserialize(type, value)
+        case type.to_sym
+        when :Time
+          Time.parse(value)
+        when :Date
+          Date.parse(value)
+        when :String
+          value.to_s
+        when :Integer
+          value.to_i
+        when :Float
+          value.to_f
+        when :Boolean
+          if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+            true
+          else
+            false
+          end
+
+        when :Object
+          # generic object (usually a Hash), return directly
+          value
+        when /\AArray<(?<inner_type>.+)>\z/
+          inner_type = Regexp.last_match[:inner_type]
+          value.map { |v| _deserialize(inner_type, v) }
+        when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+          k_type = Regexp.last_match[:k_type]
+          v_type = Regexp.last_match[:v_type]
+          {}.tap do |hash|
+            value.each do |k, v|
+              hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+            end
+          end
+          # model
+        else
+          # models (e.g. Pet) or oneOf
+          klass = Algolia::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/estimate_ab_test_response.rb

@@ -0,0 +1,224 @@
+# 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 EstimateABTestResponse
+      # Estimated number of days needed to reach the sample sizes required for detecting the configured effect. This value is based on historical traffic.
+      attr_accessor :duration_days
+
+      # Sample size estimates for each variant. The first element is the control variant. Each element is the estimated number of searches required to achieve the desired statistical significance.
+      attr_accessor :sample_sizes
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :duration_days => :durationDays,
+          :sample_sizes => :sampleSizes
+        }
+      end
+
+      # Returns all the JSON keys this model knows about
+      def self.acceptable_attributes
+        attribute_map.values
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :duration_days => :"Integer",
+          :sample_sizes => :"Array<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::EstimateABTestResponse` 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::EstimateABTestResponse`. 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?(:duration_days)
+          self.duration_days = attributes[:duration_days]
+        end
+
+        if attributes.key?(:sample_sizes)
+          if (value = attributes[:sample_sizes]).is_a?(Array)
+            self.sample_sizes = 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 &&
+          duration_days == other.duration_days &&
+          sample_sizes == other.sample_sizes
+      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
+        [duration_days, sample_sizes].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/estimate_configuration.rb

@@ -0,0 +1,232 @@
+# 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
+    # A/B test configuration for estimating the sample size and duration using minimum detectable effect.
+    class EstimateConfiguration
+      attr_accessor :outliers
+
+      attr_accessor :empty_search
+
+      attr_accessor :minimum_detectable_effect
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :outliers => :outliers,
+          :empty_search => :emptySearch,
+          :minimum_detectable_effect => :minimumDetectableEffect
+        }
+      end
+
+      # Returns all the JSON keys this model knows about
+      def self.acceptable_attributes
+        attribute_map.values
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :outliers => :"Outliers",
+          :empty_search => :"EmptySearch",
+          :minimum_detectable_effect => :"MinimumDetectableEffect"
+        }
+      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::EstimateConfiguration` 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::EstimateConfiguration`. 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?(:outliers)
+          self.outliers = attributes[:outliers]
+        end
+
+        if attributes.key?(:empty_search)
+          self.empty_search = attributes[:empty_search]
+        end
+
+        if attributes.key?(:minimum_detectable_effect)
+          self.minimum_detectable_effect = attributes[:minimum_detectable_effect]
+        else
+          self.minimum_detectable_effect = 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 &&
+          outliers == other.outliers &&
+          empty_search == other.empty_search &&
+          minimum_detectable_effect == other.minimum_detectable_effect
+      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
+        [outliers, empty_search, minimum_detectable_effect].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/minimum_detectable_effect.rb

@@ -10,13 +10,13 @@ module Algolia
       # Smallest difference in an observable metric between variants. For example, to detect a 10% difference between variants, set this value to 0.1.
       attr_accessor :size
 
-      attr_accessor :effect
+      attr_accessor :metric
 
       # Attribute mapping from ruby-style variable name to JSON key.
       def self.attribute_map
         {
           :size => :size,
-          :effect => :effect
+          :metric => :metric
         }
       end
 
@@ -29,7 +29,7 @@ module Algolia
       def self.types_mapping
         {
           :size => :"Float",
-          :effect => :"Effect"
+          :metric => :"EffectMetric"
         }
       end
 
@@ -65,10 +65,14 @@ module Algolia
 
         if attributes.key?(:size)
           self.size = attributes[:size]
+        else
+          self.size = nil
         end
 
-        if attributes.key?(:effect)
-          self.effect = attributes[:effect]
+        if attributes.key?(:metric)
+          self.metric = attributes[:metric]
+        else
+          self.metric = nil
         end
       end
 
@@ -78,7 +82,7 @@ module Algolia
         return true if self.equal?(other)
         self.class == other.class &&
           size == other.size &&
-          effect == other.effect
+          metric == other.metric
       end
 
       # @see the `==` method
@@ -90,7 +94,7 @@ module Algolia
       # Calculates hash code according to all attributes.
       # @return [Integer] Hash code
       def hash
-        [size, effect].hash
+        [size, metric].hash
       end
 
       # Builds the object from hash

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

@@ -159,8 +159,6 @@ module Algolia
 
         if attributes.key?(:action)
           self.action = attributes[:action]
-        else
-          self.action = nil
         end
 
         if attributes.key?(:cursor)

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

@@ -143,8 +143,6 @@ module Algolia
 
         if attributes.key?(:action)
           self.action = attributes[:action]
-        else
-          self.action = nil
         end
 
         if attributes.key?(:cursor)

data/lib/algolia/version.rb

@@ -1,5 +1,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.7.1".freeze
+  VERSION = "3.8.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algolia
 version: !ruby/object:Gem::Version
-  version: 3.7.1
+  version: 3.8.0
 platform: ruby
 authors:
 - https://alg.li/support
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-11-06 00:00:00.000000000 Z
+date: 2024-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -154,10 +154,13 @@ files:
 - lib/algolia/models/abtesting/add_ab_tests_request.rb
 - lib/algolia/models/abtesting/add_ab_tests_variant.rb
 - lib/algolia/models/abtesting/currency.rb
-- lib/algolia/models/abtesting/effect.rb
+- lib/algolia/models/abtesting/effect_metric.rb
 - lib/algolia/models/abtesting/empty_search.rb
 - lib/algolia/models/abtesting/empty_search_filter.rb
 - lib/algolia/models/abtesting/error_base.rb
+- lib/algolia/models/abtesting/estimate_ab_test_request.rb
+- lib/algolia/models/abtesting/estimate_ab_test_response.rb
+- lib/algolia/models/abtesting/estimate_configuration.rb
 - lib/algolia/models/abtesting/filter_effects.rb
 - lib/algolia/models/abtesting/list_ab_tests_response.rb
 - lib/algolia/models/abtesting/minimum_detectable_effect.rb