Auto-generated API code

Author: elasticmachine

elasticsearch/_async/client/__init__.py

@@ -2133,7 +2133,7 @@ async def field_caps(
         ] = None,
         fields: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        filters: t.Optional[str] = None,
+        filters: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
         ignore_unavailable: t.Optional[bool] = None,
         include_empty_fields: t.Optional[bool] = None,
@@ -5599,7 +5599,7 @@ async def search_template(
     async def terms_enum(
         self,
         *,
-        index: str,
+        index: t.Union[str, t.Sequence[str]],
         field: t.Optional[str] = None,
         case_insensitive: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,

elasticsearch/_async/client/cat.py

@@ -3310,10 +3310,20 @@ async def segments(
         self,
         *,
         index: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        allow_closed: t.Optional[bool] = None,
+        allow_no_indices: t.Optional[bool] = None,
         bytes: t.Optional[
             t.Union[str, t.Literal["b", "gb", "kb", "mb", "pb", "tb"]]
         ] = None,
         error_trace: t.Optional[bool] = None,
+        expand_wildcards: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[str, t.Literal["all", "closed", "hidden", "none", "open"]]
+                ],
+                t.Union[str, t.Literal["all", "closed", "hidden", "none", "open"]],
+            ]
+        ] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
         h: t.Optional[
@@ -3364,6 +3374,8 @@ async def segments(
         ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
+        ignore_throttled: t.Optional[bool] = None,
+        ignore_unavailable: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
@@ -3387,6 +3399,14 @@ async def segments(
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
             and indices, omit this parameter or use `*` or `_all`.
+        :param allow_closed: 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
+        :param allow_no_indices: 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.
         :param bytes: 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
             `1kb` means 1024 bytes, not 1000 bytes. If omitted, byte-size values are
@@ -3395,12 +3415,20 @@ async def segments(
             least `1.0`. If given, byte-size values are rendered as an integer with no
             suffix, representing the value of the column in the chosen unit. Values that
             are not an exact multiple of the chosen unit are rounded down.
+        :param expand_wildcards: 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.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
         :param h: A comma-separated list of columns names to display. It supports simple
             wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
+        :param ignore_throttled: If true, concrete, expanded or aliased indices are ignored
+            when frozen.
+        :param ignore_unavailable: If true, missing or closed indices are not included
+            in the response.
         :param local: If `true`, the request computes the list of selected nodes from
             the local cluster state. If `false` the list of selected nodes are computed
             from the cluster state of the master node. In both cases the coordinating
@@ -3425,10 +3453,16 @@ async def segments(
             __path_parts = {}
             __path = "/_cat/segments"
         __query: t.Dict[str, t.Any] = {}
+        if allow_closed is not None:
+            __query["allow_closed"] = allow_closed
+        if allow_no_indices is not None:
+            __query["allow_no_indices"] = allow_no_indices
         if bytes is not None:
             __query["bytes"] = bytes
         if error_trace is not None:
             __query["error_trace"] = error_trace
+        if expand_wildcards is not None:
+            __query["expand_wildcards"] = expand_wildcards
         if filter_path is not None:
             __query["filter_path"] = filter_path
         if format is not None:
@@ -3439,6 +3473,10 @@ async def segments(
             __query["help"] = help
         if human is not None:
             __query["human"] = human
+        if ignore_throttled is not None:
+            __query["ignore_throttled"] = ignore_throttled
+        if ignore_unavailable is not None:
+            __query["ignore_unavailable"] = ignore_unavailable
         if local is not None:
             __query["local"] = local
         if master_timeout is not None:

elasticsearch/_async/client/cluster.py

@@ -1068,7 +1068,40 @@ async def reroute(
     async def state(
         self,
         *,
-        metric: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        metric: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "_all",
+                            "blocks",
+                            "customs",
+                            "master_node",
+                            "metadata",
+                            "nodes",
+                            "routing_nodes",
+                            "routing_table",
+                            "version",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "_all",
+                        "blocks",
+                        "customs",
+                        "master_node",
+                        "metadata",
+                        "nodes",
+                        "routing_nodes",
+                        "routing_table",
+                        "version",
+                    ],
+                ],
+            ]
+        ] = None,
         index: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         allow_no_indices: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,