elasticsearch 8.13.2__py3-none-any.whl → 8.15.0__py3-none-any.whl

elasticsearch/_async/client/cat.py

@@ -34,9 +34,9 @@ class CatClient(NamespacedClient):
         expand_wildcards: t.Optional[
             t.Union[
                 t.Sequence[
-                    t.Union["t.Literal['all', 'closed', 'hidden', 'none', 'open']", str]
+                    t.Union[str, t.Literal["all", "closed", "hidden", "none", "open"]]
                 ],
-                t.Union["t.Literal['all', 'closed', 'hidden', 'none', 'open']", str],
+                t.Union[str, t.Literal["all", "closed", "hidden", "none", "open"]],
             ]
         ] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
@@ -45,18 +45,19 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Shows information about currently configured aliases to indices including filter
-        and routing infos.
+        Retrieves the cluster’s index aliases, including filter and routing information.
+        The API does not return data stream aliases. IMPORTANT: cat APIs are only intended
+        for human consumption using the command line or the Kibana console. They are
+        not intended for use by applications. For application consumption, use the aliases
+        API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-alias.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-alias.html>`_
 
         :param name: A comma-separated list of aliases to retrieve. Supports wildcards
             (`*`). To retrieve all aliases, omit this parameter or use `*` or `_all`.
@@ -125,7 +126,7 @@ class CatClient(NamespacedClient):
         *,
         node_id: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         bytes: t.Optional[
-            t.Union["t.Literal['b', 'gb', 'kb', 'mb', 'pb', 'tb']", str]
+            t.Union[str, t.Literal["b", "gb", "kb", "mb", "pb", "tb"]]
         ] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
@@ -134,18 +135,17 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Provides a snapshot of how many shards are allocated to each data node and how
-        much disk space they are using.
+        Provides a snapshot of the number of shards allocated to each data node and their
+        disk space. IMPORTANT: cat APIs are only intended for human consumption using
+        the command line or Kibana console. They are not intended for use by applications.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-allocation.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-allocation.html>`_
 
         :param node_id: Comma-separated list of node identifiers or names used to limit
             the returned information.
@@ -219,17 +219,19 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns information about existing component_templates templates.
+        Returns information about component templates in a cluster. Component templates
+        are building blocks for constructing index templates that specify index mappings,
+        settings, and aliases. IMPORTANT: cat APIs are only intended for human consumption
+        using the command line or Kibana console. They are not intended for use by applications.
+        For application consumption, use the get component template API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-component-templates.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-component-templates.html>`_
 
         :param name: The name of the component template. Accepts wildcard expressions.
             If omitted, all component templates are returned.
@@ -300,18 +302,20 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Provides quick access to the document count of the entire cluster, or individual
-        indices.
+        Provides quick access to a document count for a data stream, an index, or an
+        entire cluster. NOTE: The document count only includes live documents, not deleted
+        documents which have not yet been removed by the merge process. IMPORTANT: cat
+        APIs are only intended for human consumption using the command line or Kibana
+        console. They are not intended for use by applications. For application consumption,
+        use the count API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-count.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-count.html>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -377,7 +381,7 @@ class CatClient(NamespacedClient):
         *,
         fields: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         bytes: t.Optional[
-            t.Union["t.Literal['b', 'gb', 'kb', 'mb', 'pb', 'tb']", str]
+            t.Union[str, t.Literal["b", "gb", "kb", "mb", "pb", "tb"]]
         ] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
@@ -386,18 +390,18 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Shows how much heap memory is currently being used by fielddata on every data
-        node in the cluster.
+        Returns the amount of heap memory currently used by the field data cache on every
+        data node in the cluster. IMPORTANT: cat APIs are only intended for human consumption
+        using the command line or Kibana console. They are not intended for use by applications.
+        For application consumption, use the nodes stats API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-fielddata.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-fielddata.html>`_
 
         :param fields: Comma-separated list of fields used to limit returned information.
             To retrieve all fields, omit this parameter.
@@ -470,21 +474,29 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         time: t.Optional[
-            t.Union["t.Literal['d', 'h', 'm', 'micros', 'ms', 'nanos', 's']", str]
+            t.Union[str, t.Literal["d", "h", "m", "micros", "ms", "nanos", "s"]]
         ] = None,
         ts: t.Optional[bool] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns a concise representation of the cluster health.
-
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-health.html>`_
+        Returns the health status of a cluster, similar to the cluster health API. IMPORTANT:
+        cat APIs are only intended for human consumption using the command line or Kibana
+        console. They are not intended for use by applications. For application consumption,
+        use the cluster health API. This API is often used to check malfunctioning clusters.
+        To help you track cluster health alongside log files and alerting systems, the
+        API returns timestamps in two formats: `HH:MM:SS`, which is human-readable but
+        includes no date information; `Unix epoch time`, which is machine-sortable and
+        includes date information. The latter format is useful for cluster recoveries
+        that take multiple days. You can use the cat health API to verify cluster health
+        across multiple nodes. You also can use the API to track the recovery of a large
+        cluster over a longer period of time.
+
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-health.html>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
@@ -553,9 +565,7 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
@@ -563,7 +573,7 @@ class CatClient(NamespacedClient):
         """
         Returns help for the Cat APIs.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat.html>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
@@ -621,41 +631,47 @@ class CatClient(NamespacedClient):
         *,
         index: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         bytes: t.Optional[
-            t.Union["t.Literal['b', 'gb', 'kb', 'mb', 'pb', 'tb']", str]
+            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["t.Literal['all', 'closed', 'hidden', 'none', 'open']", str]
+                    t.Union[str, t.Literal["all", "closed", "hidden", "none", "open"]]
                 ],
-                t.Union["t.Literal['all', 'closed', 'hidden', 'none', 'open']", str],
+                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[t.Union[str, t.Sequence[str]]] = None,
-        health: t.Optional[t.Union["t.Literal['green', 'red', 'yellow']", str]] = None,
+        health: t.Optional[t.Union[str, t.Literal["green", "red", "yellow"]]] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         include_unloaded_segments: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         pri: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         time: t.Optional[
-            t.Union["t.Literal['d', 'h', 'm', 'micros', 'ms', 'nanos', 's']", str]
+            t.Union[str, t.Literal["d", "h", "m", "micros", "ms", "nanos", "s"]]
         ] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns information about indices: number of primaries and replicas, document
-        counts, disk size, ...
-
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-indices.html>`_
+        Returns high-level information about indices in a cluster, including backing
+        indices for data streams. IMPORTANT: cat APIs are only intended for human consumption
+        using the command line or Kibana console. They are not intended for use by applications.
+        For application consumption, use the get index API. Use the cat indices API to
+        get the following information for each index in a cluster: shard count; document
+        count; deleted document count; primary store size; total store size of all shards,
+        including shard replicas. These metrics are retrieved directly from Lucene, which
+        Elasticsearch uses internally to power indexing and search. As a result, all
+        document counts include hidden nested documents. To get an accurate count of
+        Elasticsearch documents, use the cat count or count APIs.
+
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-indices.html>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -746,17 +762,18 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns information about the master node.
+        Returns information about the master node, including the ID, bound IP address,
+        and name. IMPORTANT: cat APIs are only intended for human consumption using the
+        command line or Kibana console. They are not intended for use by applications.
+        For application consumption, use the nodes info API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-master.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-master.html>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
@@ -815,7 +832,7 @@ class CatClient(NamespacedClient):
         id: t.Optional[str] = None,
         allow_no_match: t.Optional[bool] = None,
         bytes: t.Optional[
-            t.Union["t.Literal['b', 'gb', 'kb', 'mb', 'pb', 'tb']", str]
+            t.Union[str, t.Literal["b", "gb", "kb", "mb", "pb", "tb"]]
         ] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
