[codegen] update to latest spec

Author: l-trotta

java-client/src/main/java/co/elastic/clients/elasticsearch/_types/analysis/KuromojiAnalyzer.java

@@ -26,7 +26,6 @@
 import co.elastic.clients.json.JsonpUtils;
 import co.elastic.clients.json.ObjectBuilderDeserializer;
 import co.elastic.clients.json.ObjectDeserializer;
-import co.elastic.clients.util.ApiTypeHelper;
 import co.elastic.clients.util.ObjectBuilder;
 import co.elastic.clients.util.WithJsonObjectBuilderBase;
 import jakarta.json.stream.JsonGenerator;
@@ -60,6 +59,7 @@
  */
 @JsonpDeserializable
 public class KuromojiAnalyzer implements AnalyzerVariant, JsonpSerializable {
+	@Nullable
 	private final KuromojiTokenizationMode mode;
 
 	@Nullable
@@ -69,7 +69,7 @@ public class KuromojiAnalyzer implements AnalyzerVariant, JsonpSerializable {
 
 	private KuromojiAnalyzer(Builder builder) {
 
-		this.mode = ApiTypeHelper.requireNonNull(builder.mode, this, "mode");
+		this.mode = builder.mode;
 		this.userDictionary = builder.userDictionary;
 
 	}
@@ -87,8 +87,9 @@ public Analyzer.Kind _analyzerKind() {
 	}
 
 	/**
-	 * Required - API name: {@code mode}
+	 * API name: {@code mode}
 	 */
+	@Nullable
 	public final KuromojiTokenizationMode mode() {
 		return this.mode;
 	}
@@ -114,8 +115,10 @@ protected void serializeInternal(JsonGenerator generator, JsonpMapper mapper) {
 
 		generator.write("type", "kuromoji");
 
-		generator.writeKey("mode");
-		this.mode.serialize(generator, mapper);
+		if (this.mode != null) {
+			generator.writeKey("mode");
+			this.mode.serialize(generator, mapper);
+		}
 		if (this.userDictionary != null) {
 			generator.writeKey("user_dictionary");
 			generator.write(this.userDictionary);
@@ -136,15 +139,16 @@ public String toString() {
 	 */
 
 	public static class Builder extends WithJsonObjectBuilderBase<Builder> implements ObjectBuilder<KuromojiAnalyzer> {
+		@Nullable
 		private KuromojiTokenizationMode mode;
 
 		@Nullable
 		private String userDictionary;
 
 		/**
-		 * Required - API name: {@code mode}
+		 * API name: {@code mode}
 		 */
-		public final Builder mode(KuromojiTokenizationMode value) {
+		public final Builder mode(@Nullable KuromojiTokenizationMode value) {
 			this.mode = value;
 			return this;
 		}

java-client/src/main/java/co/elastic/clients/elasticsearch/cat/MlDataFrameAnalyticsRequest.java

@@ -109,7 +109,7 @@ public static MlDataFrameAnalyticsRequest of(Function<Builder, ObjectBuilder<MlD
 
 	/**
 	 * Whether to ignore if a wildcard expression matches no configs. (This includes
-	 * <code>_all</code> string or when no configs have been specified)
+	 * <code>_all</code> string or when no configs have been specified.)
 	 * <p>
 	 * API name: {@code allow_no_match}
 	 */
@@ -210,7 +210,7 @@ public static class Builder extends CatRequestBase.AbstractBuilder<Builder>
 
 		/**
 		 * Whether to ignore if a wildcard expression matches no configs. (This includes
-		 * <code>_all</code> string or when no configs have been specified)
+		 * <code>_all</code> string or when no configs have been specified.)
 		 * <p>
 		 * API name: {@code allow_no_match}
 		 */

java-client/src/main/java/co/elastic/clients/elasticsearch/cat/SegmentsRequest.java

@@ -21,6 +21,7 @@
 
 import co.elastic.clients.elasticsearch._types.Bytes;
 import co.elastic.clients.elasticsearch._types.ErrorResponse;
+import co.elastic.clients.elasticsearch._types.ExpandWildcard;
 import co.elastic.clients.elasticsearch._types.Time;
 import co.elastic.clients.elasticsearch._types.TimeUnit;
 import co.elastic.clients.json.JsonpDeserializable;
@@ -74,11 +75,25 @@
  */
 
 public class SegmentsRequest extends CatRequestBase {
+	@Nullable
+	private final Boolean allowClosed;
+
+	@Nullable
+	private final Boolean allowNoIndices;
+
 	@Nullable
 	private final Bytes bytes;
 
+	private final List<ExpandWildcard> expandWildcards;
+
 	private final List<String> h;
 
+	@Nullable
+	private final Boolean ignoreThrottled;
+
+	@Nullable
+	private final Boolean ignoreUnavailable;
+
 	private final List<String> index;
 
 	@Nullable
@@ -96,8 +111,13 @@ public class SegmentsRequest extends CatRequestBase {
 
 	private SegmentsRequest(Builder builder) {
 
+		this.allowClosed = builder.allowClosed;
+		this.allowNoIndices = builder.allowNoIndices;
 		this.bytes = builder.bytes;
+		this.expandWildcards = ApiTypeHelper.unmodifiable(builder.expandWildcards);
 		this.h = ApiTypeHelper.unmodifiable(builder.h);
+		this.ignoreThrottled = builder.ignoreThrottled;
+		this.ignoreUnavailable = builder.ignoreUnavailable;
 		this.index = ApiTypeHelper.unmodifiable(builder.index);
 		this.local = builder.local;
 		this.masterTimeout = builder.masterTimeout;
@@ -110,6 +130,32 @@ public static SegmentsRequest of(Function<Builder, ObjectBuilder<SegmentsRequest
 		return fn.apply(new Builder()).build();
 	}
 
+	/**
+	 * If true, allow closed indices to be returned in the response otherwise if
+	 * false, keep the legacy behaviour of throwing an exception if index pattern
+	 * matches closed indices
+	 * <p>
+	 * API name: {@code allow_closed}
+	 */
+	@Nullable
+	public final Boolean allowClosed() {
+		return this.allowClosed;
+	}
+
+	/**
+	 * If false, the request returns an error if any wildcard expression, index
+	 * alias, or _all value targets only missing or closed indices. This behavior
+	 * applies even if the request targets other open indices. For example, a
+	 * request targeting foo*,bar* returns an error if an index starts with foo but
+	 * no index starts with bar.
+	 * <p>
+	 * API name: {@code allow_no_indices}
+	 */
+	@Nullable
+	public final Boolean allowNoIndices() {
+		return this.allowNoIndices;
+	}
+
 	/**
 	 * Sets the units for columns that contain a byte-size value. Note that
 	 * byte-size value units work in terms of powers of 1024. For instance
@@ -128,6 +174,17 @@ public final Bytes bytes() {
 		return this.bytes;
 	}
 
+	/**
+	 * Type of index that wildcard expressions can match. If the request can target
+	 * data streams, this argument determines whether wildcard expressions match
+	 * hidden data streams. Supports comma-separated values, such as open,hidden.
+	 * <p>
+	 * API name: {@code expand_wildcards}
+	 */
+	public final List<ExpandWildcard> expandWildcards() {
+		return this.expandWildcards;
+	}
+
 	/**
 	 * A comma-separated list of columns names to display. It supports simple
 	 * wildcards.
@@ -138,6 +195,26 @@ public final List<String> h() {
 		return this.h;
 	}
 
+	/**
+	 * If true, concrete, expanded or aliased indices are ignored when frozen.
+	 * <p>
+	 * API name: {@code ignore_throttled}
+	 */
+	@Nullable
+	public final Boolean ignoreThrottled() {
+		return this.ignoreThrottled;
+	}
+
+	/**
+	 * If true, missing or closed indices are not included in the response.
+	 * <p>
+	 * API name: {@code ignore_unavailable}
+	 */
+	@Nullable
+	public final Boolean ignoreUnavailable() {
+		return this.ignoreUnavailable;
+	}
+
 	/**
 	 * A comma-separated list of data streams, indices, and aliases used to limit
 	 * the request. Supports wildcards (<code>*</code>). To target all data streams
@@ -209,12 +286,27 @@ public final TimeUnit time() {
 	public static class Builder extends CatRequestBase.AbstractBuilder<Builder>
 			implements
 				ObjectBuilder<SegmentsRequest> {
+		@Nullable
+		private Boolean allowClosed;
+
+		@Nullable
+		private Boolean allowNoIndices;
+
 		@Nullable
 		private Bytes bytes;
 
+		@Nullable
+		private List<ExpandWildcard> expandWildcards;
+
 		@Nullable
 		private List<String> h;
 
+		@Nullable
+		private Boolean ignoreThrottled;
+
+		@Nullable
+		private Boolean ignoreUnavailable;
+
 		@Nullable
 		private List<String> index;
 
@@ -230,6 +322,32 @@ public static class Builder extends CatRequestBase.AbstractBuilder<Builder>
 		@Nullable
 		private TimeUnit time;
 
+		/**
+		 * If true, allow closed indices to be returned in the response otherwise if
+		 * false, keep the legacy behaviour of throwing an exception if index pattern
+		 * matches closed indices
+		 * <p>
+		 * API name: {@code allow_closed}
+		 */
+		public final Builder allowClosed(@Nullable Boolean value) {
+			this.allowClosed = value;
+			return this;
+		}
+
+		/**
+		 * If false, the request returns an error if any wildcard expression, index
+		 * alias, or _all value targets only missing or closed indices. This behavior
+		 * applies even if the request targets other open indices. For example, a
+		 * request targeting foo*,bar* returns an error if an index starts with foo but
+		 * no index starts with bar.
+		 * <p>
+		 * API name: {@code allow_no_indices}
+		 */
+		public final Builder allowNoIndices(@Nullable Boolean value) {
+			this.allowNoIndices = value;
+			return this;
+		}
+
 		/**
 		 * Sets the units for columns that contain a byte-size value. Note that
 		 * byte-size value units work in terms of powers of 1024. For instance
@@ -248,6 +366,34 @@ public final Builder bytes(@Nullable Bytes value) {
 			return this;
 		}
 
+		/**
+		 * Type of index that wildcard expressions can match. If the request can target
+		 * data streams, this argument determines whether wildcard expressions match
+		 * hidden data streams. Supports comma-separated values, such as open,hidden.
+		 * <p>
+		 * API name: {@code expand_wildcards}
+		 * <p>
+		 * Adds all elements of <code>list</code> to <code>expandWildcards</code>.
+		 */
+		public final Builder expandWildcards(List<ExpandWildcard> list) {
+			this.expandWildcards = _listAddAll(this.expandWildcards, list);
+			return this;
+		}
+
+		/**
+		 * Type of index that wildcard expressions can match. If the request can target
+		 * data streams, this argument determines whether wildcard expressions match
+		 * hidden data streams. Supports comma-separated values, such as open,hidden.
+		 * <p>
+		 * API name: {@code expand_wildcards}
+		 * <p>
+		 * Adds one or more values to <code>expandWildcards</code>.
+		 */
+		public final Builder expandWildcards(ExpandWildcard value, ExpandWildcard... values) {
+			this.expandWildcards = _listAdd(this.expandWildcards, value, values);
+			return this;
+		}
+
 		/**
 		 * A comma-separated list of columns names to display. It supports simple
 		 * wildcards.
@@ -288,6 +434,26 @@ public final Builder h(CatSegmentsColumn value, CatSegmentsColumn... values) {
 			return this;
 		}
 
+		/**
+		 * If true, concrete, expanded or aliased indices are ignored when frozen.
+		 * <p>
+		 * API name: {@code ignore_throttled}
+		 */
+		public final Builder ignoreThrottled(@Nullable Boolean value) {
+			this.ignoreThrottled = value;
+			return this;
+		}
+
+		/**
+		 * If true, missing or closed indices are not included in the response.
+		 * <p>
+		 * API name: {@code ignore_unavailable}
+		 */
+		public final Builder ignoreUnavailable(@Nullable Boolean value) {
+			this.ignoreUnavailable = value;
+			return this;
+		}
+
 		/**
 		 * A comma-separated list of data streams, indices, and aliases used to limit
 		 * the request. Supports wildcards (<code>*</code>). To target all data streams
@@ -480,12 +646,28 @@ public SegmentsRequest build() {
 				if (ApiTypeHelper.isDefined(request.s)) {
 					params.put("s", request.s.stream().map(v -> v).collect(Collectors.joining(",")));
 				}
+				if (ApiTypeHelper.isDefined(request.expandWildcards)) {
+					params.put("expand_wildcards",
+							request.expandWildcards.stream().map(v -> v.jsonValue()).collect(Collectors.joining(",")));
+				}
+				if (request.ignoreUnavailable != null) {
+					params.put("ignore_unavailable", String.valueOf(request.ignoreUnavailable));
+				}
+				if (request.allowNoIndices != null) {
+					params.put("allow_no_indices", String.valueOf(request.allowNoIndices));
+				}
+				if (request.allowClosed != null) {
+					params.put("allow_closed", String.valueOf(request.allowClosed));
+				}
 				if (request.bytes != null) {
 					params.put("bytes", request.bytes.jsonValue());
 				}
 				if (ApiTypeHelper.isDefined(request.h)) {
 					params.put("h", request.h.stream().map(v -> v).collect(Collectors.joining(",")));
 				}
+				if (request.ignoreThrottled != null) {
+					params.put("ignore_throttled", String.valueOf(request.ignoreThrottled));
+				}
 				if (request.time != null) {
 					params.put("time", request.time.jsonValue());
 				}