chore: generated code for commit 95ba001. [skip ci]

Co-authored-by: Clément Vannicatte <[email protected]>

Author: algolia-bot

clients/algoliasearch-client-java-2/algoliasearch-core/src/main/java/com/algolia/api/SearchClient.java

@@ -2448,38 +2448,45 @@ public CompletableFuture<Map<String, String>> getObjectAsync(String indexName, S
    * Retrieve one or more objects, potentially from different indices, in a single API call.
    *
    * @param getObjectsParams The Algolia object. (required)
+   * @param innerType The class held by the index, could be your custom class or {@link Object}
    * @param requestOptions The requestOptions to send along with the query, they will be merged with
    *     the transporter requestOptions.
-   * @return GetObjectsResponse
+   * @return <T> GetObjectsResponse<T>
    * @throws AlgoliaRuntimeException If it fails to process the API call
    */
-  public GetObjectsResponse getObjects(GetObjectsParams getObjectsParams, RequestOptions requestOptions) throws AlgoliaRuntimeException {
-    return LaunderThrowable.await(getObjectsAsync(getObjectsParams, requestOptions));
+  public <T> GetObjectsResponse<T> getObjects(GetObjectsParams getObjectsParams, Class<T> innerType, RequestOptions requestOptions)
+    throws AlgoliaRuntimeException {
+    return LaunderThrowable.await(getObjectsAsync(getObjectsParams, innerType, requestOptions));
   }
 
   /**
    * Retrieve one or more objects, potentially from different indices, in a single API call.
    *
    * @param getObjectsParams The Algolia object. (required)
-   * @return GetObjectsResponse
+   * @param innerType The class held by the index, could be your custom class or {@link Object}
+   * @return <T> GetObjectsResponse<T>
    * @throws AlgoliaRuntimeException If it fails to process the API call
    */
-  public GetObjectsResponse getObjects(GetObjectsParams getObjectsParams) throws AlgoliaRuntimeException {
-    return this.getObjects(getObjectsParams, null);
+  public <T> GetObjectsResponse<T> getObjects(GetObjectsParams getObjectsParams, Class<T> innerType) throws AlgoliaRuntimeException {
+    return this.getObjects(getObjectsParams, innerType, null);
   }
 
   /**
    * (asynchronously) Retrieve one or more objects, potentially from different indices, in a single
    * API call.
    *
    * @param getObjectsParams The Algolia object. (required)
+   * @param innerType The class held by the index, could be your custom class or {@link Object}
    * @param requestOptions The requestOptions to send along with the query, they will be merged with
    *     the transporter requestOptions.
-   * @return CompletableFuture<GetObjectsResponse> The awaitable future
+   * @return <T> CompletableFuture<GetObjectsResponse<T>> The awaitable future
    * @throws AlgoliaRuntimeException If it fails to process the API call
    */
-  public CompletableFuture<GetObjectsResponse> getObjectsAsync(GetObjectsParams getObjectsParams, RequestOptions requestOptions)
-    throws AlgoliaRuntimeException {
+  public <T> CompletableFuture<GetObjectsResponse<T>> getObjectsAsync(
+    GetObjectsParams getObjectsParams,
+    Class<T> innerType,
+    RequestOptions requestOptions
+  ) throws AlgoliaRuntimeException {
     if (getObjectsParams == null) {
       throw new AlgoliaRuntimeException("Parameter `getObjectsParams` is required when calling `getObjects`.");
     }
@@ -2493,19 +2500,21 @@ public CompletableFuture<GetObjectsResponse> getObjectsAsync(GetObjectsParams ge
     Map<String, String> headers = new HashMap<String, String>();
 
     Call call = this.buildCall(requestPath, "POST", queryParameters, bodyObj, headers, requestOptions, true);
-    return this.executeAsync(call, new TypeReference<GetObjectsResponse>() {});
+    return this.executeAsync(call, GetObjectsResponse.class, innerType);
   }
 
   /**
    * (asynchronously) Retrieve one or more objects, potentially from different indices, in a single
    * API call.
    *
    * @param getObjectsParams The Algolia object. (required)
-   * @return CompletableFuture<GetObjectsResponse> The awaitable future
+   * @param innerType The class held by the index, could be your custom class or {@link Object}
+   * @return <T> CompletableFuture<GetObjectsResponse<T>> The awaitable future
    * @throws AlgoliaRuntimeException If it fails to process the API call
    */
-  public CompletableFuture<GetObjectsResponse> getObjectsAsync(GetObjectsParams getObjectsParams) throws AlgoliaRuntimeException {
-    return this.getObjectsAsync(getObjectsParams, null);
+  public <T> CompletableFuture<GetObjectsResponse<T>> getObjectsAsync(GetObjectsParams getObjectsParams, Class<T> innerType)
+    throws AlgoliaRuntimeException {
+    return this.getObjectsAsync(getObjectsParams, innerType, null);
   }
 
   /**

clients/algoliasearch-client-java-2/algoliasearch-core/src/main/java/com/algolia/model/recommend/Distinct.java

@@ -0,0 +1,156 @@
+// This file is generated, manual changes will be lost - read more on
+// https://github.com/algolia/api-clients-automation.
+
+package com.algolia.model.recommend;
+
+import com.algolia.utils.CompoundType;
+import com.fasterxml.jackson.annotation.*;
+import com.fasterxml.jackson.core.*;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.*;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+import com.fasterxml.jackson.databind.ser.std.StdSerializer;
+import java.io.IOException;
+
+/** Enables de-duplication or grouping of results. */
+@JsonDeserialize(using = Distinct.DistinctDeserializer.class)
+@JsonSerialize(using = Distinct.DistinctSerializer.class)
+public abstract class Distinct implements CompoundType {
+
+  public static Distinct of(Boolean inside) {
+    return new DistinctBoolean(inside);
+  }
+
+  public static Distinct of(Integer inside) {
+    return new DistinctInteger(inside);
+  }
+
+  public static class DistinctSerializer extends StdSerializer<Distinct> {
+
+    public DistinctSerializer(Class<Distinct> t) {
+      super(t);
+    }
+
+    public DistinctSerializer() {
+      this(null);
+    }
+
+    @Override
+    public void serialize(Distinct value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
+      jgen.writeObject(value.getInsideValue());
+    }
+  }
+
+  public static class DistinctDeserializer extends StdDeserializer<Distinct> {
+
+    public DistinctDeserializer() {
+      this(Distinct.class);
+    }
+
+    public DistinctDeserializer(Class<?> vc) {
+      super(vc);
+    }
+
+    @Override
+    public Distinct deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
+      JsonNode tree = jp.readValueAsTree();
+      Distinct deserialized = null;
+
+      int match = 0;
+      JsonToken token = tree.traverse(jp.getCodec()).nextToken();
+      String currentType = "";
+      // deserialize Boolean
+      try {
+        boolean attemptParsing = true;
+        currentType = "Boolean";
+        if (
+          ((currentType.equals("Integer") || currentType.equals("Long")) && token == JsonToken.VALUE_NUMBER_INT) |
+          ((currentType.equals("Float") || currentType.equals("Double")) && token == JsonToken.VALUE_NUMBER_FLOAT) |
+          (currentType.equals("Boolean") && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)) |
+          (currentType.equals("String") && token == JsonToken.VALUE_STRING) |
+          (currentType.startsWith("List<") && token == JsonToken.START_ARRAY)
+        ) {
+          deserialized = Distinct.of((Boolean) tree.traverse(jp.getCodec()).readValueAs(new TypeReference<Boolean>() {}));
+          match++;
+        } else if (token == JsonToken.START_OBJECT) {
+          try {
+            deserialized = Distinct.of((Boolean) tree.traverse(jp.getCodec()).readValueAs(new TypeReference<Boolean>() {}));
+            match++;
+          } catch (IOException e) {
+            // do nothing
+          }
+        }
+      } catch (Exception e) {
+        // deserialization failed, continue
+        System.err.println("Failed to deserialize oneOf Boolean (error: " + e.getMessage() + ") (type: " + currentType + ")");
+      }
+
+      // deserialize Integer
+      try {
+        boolean attemptParsing = true;
+        currentType = "Integer";
+        if (
+          ((currentType.equals("Integer") || currentType.equals("Long")) && token == JsonToken.VALUE_NUMBER_INT) |
+          ((currentType.equals("Float") || currentType.equals("Double")) && token == JsonToken.VALUE_NUMBER_FLOAT) |
+          (currentType.equals("Boolean") && (token == JsonToken.VALUE_FALSE || token == JsonToken.VALUE_TRUE)) |
+          (currentType.equals("String") && token == JsonToken.VALUE_STRING) |
+          (currentType.startsWith("List<") && token == JsonToken.START_ARRAY)
+        ) {
+          deserialized = Distinct.of((Integer) tree.traverse(jp.getCodec()).readValueAs(new TypeReference<Integer>() {}));
+          match++;
+        } else if (token == JsonToken.START_OBJECT) {
+          try {
+            deserialized = Distinct.of((Integer) tree.traverse(jp.getCodec()).readValueAs(new TypeReference<Integer>() {}));
+            match++;
+          } catch (IOException e) {
+            // do nothing
+          }
+        }
+      } catch (Exception e) {
+        // deserialization failed, continue
+        System.err.println("Failed to deserialize oneOf Integer (error: " + e.getMessage() + ") (type: " + currentType + ")");
+      }
+
+      if (match == 1) {
+        return deserialized;
+      }
+      throw new IOException(String.format("Failed deserialization for Distinct: %d classes match result, expected 1", match));
+    }
+
+    /** Handle deserialization of the 'null' value. */
+    @Override
+    public Distinct getNullValue(DeserializationContext ctxt) throws JsonMappingException {
+      throw new JsonMappingException(ctxt.getParser(), "Distinct cannot be null");
+    }
+  }
+}
+
+class DistinctBoolean extends Distinct {
+
+  private final Boolean insideValue;
+
+  DistinctBoolean(Boolean insideValue) {
+    this.insideValue = insideValue;
+  }
+
+  @Override
+  public Boolean getInsideValue() {
+    return insideValue;
+  }
+}
+
+class DistinctInteger extends Distinct {
+
+  private final Integer insideValue;
+
+  DistinctInteger(Integer insideValue) {
+    this.insideValue = insideValue;
+  }
+
+  @Override
+  public Integer getInsideValue() {
+    return insideValue;
+  }
+}

clients/algoliasearch-client-java-2/algoliasearch-core/src/main/java/com/algolia/model/recommend/IndexSettingsAsSearchParams.java

@@ -114,7 +114,7 @@ public class IndexSettingsAsSearchParams {
   private List<AdvancedSyntaxFeatures> advancedSyntaxFeatures;
 
   @JsonProperty("distinct")
-  private Integer distinct;
+  private Distinct distinct;
 
   @JsonProperty("synonyms")
   private Boolean synonyms;
@@ -764,18 +764,18 @@ public List<AdvancedSyntaxFeatures> getAdvancedSyntaxFeatures() {
     return advancedSyntaxFeatures;
   }
 
-  public IndexSettingsAsSearchParams setDistinct(Integer distinct) {
+  public IndexSettingsAsSearchParams setDistinct(Distinct distinct) {
     this.distinct = distinct;
     return this;
   }
 
   /**
-   * Enables de-duplication or grouping of results. minimum: 0 maximum: 4
+   * Get distinct
    *
    * @return distinct
    */
   @javax.annotation.Nullable
-  public Integer getDistinct() {
+  public Distinct getDistinct() {
     return distinct;
   }
 

clients/algoliasearch-client-java-2/algoliasearch-core/src/main/java/com/algolia/model/recommend/SearchParamsObject.java

@@ -216,7 +216,7 @@ public class SearchParamsObject {
   private List<AdvancedSyntaxFeatures> advancedSyntaxFeatures;
 
   @JsonProperty("distinct")
-  private Integer distinct;
+  private Distinct distinct;
 
   @JsonProperty("synonyms")
   private Boolean synonyms;
@@ -1430,18 +1430,18 @@ public List<AdvancedSyntaxFeatures> getAdvancedSyntaxFeatures() {
     return advancedSyntaxFeatures;
   }
 
-  public SearchParamsObject setDistinct(Integer distinct) {
+  public SearchParamsObject setDistinct(Distinct distinct) {
     this.distinct = distinct;
     return this;
   }
 
   /**
-   * Enables de-duplication or grouping of results. minimum: 0 maximum: 4
+   * Get distinct
    *
    * @return distinct
    */
   @javax.annotation.Nullable
-  public Integer getDistinct() {
+  public Distinct getDistinct() {
     return distinct;
   }
 

clients/algoliasearch-client-java-2/algoliasearch-core/src/main/java/com/algolia/model/search/BatchParams.java

@@ -12,14 +12,14 @@
 public class BatchParams {
 
   @JsonProperty("requests")
-  private List<MultipleBatchOperation> requests;
+  private List<MultipleBatchRequest> requests;
 
-  public BatchParams setRequests(List<MultipleBatchOperation> requests) {
+  public BatchParams setRequests(List<MultipleBatchRequest> requests) {
     this.requests = requests;
     return this;
   }
 
-  public BatchParams addRequests(MultipleBatchOperation requestsItem) {
+  public BatchParams addRequests(MultipleBatchRequest requestsItem) {
     if (this.requests == null) {
       this.requests = new ArrayList<>();
     }
@@ -33,7 +33,7 @@ public BatchParams addRequests(MultipleBatchOperation requestsItem) {
    * @return requests
    */
   @javax.annotation.Nullable
-  public List<MultipleBatchOperation> getRequests() {
+  public List<MultipleBatchRequest> getRequests() {
     return requests;
   }
 

clients/algoliasearch-client-java-2/algoliasearch-core/src/main/java/com/algolia/model/search/BatchOperation.java renamed to clients/algoliasearch-client-java-2/algoliasearch-core/src/main/java/com/algolia/model/search/BatchRequest.java

@@ -6,16 +6,16 @@
 import com.fasterxml.jackson.annotation.*;
 import java.util.Objects;
 
-/** BatchOperation */
-public class BatchOperation {
+/** BatchRequest */
+public class BatchRequest {
 
   @JsonProperty("action")
   private Action action;
 
   @JsonProperty("body")
   private Object body;
 
-  public BatchOperation setAction(Action action) {
+  public BatchRequest setAction(Action action) {
     this.action = action;
     return this;
   }
@@ -30,7 +30,7 @@ public Action getAction() {
     return action;
   }
 
-  public BatchOperation setBody(Object body) {
+  public BatchRequest setBody(Object body) {
     this.body = body;
     return this;
   }
@@ -53,8 +53,8 @@ public boolean equals(Object o) {
     if (o == null || getClass() != o.getClass()) {
       return false;
     }
-    BatchOperation batchOperation = (BatchOperation) o;
-    return Objects.equals(this.action, batchOperation.action) && Objects.equals(this.body, batchOperation.body);
+    BatchRequest batchRequest = (BatchRequest) o;
+    return Objects.equals(this.action, batchRequest.action) && Objects.equals(this.body, batchRequest.body);
   }
 
   @Override
@@ -65,7 +65,7 @@ public int hashCode() {
   @Override
   public String toString() {
     StringBuilder sb = new StringBuilder();
-    sb.append("class BatchOperation {\n");
+    sb.append("class BatchRequest {\n");
     sb.append("    action: ").append(toIndentedString(action)).append("\n");
     sb.append("    body: ").append(toIndentedString(body)).append("\n");
     sb.append("}");