@@ -824,44 +841,113 @@ class CatClient(NamespacedClient):
             t.Union[
                 t.Sequence[
                     t.Union[
-                        "t.Literal['assignment_explanation', 'create_time', 'description', 'dest_index', 'failure_reason', 'id', 'model_memory_limit', 'node.address', 'node.ephemeral_id', 'node.id', 'node.name', 'progress', 'source_index', 'state', 'type', 'version']",
                         str,
+                        t.Literal[
+                            "assignment_explanation",
+                            "create_time",
+                            "description",
+                            "dest_index",
+                            "failure_reason",
+                            "id",
+                            "model_memory_limit",
+                            "node.address",
+                            "node.ephemeral_id",
+                            "node.id",
+                            "node.name",
+                            "progress",
+                            "source_index",
+                            "state",
+                            "type",
+                            "version",
+                        ],
                     ]
                 ],
                 t.Union[
-                    "t.Literal['assignment_explanation', 'create_time', 'description', 'dest_index', 'failure_reason', 'id', 'model_memory_limit', 'node.address', 'node.ephemeral_id', 'node.id', 'node.name', 'progress', 'source_index', 'state', 'type', 'version']",
                     str,
+                    t.Literal[
+                        "assignment_explanation",
+                        "create_time",
+                        "description",
+                        "dest_index",
+                        "failure_reason",
+                        "id",
+                        "model_memory_limit",
+                        "node.address",
+                        "node.ephemeral_id",
+                        "node.id",
+                        "node.name",
+                        "progress",
+                        "source_index",
+                        "state",
+                        "type",
+                        "version",
+                    ],
                 ],
             ]
         ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[
             t.Union[
                 t.Sequence[
                     t.Union[
-                        "t.Literal['assignment_explanation', 'create_time', 'description', 'dest_index', 'failure_reason', 'id', 'model_memory_limit', 'node.address', 'node.ephemeral_id', 'node.id', 'node.name', 'progress', 'source_index', 'state', 'type', 'version']",
                         str,
+                        t.Literal[
+                            "assignment_explanation",
+                            "create_time",
+                            "description",
+                            "dest_index",
+                            "failure_reason",
+                            "id",
+                            "model_memory_limit",
+                            "node.address",
+                            "node.ephemeral_id",
+                            "node.id",
+                            "node.name",
+                            "progress",
+                            "source_index",
+                            "state",
+                            "type",
+                            "version",
+                        ],
                     ]
                 ],
                 t.Union[
-                    "t.Literal['assignment_explanation', 'create_time', 'description', 'dest_index', 'failure_reason', 'id', 'model_memory_limit', 'node.address', 'node.ephemeral_id', 'node.id', 'node.name', 'progress', 'source_index', 'state', 'type', 'version']",
                     str,
+                    t.Literal[
+                        "assignment_explanation",
+                        "create_time",
+                        "description",
+                        "dest_index",
+                        "failure_reason",
+                        "id",
+                        "model_memory_limit",
+                        "node.address",
+                        "node.ephemeral_id",
+                        "node.id",
+                        "node.name",
+                        "progress",
+                        "source_index",
+                        "state",
+                        "type",
+                        "version",
+                    ],
                 ],
             ]
         ] = None,
