algolia 3.42.3 → 3.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7ee727296f4ef0f5097f1e9a17f8b76e0a2e04303aeaaa1b84a78a8cc3e899e
-  data.tar.gz: 340f56004e8c495e8585bf43dc0b5a8cf36208c69b239b3d029e7b6b9428e8b7
+  metadata.gz: 26e15a7a80471a7a68cf607c70e21c52f1a0f5d12b3a93888d3865f5bc02a257
+  data.tar.gz: 0c45427919aef09a76d67b2320ad80908268fb5e9d96a6e9f1510c25b8fab6bf
 SHA512:
-  metadata.gz: 0c50e49997bdfb4101478f6800ce76397c73d51e7755a1c7c425e6c6565d7c4435c04d792707fbee1c1cc3efc7a7cc8ef2fea740312d579651338c4cac953563
-  data.tar.gz: 2d38395ca0ec5f708b0ba6a3210ff2c60d988829aac5cf80b8de2e767f408722932c899e86902555df17d064569612d9bf86ed5f115f9ee4f6bdff3c1b8a6821
+  metadata.gz: 8f2f198904f5afb8bc656d3d6f4eadfb37330db685656144c978443b0614aa5faf64718124200fcde6d19234b18e48aa960b173ab9e5222cb04ccc7d1dd2fed7
+  data.tar.gz: a4971f5c0ffc4fbddba53281df8763082e659a39f67cb53ffc1b5f76898b8269f4e544575727742d8e048ae4dea79d1b2cfc60639550a38d74203d94572099b9

data/.github/workflows/do-not-edit-this-repository.yml

@@ -14,7 +14,7 @@ jobs:
     name: Close PR
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Close PR
         env:

data/.github/workflows/issue.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Create ticket
-        uses: actions/github-script@v9
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
           script: |
             const action = context.payload.action;

data/.github/workflows/release.yml

@@ -16,14 +16,14 @@ jobs:
       id-token: write
       contents: write
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Install Ruby
-        uses: ruby/setup-ruby@v1
+        uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
         with:
-          ruby-version: 4.0.5
+          ruby-version: 4.0.6
           bundler-cache: true
 