-        time: t.Optional[t.Union["t.Literal[-1]", "t.Literal[0]", str]] = None,
+        time: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Gets configuration and usage information about data frame analytics jobs.
+        Returns configuration and usage information about data frame analytics jobs.
+        IMPORTANT: cat APIs are only intended for human consumption using the Kibana
+        console or command line. They are not intended for use by applications. For application
+        consumption, use the get data frame analytics jobs statistics API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-dfanalytics.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-dfanalytics.html>`_
 
         :param id: The ID of the data frame analytics to fetch
         :param allow_no_match: Whether to ignore if a wildcard expression matches no
@@ -941,46 +1027,101 @@ class CatClient(NamespacedClient):
             t.Union[
                 t.Sequence[
                     t.Union[
-                        "t.Literal['ae', 'bc', 'id', 'na', 'ne', 'ni', 'nn', 's', 'sba', 'sc', 'seah', 'st']",
                         str,
+                        t.Literal[
+                            "ae",
+                            "bc",
+                            "id",
+                            "na",
+                            "ne",
+                            "ni",
+                            "nn",
+                            "s",
+                            "sba",
+                            "sc",
+                            "seah",
+                            "st",
+                        ],
                     ]
                 ],
                 t.Union[
-                    "t.Literal['ae', 'bc', 'id', 'na', 'ne', 'ni', 'nn', 's', 'sba', 'sc', 'seah', 'st']",
                     str,
+                    t.Literal[
+                        "ae",
+                        "bc",
+                        "id",
+                        "na",
+                        "ne",
+                        "ni",
+                        "nn",
+                        "s",
+                        "sba",
+                        "sc",
+                        "seah",
+                        "st",
+                    ],
                 ],
             ]
         ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[
             t.Union[
                 t.Sequence[
                     t.Union[
-                        "t.Literal['ae', 'bc', 'id', 'na', 'ne', 'ni', 'nn', 's', 'sba', 'sc', 'seah', 'st']",
                         str,
+                        t.Literal[
+                            "ae",
+                            "bc",
+                            "id",
+                            "na",
+                            "ne",
+                            "ni",
+                            "nn",
+                            "s",
+                            "sba",
+                            "sc",
+                            "seah",
+                            "st",
+                        ],
                     ]
                 ],
                 t.Union[
-                    "t.Literal['ae', 'bc', 'id', 'na', 'ne', 'ni', 'nn', 's', 'sba', 'sc', 'seah', 'st']",
                     str,
+                    t.Literal[
+                        "ae",
+                        "bc",
+                        "id",
+                        "na",
+                        "ne",
+                        "ni",
+                        "nn",
+                        "s",
+                        "sba",
+                        "sc",
+                        "seah",
+                        "st",
+                    ],
                 ],
             ]
         ] = None,
         time: t.Optional[
-            t.Union["t.Literal['d', 'h', 'm', 'micros', 'ms', 'nanos', 's']", str]
+            t.Union[str, t.Literal["d", "h", "m", "micros", "ms", "nanos", "s"]]
         ] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Gets configuration and usage information about datafeeds.
+        Returns configuration and usage information about datafeeds. This API returns
+        a maximum of 10,000 datafeeds. If the Elasticsearch security features are enabled,
+        you must have `monitor_ml`, `monitor`, `manage_ml`, or `manage` cluster privileges
+        to use this API. IMPORTANT: cat APIs are only intended for human consumption
+        using the Kibana console or command line. They are not intended for use by applications.
+        For application consumption, use the get datafeed statistics API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-datafeeds.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-datafeeds.html>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed.
@@ -1057,7 +1198,7 @@ class CatClient(NamespacedClient):
         job_id: t.Optional[str] = None,
         allow_no_match: t.Optional[bool] = None,
         bytes: t.Optional[
-            t.Union["t.Literal['b', 'gb', 'kb', 'mb', 'pb', 'tb']", str]
+            t.Union[str, t.Literal["b", "gb", "kb", "mb", "pb", "tb"]]
         ] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
@@ -1066,46 +1207,294 @@ class CatClient(NamespacedClient):
             t.Union[
                 t.Sequence[
                     t.Union[
-                        "t.Literal['assignment_explanation', 'buckets.count', 'buckets.time.exp_avg', 'buckets.time.exp_avg_hour', 'buckets.time.max', 'buckets.time.min', 'buckets.time.total', 'data.buckets', 'data.earliest_record', 'data.empty_buckets', 'data.input_bytes', 'data.input_fields', 'data.input_records', 'data.invalid_dates', 'data.last', 'data.last_empty_bucket', 'data.last_sparse_bucket', 'data.latest_record', 'data.missing_fields', 'data.out_of_order_timestamps', 'data.processed_fields', 'data.processed_records', 'data.sparse_buckets', 'forecasts.memory.avg', 'forecasts.memory.max', 'forecasts.memory.min', 'forecasts.memory.total', 'forecasts.records.avg', 'forecasts.records.max', 'forecasts.records.min', 'forecasts.records.total', 'forecasts.time.avg', 'forecasts.time.max', 'forecasts.time.min', 'forecasts.time.total', 'forecasts.total', 'id', 'model.bucket_allocation_failures', 'model.by_fields', 'model.bytes', 'model.bytes_exceeded', 'model.categorization_status', 'model.categorized_doc_count', 'model.dead_category_count', 'model.failed_category_count', 'model.frequent_category_count', 'model.log_time', 'model.memory_limit', 'model.memory_status', 'model.over_fields', 'model.partition_fields', 'model.rare_category_count', 'model.timestamp', 'model.total_category_count', 'node.address', 'node.ephemeral_id', 'node.id', 'node.name', 'opened_time', 'state']",
                         str,
+                        t.Literal[
+                            "assignment_explanation",
+                            "buckets.count",
+                            "buckets.time.exp_avg",
+                            "buckets.time.exp_avg_hour",
+                            "buckets.time.max",
+                            "buckets.time.min",
+                            "buckets.time.total",
+                            "data.buckets",
+                            "data.earliest_record",
+                            "data.empty_buckets",
+                            "data.input_bytes",
+                            "data.input_fields",
+                            "data.input_records",
+                            "data.invalid_dates",
+                            "data.last",
+                            "data.last_empty_bucket",
+                            "data.last_sparse_bucket",
+                            "data.latest_record",
+                            "data.missing_fields",
+                            "data.out_of_order_timestamps",
+                            "data.processed_fields",
+                            "data.processed_records",
+                            "data.sparse_buckets",
+                            "forecasts.memory.avg",
+                            "forecasts.memory.max",
+                            "forecasts.memory.min",
+                            "forecasts.memory.total",
+                            "forecasts.records.avg",
+                            "forecasts.records.max",
+                            "forecasts.records.min",
+                            "forecasts.records.total",
+                            "forecasts.time.avg",
+                            "forecasts.time.max",
+                            "forecasts.time.min",
+                            "forecasts.time.total",
+                            "forecasts.total",
+                            "id",
+                            "model.bucket_allocation_failures",
+                            "model.by_fields",
+                            "model.bytes",
+                            "model.bytes_exceeded",
+                            "model.categorization_status",
+                            "model.categorized_doc_count",
+                            "model.dead_category_count",
+                            "model.failed_category_count",
+                            "model.frequent_category_count",
+                            "model.log_time",
+                            "model.memory_limit",
+                            "model.memory_status",
+                            "model.over_fields",
+                            "model.partition_fields",
+                            "model.rare_category_count",
+                            "model.timestamp",
+                            "model.total_category_count",
+                            "node.address",
+                            "node.ephemeral_id",
+                            "node.id",
+                            "node.name",
+                            "opened_time",
+                            "state",
+                        ],
                     ]
                 ],
                 t.Union[
-                    "t.Literal['assignment_explanation', 'buckets.count', 'buckets.time.exp_avg', 'buckets.time.exp_avg_hour', 'buckets.time.max', 'buckets.time.min', 'buckets.time.total', 'data.buckets', 'data.earliest_record', 'data.empty_buckets', 'data.input_bytes', 'data.input_fields', 'data.input_records', 'data.invalid_dates', 'data.last', 'data.last_empty_bucket', 'data.last_sparse_bucket', 'data.latest_record', 'data.missing_fields', 'data.out_of_order_timestamps', 'data.processed_fields', 'data.processed_records', 'data.sparse_buckets', 'forecasts.memory.avg', 'forecasts.memory.max', 'forecasts.memory.min', 'forecasts.memory.total', 'forecasts.records.avg', 'forecasts.records.max', 'forecasts.records.min', 'forecasts.records.total', 'forecasts.time.avg', 'forecasts.time.max', 'forecasts.time.min', 'forecasts.time.total', 'forecasts.total', 'id', 'model.bucket_allocation_failures', 'model.by_fields', 'model.bytes', 'model.bytes_exceeded', 'model.categorization_status', 'model.categorized_doc_count', 'model.dead_category_count', 'model.failed_category_count', 'model.frequent_category_count', 'model.log_time', 'model.memory_limit', 'model.memory_status', 'model.over_fields', 'model.partition_fields', 'model.rare_category_count', 'model.timestamp', 'model.total_category_count', 'node.address', 'node.ephemeral_id', 'node.id', 'node.name', 'opened_time', 'state']",
                     str,
+                    t.Literal[
+                        "assignment_explanation",
+                        "buckets.count",
+                        "buckets.time.exp_avg",
+                        "buckets.time.exp_avg_hour",
+                        "buckets.time.max",
+                        "buckets.time.min",
+                        "buckets.time.total",
+                        "data.buckets",
+                        "data.earliest_record",
+                        "data.empty_buckets",
+                        "data.input_bytes",
+                        "data.input_fields",
+                        "data.input_records",
+                        "data.invalid_dates",
+                        "data.last",
+                        "data.last_empty_bucket",
+                        "data.last_sparse_bucket",
+                        "data.latest_record",
+                        "data.missing_fields",
+                        "data.out_of_order_timestamps",
+                        "data.processed_fields",
+                        "data.processed_records",
+                        "data.sparse_buckets",
+                        "forecasts.memory.avg",
+                        "forecasts.memory.max",
+                        "forecasts.memory.min",
+                        "forecasts.memory.total",
+                        "forecasts.records.avg",
+                        "forecasts.records.max",
+                        "forecasts.records.min",
+                        "forecasts.records.total",
+                        "forecasts.time.avg",
+                        "forecasts.time.max",
+                        "forecasts.time.min",
+                        "forecasts.time.total",
+                        "forecasts.total",
+                        "id",
+                        "model.bucket_allocation_failures",
+                        "model.by_fields",
+                        "model.bytes",
+                        "model.bytes_exceeded",
+                        "model.categorization_status",
+                        "model.categorized_doc_count",
+                        "model.dead_category_count",
+                        "model.failed_category_count",
+                        "model.frequent_category_count",
+                        "model.log_time",
+                        "model.memory_limit",
+                        "model.memory_status",
+                        "model.over_fields",
+                        "model.partition_fields",
+                        "model.rare_category_count",
+                        "model.timestamp",
+                        "model.total_category_count",
+                        "node.address",
+                        "node.ephemeral_id",
+                        "node.id",
+                        "node.name",
+                        "opened_time",
+                        "state",
+                    ],
                 ],
             ]
         ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[
             t.Union[
                 t.Sequence[
                     t.Union[
-                        "t.Literal['assignment_explanation', 'buckets.count', 'buckets.time.exp_avg', 'buckets.time.exp_avg_hour', 'buckets.time.max', 'buckets.time.min', 'buckets.time.total', 'data.buckets', 'data.earliest_record', 'data.empty_buckets', 'data.input_bytes', 'data.input_fields', 'data.input_records', 'data.invalid_dates', 'data.last', 'data.last_empty_bucket', 'data.last_sparse_bucket', 'data.latest_record', 'data.missing_fields', 'data.out_of_order_timestamps', 'data.processed_fields', 'data.processed_records', 'data.sparse_buckets', 'forecasts.memory.avg', 'forecasts.memory.max', 'forecasts.memory.min', 'forecasts.memory.total', 'forecasts.records.avg', 'forecasts.records.max', 'forecasts.records.min', 'forecasts.records.total', 'forecasts.time.avg', 'forecasts.time.max', 'forecasts.time.min', 'forecasts.time.total', 'forecasts.total', 'id', 'model.bucket_allocation_failures', 'model.by_fields', 'model.bytes', 'model.bytes_exceeded', 'model.categorization_status', 'model.categorized_doc_count', 'model.dead_category_count', 'model.failed_category_count', 'model.frequent_category_count', 'model.log_time', 'model.memory_limit', 'model.memory_status', 'model.over_fields', 'model.partition_fields', 'model.rare_category_count', 'model.timestamp', 'model.total_category_count', 'node.address', 'node.ephemeral_id', 'node.id', 'node.name', 'opened_time', 'state']",
                         str,
+                        t.Literal[
+                            "assignment_explanation",
+                            "buckets.count",
+                            "buckets.time.exp_avg",
+                            "buckets.time.exp_avg_hour",
+                            "buckets.time.max",
+                            "buckets.time.min",
+                            "buckets.time.total",
+                            "data.buckets",
+                            "data.earliest_record",
+                            "data.empty_buckets",
+                            "data.input_bytes",
+                            "data.input_fields",
+                            "data.input_records",
+                            "data.invalid_dates",
+                            "data.last",
+                            "data.last_empty_bucket",
+                            "data.last_sparse_bucket",
+                            "data.latest_record",
+                            "data.missing_fields",
+                            "data.out_of_order_timestamps",
+                            "data.processed_fields",
+                            "data.processed_records",
+                            "data.sparse_buckets",
+                            "forecasts.memory.avg",
+                            "forecasts.memory.max",
+                            "forecasts.memory.min",
+                            "forecasts.memory.total",
+                            "forecasts.records.avg",
+                            "forecasts.records.max",
+                            "forecasts.records.min",
+                            "forecasts.records.total",
+                            "forecasts.time.avg",
+                            "forecasts.time.max",
+                            "forecasts.time.min",
+                            "forecasts.time.total",
+                            "forecasts.total",
+                            "id",
+                            "model.bucket_allocation_failures",
+                            "model.by_fields",
+                            "model.bytes",
+                            "model.bytes_exceeded",
+                            "model.categorization_status",
+                            "model.categorized_doc_count",
+                            "model.dead_category_count",
+                            "model.failed_category_count",
+                            "model.frequent_category_count",
+                            "model.log_time",
+                            "model.memory_limit",
+                            "model.memory_status",
+                            "model.over_fields",
+                            "model.partition_fields",
+                            "model.rare_category_count",
+                            "model.timestamp",
+                            "model.total_category_count",
+                            "node.address",
+                            "node.ephemeral_id",
+                            "node.id",
+                            "node.name",
+                            "opened_time",
+                            "state",
+                        ],
                     ]
                 ],
                 t.Union[
-                    "t.Literal['assignment_explanation', 'buckets.count', 'buckets.time.exp_avg', 'buckets.time.exp_avg_hour', 'buckets.time.max', 'buckets.time.min', 'buckets.time.total', 'data.buckets', 'data.earliest_record', 'data.empty_buckets', 'data.input_bytes', 'data.input_fields', 'data.input_records', 'data.invalid_dates', 'data.last', 'data.last_empty_bucket', 'data.last_sparse_bucket', 'data.latest_record', 'data.missing_fields', 'data.out_of_order_timestamps', 'data.processed_fields', 'data.processed_records', 'data.sparse_buckets', 'forecasts.memory.avg', 'forecasts.memory.max', 'forecasts.memory.min', 'forecasts.memory.total', 'forecasts.records.avg', 'forecasts.records.max', 'forecasts.records.min', 'forecasts.records.total', 'forecasts.time.avg', 'forecasts.time.max', 'forecasts.time.min', 'forecasts.time.total', 'forecasts.total', 'id', 'model.bucket_allocation_failures', 'model.by_fields', 'model.bytes', 'model.bytes_exceeded', 'model.categorization_status', 'model.categorized_doc_count', 'model.dead_category_count', 'model.failed_category_count', 'model.frequent_category_count', 'model.log_time', 'model.memory_limit', 'model.memory_status', 'model.over_fields', 'model.partition_fields', 'model.rare_category_count', 'model.timestamp', 'model.total_category_count', 'node.address', 'node.ephemeral_id', 'node.id', 'node.name', 'opened_time', 'state']",
                     str,
+                    t.Literal[
+                        "assignment_explanation",
+                        "buckets.count",
+                        "buckets.time.exp_avg",
+                        "buckets.time.exp_avg_hour",
+                        "buckets.time.max",
+                        "buckets.time.min",
+                        "buckets.time.total",
+                        "data.buckets",
+                        "data.earliest_record",
+                        "data.empty_buckets",
+                        "data.input_bytes",
+                        "data.input_fields",
+                        "data.input_records",
+                        "data.invalid_dates",
+                        "data.last",
+                        "data.last_empty_bucket",
+                        "data.last_sparse_bucket",
+                        "data.latest_record",
+                        "data.missing_fields",
+                        "data.out_of_order_timestamps",
+                        "data.processed_fields",
+                        "data.processed_records",
+                        "data.sparse_buckets",
+                        "forecasts.memory.avg",
+                        "forecasts.memory.max",
+                        "forecasts.memory.min",
+                        "forecasts.memory.total",
+                        "forecasts.records.avg",
+                        "forecasts.records.max",
+                        "forecasts.records.min",
+                        "forecasts.records.total",
+                        "forecasts.time.avg",
+                        "forecasts.time.max",
+                        "forecasts.time.min",
+                        "forecasts.time.total",
+                        "forecasts.total",
+                        "id",
+                        "model.bucket_allocation_failures",
+                        "model.by_fields",
+                        "model.bytes",
+                        "model.bytes_exceeded",
+                        "model.categorization_status",
+                        "model.categorized_doc_count",
+                        "model.dead_category_count",
+                        "model.failed_category_count",
+                        "model.frequent_category_count",
+                        "model.log_time",
+                        "model.memory_limit",
+                        "model.memory_status",
+                        "model.over_fields",
+                        "model.partition_fields",
+                        "model.rare_category_count",
+                        "model.timestamp",
+                        "model.total_category_count",
+                        "node.address",
+                        "node.ephemeral_id",
+                        "node.id",
+                        "node.name",
+                        "opened_time",
+                        "state",
+                    ],
                 ],
             ]
         ] = None,
         time: t.Optional[
-            t.Union["t.Literal['d', 'h', 'm', 'micros', 'ms', 'nanos', 's']", str]
+            t.Union[str, t.Literal["d", "h", "m", "micros", "ms", "nanos", "s"]]
         ] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Gets configuration and usage information about anomaly detection jobs.
+        Returns configuration and usage information for anomaly detection jobs. This
+        API returns a maximum of 10,000 jobs. If the Elasticsearch security features
+        are enabled, you must have `monitor_ml`, `monitor`, `manage_ml`, or `manage`
+        cluster privileges to use this API. IMPORTANT: cat APIs are only intended for
+        human consumption using the Kibana console or command line. They are not intended
+        for use by applications. For application consumption, use the get anomaly detection
+        job statistics API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-anomaly-detectors.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-anomaly-detectors.html>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param allow_no_match: Specifies what to do when the request: * Contains wildcard
@@ -1186,7 +1575,7 @@ class CatClient(NamespacedClient):
         model_id: t.Optional[str] = None,
         allow_no_match: t.Optional[bool] = None,
         bytes: t.Optional[
-            t.Union["t.Literal['b', 'gb', 'kb', 'mb', 'pb', 'tb']", str]
+            t.Union[str, t.Literal["b", "gb", "kb", "mb", "pb", "tb"]]
         ] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
@@ -1196,34 +1585,92 @@ class CatClient(NamespacedClient):
             t.Union[
                 t.Sequence[
                     t.Union[
-                        "t.Literal['create_time', 'created_by', 'data_frame_analytics_id', 'description', 'heap_size', 'id', 'ingest.count', 'ingest.current', 'ingest.failed', 'ingest.pipelines', 'ingest.time', 'license', 'operations', 'version']",
                         str,
+                        t.Literal[
+                            "create_time",
+                            "created_by",
+                            "data_frame_analytics_id",
+                            "description",
+                            "heap_size",
+                            "id",
+                            "ingest.count",
+                            "ingest.current",
+                            "ingest.failed",
+                            "ingest.pipelines",
+                            "ingest.time",
+                            "license",
+                            "operations",
+                            "version",
+                        ],
                     ]
                 ],
                 t.Union[
-                    "t.Literal['create_time', 'created_by', 'data_frame_analytics_id', 'description', 'heap_size', 'id', 'ingest.count', 'ingest.current', 'ingest.failed', 'ingest.pipelines', 'ingest.time', 'license', 'operations', 'version']",
                     str,
+                    t.Literal[
+                        "create_time",
+                        "created_by",
+                        "data_frame_analytics_id",
+                        "description",
+                        "heap_size",
+                        "id",
+                        "ingest.count",
+                        "ingest.current",
+                        "ingest.failed",
+                        "ingest.pipelines",
+                        "ingest.time",
+                        "license",
+                        "operations",
+                        "version",
+                    ],
                 ],
             ]
         ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[
             t.Union[
                 t.Sequence[
                     t.Union[
-                        "t.Literal['create_time', 'created_by', 'data_frame_analytics_id', 'description', 'heap_size', 'id', 'ingest.count', 'ingest.current', 'ingest.failed', 'ingest.pipelines', 'ingest.time', 'license', 'operations', 'version']",
                         str,
+                        t.Literal[
+                            "create_time",
+                            "created_by",
+                            "data_frame_analytics_id",
+                            "description",
+                            "heap_size",
+                            "id",
+                            "ingest.count",
+                            "ingest.current",
+                            "ingest.failed",
+                            "ingest.pipelines",
+                            "ingest.time",
+                            "license",
+                            "operations",
+                            "version",
+                        ],
                     ]
                 ],
                 t.Union[
-                    "t.Literal['create_time', 'created_by', 'data_frame_analytics_id', 'description', 'heap_size', 'id', 'ingest.count', 'ingest.current', 'ingest.failed', 'ingest.pipelines', 'ingest.time', 'license', 'operations', 'version']",
                     str,
+                    t.Literal[
+                        "create_time",
+                        "created_by",
+                        "data_frame_analytics_id",
+                        "description",
+                        "heap_size",
+                        "id",
+                        "ingest.count",
+                        "ingest.current",
+                        "ingest.failed",
+                        "ingest.pipelines",
+                        "ingest.time",
+                        "license",
+                        "operations",
+                        "version",
+                    ],
                 ],
             ]
         ] = None,
@@ -1231,9 +1678,12 @@ class CatClient(NamespacedClient):
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Gets configuration and usage information about inference trained models.
+        Returns configuration and usage information about inference trained models. IMPORTANT:
+        cat APIs are only intended for human consumption using the Kibana console or
+        command line. They are not intended for use by applications. For application
+        consumption, use the get trained models statistics API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-trained-model.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-trained-model.html>`_
 
         :param model_id: A unique identifier for the trained model.
         :param allow_no_match: Specifies what to do when the request: contains wildcard
@@ -1319,17 +1769,18 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns information about custom node attributes.
+        Returns information about custom node attributes. IMPORTANT: cat APIs are only
+        intended for human consumption using the command line or Kibana console. They
+        are not intended for use by applications. For application consumption, use the
+        nodes info API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-nodeattrs.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-nodeattrs.html>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
@@ -1386,7 +1837,7 @@ class CatClient(NamespacedClient):
         self,
         *,
         bytes: t.Optional[
-            t.Union["t.Literal['b', 'gb', 'kb', 'mb', 'pb', 'tb']", str]
+            t.Union[str, t.Literal["b", "gb", "kb", "mb", "pb", "tb"]]
         ] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
@@ -1397,17 +1848,18 @@ class CatClient(NamespacedClient):
         human: t.Optional[bool] = None,
         include_unloaded_segments: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns basic statistics about performance of cluster nodes.
+        Returns information about the nodes in a cluster. IMPORTANT: cat APIs are only
+        intended for human consumption using the command line or Kibana console. They
+        are not intended for use by applications. For application consumption, use the
+        nodes info API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-nodes.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-nodes.html>`_
 
         :param bytes: The unit used to display byte values.
         :param format: Specifies the format to return the columnar data in, can be set
@@ -1481,17 +1933,18 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns a concise representation of the cluster pending tasks.
+        Returns cluster-level changes that have not yet been executed. IMPORTANT: cat
+        APIs are only intended for human consumption using the command line or Kibana
+        console. They are not intended for use by applications. For application consumption,
+        use the pending cluster tasks API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-pending-tasks.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-pending-tasks.html>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
@@ -1554,17 +2007,18 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns information about installed plugins across nodes node.
+        Returns a list of plugins running on each node of a cluster. IMPORTANT: cat APIs
+        are only intended for human consumption using the command line or Kibana console.
+        They are not intended for use by applications. For application consumption, use
+        the nodes info API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-plugins.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-plugins.html>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
@@ -1623,7 +2077,7 @@ class CatClient(NamespacedClient):
         index: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         active_only: t.Optional[bool] = None,
         bytes: t.Optional[
-            t.Union["t.Literal['b', 'gb', 'kb', 'mb', 'pb', 'tb']", str]
+            t.Union[str, t.Literal["b", "gb", "kb", "mb", "pb", "tb"]]
         ] = None,
         detailed: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,
@@ -1633,17 +2087,22 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns information about index shard recoveries, both on-going completed.
+        Returns information about ongoing and completed shard recoveries. Shard recovery
+        is the process of initializing a shard copy, such as restoring a primary shard
+        from a snapshot or syncing a replica shard from a primary shard. When a shard
+        recovery completes, the recovered shard is available for search and indexing.
+        For data streams, the API returns information about the stream’s backing indices.
+        IMPORTANT: cat APIs are only intended for human consumption using the command
+        line or Kibana console. They are not intended for use by applications. For application
+        consumption, use the index recovery API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-recovery.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-recovery.html>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -1724,17 +2183,18 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns information about snapshot repositories registered in the cluster.
+        Returns the snapshot repositories for a cluster. IMPORTANT: cat APIs are only
+        intended for human consumption using the command line or Kibana console. They
+        are not intended for use by applications. For application consumption, use the
+        get snapshot repository API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-repositories.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-repositories.html>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
@@ -1792,7 +2252,7 @@ class CatClient(NamespacedClient):
         *,
         index: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         bytes: t.Optional[
-            t.Union["t.Literal['b', 'gb', 'kb', 'mb', 'pb', 'tb']", str]
+            t.Union[str, t.Literal["b", "gb", "kb", "mb", "pb", "tb"]]
         ] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
@@ -1801,17 +2261,19 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Provides low-level information about the segments in the shards of an index.
+        Returns low-level information about the Lucene segments in index shards. For
+        data streams, the API returns information about the backing indices. IMPORTANT:
+        cat APIs are only intended for human consumption using the command line or Kibana
+        console. They are not intended for use by applications. For application consumption,
+        use the index segments API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-segments.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-segments.html>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -1880,7 +2342,7 @@ class CatClient(NamespacedClient):
         *,
         index: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         bytes: t.Optional[
-            t.Union["t.Literal['b', 'gb', 'kb', 'mb', 'pb', 'tb']", str]
+            t.Union[str, t.Literal["b", "gb", "kb", "mb", "pb", "tb"]]
         ] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
@@ -1889,17 +2351,18 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Provides a detailed view of shard allocation on nodes.
+        Returns information about the shards in a cluster. For data streams, the API
+        returns information about the backing indices. IMPORTANT: cat APIs are only intended
+        for human consumption using the command line or Kibana console. They are not
+        intended for use by applications.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-shards.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-shards.html>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -1975,17 +2438,19 @@ class CatClient(NamespacedClient):
         human: t.Optional[bool] = None,
         ignore_unavailable: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns all snapshots in a specific repository.
+        Returns information about the snapshots stored in one or more repositories. A
+        snapshot is a backup of an index or running Elasticsearch cluster. IMPORTANT:
+        cat APIs are only intended for human consumption using the command line or Kibana
+        console. They are not intended for use by applications. For application consumption,
+        use the get snapshot API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-snapshots.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-snapshots.html>`_
 
         :param repository: A comma-separated list of snapshot repositories used to limit
             the request. Accepts wildcard expressions. `_all` returns all repositories.