-      - uses: rubygems/release-gem@e9a6361a0b14562539327c2a02373edc56dd3169
+      - uses: rubygems/release-gem@052cc82692552de3ef2b81fd670e41d13cba8092 # v1.4.0
         with:
           await-release: false

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [3.43.0](https://github.com/algolia/algoliasearch-client-ruby/compare/3.42.3...3.43.0)
+
+- [3bee6d1dee](https://github.com/algolia/api-clients-automation/commit/3bee6d1dee) chore(ci): pin all GitHub Action refs to commit SHAs (API-475) ([#6819](https://github.com/algolia/api-clients-automation/pull/6819)) by [@MarioAlexandruDan](https://github.com/MarioAlexandruDan/)
+- [22af756864](https://github.com/algolia/api-clients-automation/commit/22af756864) chore(deps): dependencies 2026-07-20 ([#6733](https://github.com/algolia/api-clients-automation/pull/6733)) by [@algolia-api-clients-automation-bot[bot]](https://github.com/apps/algolia-api-clients-automation-bot)
+- [1f389d1f7f](https://github.com/algolia/api-clients-automation/commit/1f389d1f7f) feat(specs): add agentic analytics support to insights spec ([#6876](https://github.com/algolia/api-clients-automation/pull/6876)) by [@sirockin](https://github.com/sirockin/)
+- [65cc642811](https://github.com/algolia/api-clients-automation/commit/65cc642811) feat(specs): add decision (declared winner) to abtesting-v3 ABTest ([#6732](https://github.com/algolia/api-clients-automation/pull/6732)) by [@cdhawke](https://github.com/cdhawke/)
+- [637defc23a](https://github.com/algolia/api-clients-automation/commit/637defc23a) feat(specs): add analytics v3 pattern endpoints ([#6795](https://github.com/algolia/api-clients-automation/pull/6795)) by [@Niamsy](https://github.com/Niamsy/)
+- [bed536e149](https://github.com/algolia/api-clients-automation/commit/bed536e149) chore(deps): dependencies 2026-08-10 ([#6835](https://github.com/algolia/api-clients-automation/pull/6835)) by [@algolia-api-clients-automation-bot[bot]](https://github.com/apps/algolia-api-clients-automation-bot)
+
 ## [3.42.3](https://github.com/algolia/algoliasearch-client-ruby/compare/3.42.2...3.42.3)
 
 - [772f7055cc](https://github.com/algolia/api-clients-automation/commit/772f7055cc) fix(clients): add warning in replace_all_objects for empty objects ([#6610](https://github.com/algolia/api-clients-automation/pull/6610)) by [@eric-zaharia](https://github.com/eric-zaharia/)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    algolia (3.42.3)
+    algolia (3.43.0)
       base64 (>= 0.2.0, < 1)
       faraday (>= 1.0.1, < 3.0)
       faraday-net_http_persistent (>= 0.15, < 3)
@@ -21,7 +21,7 @@ GEM
     faraday-net_http_persistent (2.3.1)
       faraday (~> 2.5)
       net-http-persistent (>= 4.0.4, < 5)
-    json (2.20.0)
+    json (2.21.2)
     logger (1.7.0)
     net-http (0.9.1)
       uri (>= 0.11.1)

data/lib/algolia/api/analytics_client.rb

@@ -691,6 +691,39 @@ module Algolia
       )
     end
 
+    # **Beta**: this endpoint is under active development and may change without notice.  Returns the static catalog of analytics fields, grouped by domain and usage (metrics, filters, groups, distributions). No authentication is required. Use it to discover valid `(domain, kind)` pairs before building the other `/3/patterns/*` queries; two fields are combinable in one query only when their `roots` intersect. Each entry's `requires` lists the ACLs needed when that field is actually used in a query.
+
+    # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
+    # @return [Http::Response] the response
+    def get_patterns_fields_with_http_info(request_options = {})
+      path = "/3/patterns/fields"
+      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]
+
+      new_options = request_options.merge(
+        :operation => :"AnalyticsClient.get_patterns_fields",
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :use_read_transporter => false
+      )
+
+      @api_client.call_api(:GET, path, new_options)
+    end
+
+    # **Beta**: this endpoint is under active development and may change without notice.  Returns the static catalog of analytics fields, grouped by domain and usage (metrics, filters, groups, distributions). No authentication is required. Use it to discover valid `(domain, kind)` pairs before building the other `/3/patterns/*` queries; two fields are combinable in one query only when their `roots` intersect. Each entry's `requires` lists the ACLs needed when that field is actually used in a query.
+
+    # @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 [Catalog]
+    def get_patterns_fields(request_options = {})
+      response = get_patterns_fields_with_http_info(request_options)
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Analytics::Catalog")
+    end
+
     # Retrieves the purchase rate for all your searches with at least one purchase event, including a daily breakdown.  By default, the analyzed period includes the last eight days, including the current day.  The rate is purchase conversion events divided by tracked searches. A search is tracked if it returns a query ID (`clickAnalytics` is `true`). This differs from the response's `count`, which includes searches where `clickAnalytics` is `false`.  **There's a difference between a 0 and null purchase rate when `clickAnalytics` is enabled:**  - **Null** means there were no queries. Algolia didn't receive any events, so the purchase rate is null. - **0** means there were queries but no [purchase conversion events](https://www.algolia.com/doc/guides/sending-events/getting-started) were received.
     #
     # Required API Key ACLs:
@@ -1765,5 +1798,193 @@ module Algolia
       @api_client.deserialize(response.body, request_options[:debug_return_type] || "Analytics::GetUsersCountResponse")
     end
 
+    # **Beta**: this endpoint is under active development and may change without notice.  Buckets one or more numeric fields into histograms and returns an object keyed by `histogram<Field>`, each mapping a bin label to a count. `distributions` and `parameters` are required; `filters` is optional. Discover valid field kinds per domain with `/3/patterns/fields`.
+    #
+    # Required API Key ACLs:
+    #   - analytics
+    # @param distribution_payload [DistributionPayload]  (required)
+    # @param index [String] Comma-separated list of indices the request runs on, used for authorization. Required for index-restricted API keys and must match the indices supplied in the request body's `indices` parameter; optional for unrestricted keys.
+    # @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 query_patterns_distribution_with_http_info(distribution_payload, index = nil, request_options = {})
+      # verify the required parameter 'distribution_payload' is set
+      if @api_client.config.client_side_validation && distribution_payload.nil?
+        raise ArgumentError, "Parameter `distribution_payload` is required when calling `query_patterns_distribution`."
+      end
+
+      path = "/3/patterns/distribution"
+      query_params = {}
+      query_params[:index] = index unless index.nil?
+      query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
+      header_params = {}
+      header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?
+
+      post_body = request_options[:debug_body] || @api_client.object_to_http_body(distribution_payload)
+
+      new_options = request_options.merge(
+        :operation => :"AnalyticsClient.query_patterns_distribution",
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :use_read_transporter => false
+      )
+
+      @api_client.call_api(:POST, path, new_options)
+    end
+
+    # **Beta**: this endpoint is under active development and may change without notice.  Buckets one or more numeric fields into histograms and returns an object keyed by `histogram<Field>`, each mapping a bin label to a count. `distributions` and `parameters` are required; `filters` is optional. Discover valid field kinds per domain with `/3/patterns/fields`.
+    #
+    # Required API Key ACLs:
+    #   - analytics
+    # @param distribution_payload [DistributionPayload]  (required)
+    # @param index [String] Comma-separated list of indices the request runs on, used for authorization. Required for index-restricted API keys and must match the indices supplied in the request body's `indices` parameter; optional for unrestricted keys.
+    # @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 [Hash<String, Object>]
+    def query_patterns_distribution(distribution_payload, index = nil, request_options = {})
+      response = query_patterns_distribution_with_http_info(distribution_payload, index, request_options)
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Hash<String, Object>")
+    end
+
+    # **Beta**: this endpoint is under active development and may change without notice.  Aggregates the requested `metrics` over the whole period and returns a single object keyed by metric kind. `metrics` and `parameters` are required; `filters` is optional. Discover valid field kinds per domain with `/3/patterns/fields`.
+    #
+    # Required API Key ACLs:
+    #   - analytics
+    # @param scalar_payload [ScalarPayload]  (required)
+    # @param index [String] Comma-separated list of indices the request runs on, used for authorization. Required for index-restricted API keys and must match the indices supplied in the request body's `indices` parameter; optional for unrestricted keys.
+    # @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 query_patterns_scalar_with_http_info(scalar_payload, index = nil, request_options = {})
+      # verify the required parameter 'scalar_payload' is set
+      if @api_client.config.client_side_validation && scalar_payload.nil?
+        raise ArgumentError, "Parameter `scalar_payload` is required when calling `query_patterns_scalar`."
+      end
+
+      path = "/3/patterns/scalar"
+      query_params = {}
+      query_params[:index] = index unless index.nil?
+      query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
+      header_params = {}
+      header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?
+
+      post_body = request_options[:debug_body] || @api_client.object_to_http_body(scalar_payload)
+
+      new_options = request_options.merge(
+        :operation => :"AnalyticsClient.query_patterns_scalar",
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :use_read_transporter => false
+      )
+
+      @api_client.call_api(:POST, path, new_options)
+    end
+
+    # **Beta**: this endpoint is under active development and may change without notice.  Aggregates the requested `metrics` over the whole period and returns a single object keyed by metric kind. `metrics` and `parameters` are required; `filters` is optional. Discover valid field kinds per domain with `/3/patterns/fields`.
+    #
+    # Required API Key ACLs:
+    #   - analytics
+    # @param scalar_payload [ScalarPayload]  (required)
+    # @param index [String] Comma-separated list of indices the request runs on, used for authorization. Required for index-restricted API keys and must match the indices supplied in the request body's `indices` parameter; optional for unrestricted keys.
+    # @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 [Hash<String, Object>]
+    def query_patterns_scalar(scalar_payload, index = nil, request_options = {})
+      response = query_patterns_scalar_with_http_info(scalar_payload, index, request_options)
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Hash<String, Object>")
+    end
+
+    # **Beta**: this endpoint is under active development and may change without notice.  Returns `rows`, each a flat object of the requested fields. `metrics` and `parameters` are required; `groupBy`, `filters`, and `orderBy` are optional, though `orderBy` is required when `groupBy` is set. Discover valid field kinds per domain with `/3/patterns/fields`.
+    #
+    # Required API Key ACLs:
+    #   - analytics
+    # @param table_payload [TablePayload]  (required)
+    # @param index [String] Comma-separated list of indices the request runs on, used for authorization. Required for index-restricted API keys and must match the indices supplied in the request body's `indices` parameter; optional for unrestricted keys.
+    # @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 query_patterns_table_with_http_info(table_payload, index = nil, request_options = {})
+      # verify the required parameter 'table_payload' is set
+      if @api_client.config.client_side_validation && table_payload.nil?
+        raise ArgumentError, "Parameter `table_payload` is required when calling `query_patterns_table`."
+      end
+
+      path = "/3/patterns/table"
+      query_params = {}
+      query_params[:index] = index unless index.nil?
+      query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
+      header_params = {}
+      header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?
+
+      post_body = request_options[:debug_body] || @api_client.object_to_http_body(table_payload)
+
+      new_options = request_options.merge(
+        :operation => :"AnalyticsClient.query_patterns_table",
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :use_read_transporter => false
+      )
+
+      @api_client.call_api(:POST, path, new_options)
+    end
+
+    # **Beta**: this endpoint is under active development and may change without notice.  Returns `rows`, each a flat object of the requested fields. `metrics` and `parameters` are required; `groupBy`, `filters`, and `orderBy` are optional, though `orderBy` is required when `groupBy` is set. Discover valid field kinds per domain with `/3/patterns/fields`.
+    #
+    # Required API Key ACLs:
+    #   - analytics
+    # @param table_payload [TablePayload]  (required)
+    # @param index [String] Comma-separated list of indices the request runs on, used for authorization. Required for index-restricted API keys and must match the indices supplied in the request body's `indices` parameter; optional for unrestricted keys.
+    # @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 [TableResponse]
+    def query_patterns_table(table_payload, index = nil, request_options = {})
+      response = query_patterns_table_with_http_info(table_payload, index, request_options)
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Analytics::TableResponse")
+    end
+
+    # **Beta**: this endpoint is under active development and may change without notice.  Returns one time series per `groupBy` combination, each with period `totals` and a per-day metric breakdown. `metrics` and `parameters` are required; `groupBy` and `filters` are optional. Discover valid field kinds per domain with `/3/patterns/fields`.
+    #
+    # Required API Key ACLs:
+    #   - analytics
+    # @param timeseries_payload [TimeseriesPayload]  (required)
+    # @param index [String] Comma-separated list of indices the request runs on, used for authorization. Required for index-restricted API keys and must match the indices supplied in the request body's `indices` parameter; optional for unrestricted keys.
+    # @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 query_patterns_timeseries_with_http_info(timeseries_payload, index = nil, request_options = {})
+      # verify the required parameter 'timeseries_payload' is set
+      if @api_client.config.client_side_validation && timeseries_payload.nil?
+        raise ArgumentError, "Parameter `timeseries_payload` is required when calling `query_patterns_timeseries`."
+      end
+
+      path = "/3/patterns/timeseries"
+      query_params = {}
+      query_params[:index] = index unless index.nil?
+      query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
+      header_params = {}
+      header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?
+
+      post_body = request_options[:debug_body] || @api_client.object_to_http_body(timeseries_payload)
+
+      new_options = request_options.merge(
+        :operation => :"AnalyticsClient.query_patterns_timeseries",
+        :header_params => header_params,
+        :query_params => query_params,
+        :body => post_body,
+        :use_read_transporter => false
+      )
+
+      @api_client.call_api(:POST, path, new_options)
+    end
+
+    # **Beta**: this endpoint is under active development and may change without notice.  Returns one time series per `groupBy` combination, each with period `totals` and a per-day metric breakdown. `metrics` and `parameters` are required; `groupBy` and `filters` are optional. Discover valid field kinds per domain with `/3/patterns/fields`.
+    #
+    # Required API Key ACLs:
+    #   - analytics
+    # @param timeseries_payload [TimeseriesPayload]  (required)
+    # @param index [String] Comma-separated list of indices the request runs on, used for authorization. Required for index-restricted API keys and must match the indices supplied in the request body's `indices` parameter; optional for unrestricted keys.
+    # @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 [TimeseriesResponse]
+    def query_patterns_timeseries(timeseries_payload, index = nil, request_options = {})
+      response = query_patterns_timeseries_with_http_info(timeseries_payload, index, request_options)
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Analytics::TimeseriesResponse")
+    end
+
   end
 end

data/lib/algolia/models/abtesting-v3/ab_test.rb

@@ -36,6 +36,8 @@ module Algolia
       # Unique migrated A/B test identifier.
       attr_accessor :migrated_ab_test_id
 
+      attr_accessor :decision
+
       # Attribute mapping from ruby-style variable name to JSON key.
       def self.attribute_map
         {
@@ -48,7 +50,8 @@ module Algolia
           :status => :status,
           :variants => :variants,
           :configuration => :configuration,
-          :migrated_ab_test_id => :migratedAbTestID
+          :migrated_ab_test_id => :migratedAbTestID,
+          :decision => :decision
         }
       end
 
@@ -64,7 +67,8 @@ module Algolia
           :status => :"Status",
           :variants => :"Array<Variant>",
           :configuration => :"ABTestConfiguration",
-          :migrated_ab_test_id => :"Integer"
+          :migrated_ab_test_id => :"Integer",
+          :decision => :"Decision"
         }
       end
 
@@ -152,6 +156,10 @@ module Algolia
         if attributes.key?(:migrated_ab_test_id)
           self.migrated_ab_test_id = attributes[:migrated_ab_test_id]
         end
+
+        if attributes.key?(:decision)
+          self.decision = attributes[:decision]
+        end
       end
 
       # Checks equality by comparing each attribute.
@@ -168,7 +176,8 @@ module Algolia
           status == other.status &&
           variants == other.variants &&
           configuration == other.configuration &&
-          migrated_ab_test_id == other.migrated_ab_test_id
+          migrated_ab_test_id == other.migrated_ab_test_id &&
+          decision == other.decision
       end
 
       # @see the `==` method
@@ -190,7 +199,8 @@ module Algolia
           status,
           variants,
           configuration,
-          migrated_ab_test_id
+          migrated_ab_test_id,
+          decision
         ].hash
       end
 

data/lib/algolia/models/abtesting-v3/decision.rb

@@ -0,0 +1,219 @@
+# 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
+    # Outcome of the A/B test once a winner has been declared. Only present when a winning variant has been declared, so its presence indicates the test has been decided.
+    class Decision
+      # Identifier of the declared winning variant. The control variant is 1.
+      attr_accessor :winner_variant_id
+
+      # Date and time when the winning variant was declared, in RFC 3339 format.
+      attr_accessor :declared_at
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :winner_variant_id => :winnerVariantId,
+          :declared_at => :declaredAt
+        }
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :winner_variant_id => :"Integer",
+          :declared_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::Decision` 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::Decision`. 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?(:winner_variant_id)
+          self.winner_variant_id = attributes[:winner_variant_id]
+        else
+          self.winner_variant_id = nil
+        end
+
+        if attributes.key?(:declared_at)
+          self.declared_at = attributes[:declared_at]
+        else
+          self.declared_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 &&
+          winner_variant_id == other.winner_variant_id &&
+          declared_at == other.declared_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
+        [winner_variant_id, declared_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.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