@@ -2062,9 +2527,7 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         node_id: t.Optional[t.Sequence[str]] = None,
         parent_task_id: t.Optional[str] = None,
         pretty: t.Optional[bool] = None,
@@ -2072,10 +2535,12 @@ class CatClient(NamespacedClient):
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns information about the tasks currently executing on one or more nodes
-        in the cluster.
+        Returns information about tasks currently executing in the cluster. IMPORTANT:
+        cat APIs are only intended for human consumption using the command line or Kibana
+        console. They are not intended for use by applications. For application consumption,
+        use the task management API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/tasks.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/tasks.html>`_
 
         :param actions: The task action names, which are used to limit the response.
         :param detailed: If `true`, the response includes detailed information about
@@ -2153,17 +2618,19 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns information about existing templates.
+        Returns information about index templates in a cluster. You can use index templates
+        to apply index settings and field mappings to new indices at creation. IMPORTANT:
+        cat APIs are only intended for human consumption using the command line or Kibana
+        console. They are not intended for use by applications. For application consumption,
+        use the get index template API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-templates.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-templates.html>`_
 
         :param name: The name of the template to return. Accepts wildcard expressions.
             If omitted, all templates are returned.
@@ -2234,21 +2701,22 @@ class CatClient(NamespacedClient):
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         time: t.Optional[
-            t.Union["t.Literal['d', 'h', 'm', 'micros', 'ms', 'nanos', 's']", str]
+            t.Union[str, t.Literal["d", "h", "m", "micros", "ms", "nanos", "s"]]
         ] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Returns cluster-wide thread pool statistics per node. By default the active,
-        queue and rejected statistics are returned for all thread pools.
+        Returns thread pool statistics for each node in a cluster. Returned information
+        includes all built-in thread pools and custom thread pools. IMPORTANT: cat APIs
+        are only intended for human consumption using the command line or Kibana console.
+        They are not intended for use by applications. For application consumption, use
+        the nodes info API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-thread-pool.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-thread-pool.html>`_
 
         :param thread_pool_patterns: A comma-separated list of thread pool names used
             to limit the request. Accepts wildcard expressions.
@@ -2326,47 +2794,184 @@ class CatClient(NamespacedClient):
             t.Union[
                 t.Sequence[
                     t.Union[
-                        "t.Literal['changes_last_detection_time', 'checkpoint', 'checkpoint_duration_time_exp_avg', 'checkpoint_progress', 'create_time', 'delete_time', 'description', 'dest_index', 'docs_per_second', 'documents_deleted', 'documents_indexed', 'documents_processed', 'frequency', 'id', 'index_failure', 'index_time', 'index_total', 'indexed_documents_exp_avg', 'last_search_time', 'max_page_search_size', 'pages_processed', 'pipeline', 'processed_documents_exp_avg', 'processing_time', 'reason', 'search_failure', 'search_time', 'search_total', 'source_index', 'state', 'transform_type', 'trigger_count', 'version']",
                         str,
+                        t.Literal[
+                            "changes_last_detection_time",
+                            "checkpoint",
+                            "checkpoint_duration_time_exp_avg",
+                            "checkpoint_progress",
+                            "create_time",
+                            "delete_time",
+                            "description",
+                            "dest_index",
+                            "docs_per_second",
+                            "documents_deleted",
+                            "documents_indexed",
+                            "documents_processed",
+                            "frequency",
+                            "id",
+                            "index_failure",
+                            "index_time",
+                            "index_total",
+                            "indexed_documents_exp_avg",
+                            "last_search_time",
+                            "max_page_search_size",
+                            "pages_processed",
+                            "pipeline",
+                            "processed_documents_exp_avg",
+                            "processing_time",
+                            "reason",
+                            "search_failure",
+                            "search_time",
+                            "search_total",
+                            "source_index",
+                            "state",
+                            "transform_type",
+                            "trigger_count",
+                            "version",
+                        ],
                     ]
                 ],
                 t.Union[
-                    "t.Literal['changes_last_detection_time', 'checkpoint', 'checkpoint_duration_time_exp_avg', 'checkpoint_progress', 'create_time', 'delete_time', 'description', 'dest_index', 'docs_per_second', 'documents_deleted', 'documents_indexed', 'documents_processed', 'frequency', 'id', 'index_failure', 'index_time', 'index_total', 'indexed_documents_exp_avg', 'last_search_time', 'max_page_search_size', 'pages_processed', 'pipeline', 'processed_documents_exp_avg', 'processing_time', 'reason', 'search_failure', 'search_time', 'search_total', 'source_index', 'state', 'transform_type', 'trigger_count', 'version']",
                     str,
+                    t.Literal[
+                        "changes_last_detection_time",
+                        "checkpoint",
+                        "checkpoint_duration_time_exp_avg",
+                        "checkpoint_progress",
+                        "create_time",
+                        "delete_time",
+                        "description",
+                        "dest_index",
+                        "docs_per_second",
+                        "documents_deleted",
+                        "documents_indexed",
+                        "documents_processed",
+                        "frequency",
+                        "id",
+                        "index_failure",
+                        "index_time",
+                        "index_total",
+                        "indexed_documents_exp_avg",
+                        "last_search_time",
+                        "max_page_search_size",
+                        "pages_processed",
+                        "pipeline",
+                        "processed_documents_exp_avg",
+                        "processing_time",
+                        "reason",
+                        "search_failure",
+                        "search_time",
+                        "search_total",
+                        "source_index",
+                        "state",
+                        "transform_type",
+                        "trigger_count",
+                        "version",
+                    ],
                 ],
             ]
         ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         s: t.Optional[
             t.Union[
                 t.Sequence[
                     t.Union[
-                        "t.Literal['changes_last_detection_time', 'checkpoint', 'checkpoint_duration_time_exp_avg', 'checkpoint_progress', 'create_time', 'delete_time', 'description', 'dest_index', 'docs_per_second', 'documents_deleted', 'documents_indexed', 'documents_processed', 'frequency', 'id', 'index_failure', 'index_time', 'index_total', 'indexed_documents_exp_avg', 'last_search_time', 'max_page_search_size', 'pages_processed', 'pipeline', 'processed_documents_exp_avg', 'processing_time', 'reason', 'search_failure', 'search_time', 'search_total', 'source_index', 'state', 'transform_type', 'trigger_count', 'version']",
                         str,
+                        t.Literal[
+                            "changes_last_detection_time",
+                            "checkpoint",
+                            "checkpoint_duration_time_exp_avg",
+                            "checkpoint_progress",
+                            "create_time",
+                            "delete_time",
+                            "description",
+                            "dest_index",
+                            "docs_per_second",
+                            "documents_deleted",
+                            "documents_indexed",
+                            "documents_processed",
+                            "frequency",
+                            "id",
+                            "index_failure",
+                            "index_time",
+                            "index_total",
+                            "indexed_documents_exp_avg",
+                            "last_search_time",
+                            "max_page_search_size",
+                            "pages_processed",
+                            "pipeline",
+                            "processed_documents_exp_avg",
+                            "processing_time",
+                            "reason",
+                            "search_failure",
+                            "search_time",
+                            "search_total",
+                            "source_index",
+                            "state",
+                            "transform_type",
+                            "trigger_count",
+                            "version",
+                        ],
                     ]
                 ],
                 t.Union[
-                    "t.Literal['changes_last_detection_time', 'checkpoint', 'checkpoint_duration_time_exp_avg', 'checkpoint_progress', 'create_time', 'delete_time', 'description', 'dest_index', 'docs_per_second', 'documents_deleted', 'documents_indexed', 'documents_processed', 'frequency', 'id', 'index_failure', 'index_time', 'index_total', 'indexed_documents_exp_avg', 'last_search_time', 'max_page_search_size', 'pages_processed', 'pipeline', 'processed_documents_exp_avg', 'processing_time', 'reason', 'search_failure', 'search_time', 'search_total', 'source_index', 'state', 'transform_type', 'trigger_count', 'version']",
                     str,
+                    t.Literal[
+                        "changes_last_detection_time",
+                        "checkpoint",
+                        "checkpoint_duration_time_exp_avg",
+                        "checkpoint_progress",
+                        "create_time",
+                        "delete_time",
+                        "description",
+                        "dest_index",
+                        "docs_per_second",
+                        "documents_deleted",
+                        "documents_indexed",
+                        "documents_processed",
+                        "frequency",
+                        "id",
+                        "index_failure",
+                        "index_time",
+                        "index_total",
+                        "indexed_documents_exp_avg",
+                        "last_search_time",
+                        "max_page_search_size",
+                        "pages_processed",
+                        "pipeline",
+                        "processed_documents_exp_avg",
+                        "processing_time",
+                        "reason",
+                        "search_failure",
+                        "search_time",
+                        "search_total",
+                        "source_index",
+                        "state",
+                        "transform_type",
+                        "trigger_count",
+                        "version",
+                    ],
                 ],
             ]
         ] = None,
         size: t.Optional[int] = None,
         time: t.Optional[
-            t.Union["t.Literal['d', 'h', 'm', 'micros', 'ms', 'nanos', 's']", str]
+            t.Union[str, t.Literal["d", "h", "m", "micros", "ms", "nanos", "s"]]
         ] = None,
         v: t.Optional[bool] = None,
     ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
         """
-        Gets configuration and usage information about transforms.
+        Returns configuration and usage information about transforms. IMPORTANT: cat
+        APIs are only intended for human consumption using the Kibana console or command
+        line. They are not intended for use by applications. For application consumption,
+        use the get transform statistics API.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.13/cat-transforms.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-transforms.html>`_
 
         :param transform_id: A transform identifier or a wildcard expression. If you
             do not specify one of these options, the API returns information for all