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

elasticsearch/_sync/client/monitoring.py

@@ -31,7 +31,7 @@ class MonitoringClient(NamespacedClient):
     def bulk(
         self,
         *,
-        interval: t.Union["t.Literal[-1]", "t.Literal[0]", str],
+        interval: t.Union[str, t.Literal[-1], t.Literal[0]],
         operations: t.Optional[t.Sequence[t.Mapping[str, t.Any]]] = None,
         body: t.Optional[t.Sequence[t.Mapping[str, t.Any]]] = None,
         system_api_version: str,
@@ -44,7 +44,7 @@ class MonitoringClient(NamespacedClient):
         """
         Used by the monitoring features to send monitoring data.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/monitor-elasticsearch-cluster.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/monitor-elasticsearch-cluster.html>`_
 
         :param interval: Collection interval (e.g., '10s' or '10000ms') of the payload
         :param operations:

elasticsearch/_sync/client/nodes.py

@@ -37,9 +37,10 @@ class NodesClient(NamespacedClient):
         pretty: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Removes the archived repositories metering information present in the cluster.
+        You can use this API to clear the archived repositories metering information
+        in the cluster.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/clear-repositories-metering-archive-api.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/clear-repositories-metering-archive-api.html>`_
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
             information. All the nodes selective options are explained [here](https://www.elastic.co/guide/en/elasticsearch/reference/current/cluster.html#cluster-nodes).
@@ -85,9 +86,13 @@ class NodesClient(NamespacedClient):
         pretty: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Returns cluster repositories metering information.
+        You can use the cluster repositories metering API to retrieve repositories metering
+        information in a cluster. This API exposes monotonically non-decreasing counters
+        and it’s expected that clients would durably store the information needed to
+        compute aggregations over a period of time. Additionally, the information exposed
+        by this API is volatile, meaning that it won’t be present after node restarts.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/get-repositories-metering-api.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/get-repositories-metering-api.html>`_
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
             information. All the nodes selective options are explained [here](https://www.elastic.co/guide/en/elasticsearch/reference/current/cluster.html#cluster-nodes).
@@ -124,25 +129,24 @@ class NodesClient(NamespacedClient):
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
         ignore_idle_threads: t.Optional[bool] = None,
-        interval: t.Optional[t.Union["t.Literal[-1]", "t.Literal[0]", str]] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
-        ] = None,
+        interval: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
         snapshots: t.Optional[int] = None,
         sort: t.Optional[
-            t.Union["t.Literal['block', 'cpu', 'gpu', 'mem', 'wait']", str]
+            t.Union[str, t.Literal["block", "cpu", "gpu", "mem", "wait"]]
         ] = None,
         threads: t.Optional[int] = None,
-        timeout: t.Optional[t.Union["t.Literal[-1]", "t.Literal[0]", str]] = None,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         type: t.Optional[
-            t.Union["t.Literal['block', 'cpu', 'gpu', 'mem', 'wait']", str]
+            t.Union[str, t.Literal["block", "cpu", "gpu", "mem", "wait"]]
         ] = None,
     ) -> TextApiResponse:
         """
-        Returns information about hot threads on each node in the cluster.
+        This API yields a breakdown of the hot threads on each selected node in the cluster.
+        The output is plain text with a breakdown of each node’s top hot threads.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cluster-nodes-hot-threads.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cluster-nodes-hot-threads.html>`_
 
         :param node_id: List of node IDs or names used to limit returned information.
         :param ignore_idle_threads: If true, known idle threads (e.g. waiting in a socket
@@ -210,16 +214,14 @@ class NodesClient(NamespacedClient):
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         flat_settings: t.Optional[bool] = None,
         human: 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,
-        timeout: t.Optional[t.Union["t.Literal[-1]", "t.Literal[0]", str]] = None,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Returns information about nodes in the cluster.
+        Returns cluster nodes information.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cluster-nodes-info.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cluster-nodes-info.html>`_
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
             information.
@@ -282,13 +284,13 @@ class NodesClient(NamespacedClient):
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
         secure_settings_password: t.Optional[str] = None,
-        timeout: t.Optional[t.Union["t.Literal[-1]", "t.Literal[0]", str]] = None,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Reloads secure settings.
+        Reloads the keystore on nodes in the cluster.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/secure-settings.html#reloadable-secure-settings>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/secure-settings.html#reloadable-secure-settings>`_
 
         :param node_id: The names of particular nodes in the cluster to target.
         :param secure_settings_password: The password for the Elasticsearch keystore.
@@ -349,19 +351,17 @@ class NodesClient(NamespacedClient):
         include_segment_file_sizes: t.Optional[bool] = None,
         include_unloaded_segments: t.Optional[bool] = None,
         level: t.Optional[
-            t.Union["t.Literal['cluster', 'indices', 'shards']", str]
-        ] = None,
-        master_timeout: t.Optional[
-            t.Union["t.Literal[-1]", "t.Literal[0]", str]
+            t.Union[str, t.Literal["cluster", "indices", "shards"]]
         ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
-        timeout: t.Optional[t.Union["t.Literal[-1]", "t.Literal[0]", str]] = None,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         types: t.Optional[t.Sequence[str]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Returns statistical information about nodes in the cluster.
+        Returns cluster nodes statistics.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cluster-nodes-stats.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cluster-nodes-stats.html>`_
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
             information.
@@ -473,12 +473,12 @@ class NodesClient(NamespacedClient):
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
-        timeout: t.Optional[t.Union["t.Literal[-1]", "t.Literal[0]", str]] = None,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Returns low-level information about REST actions usage on nodes.
+        Returns information on the usage of features.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cluster-nodes-usage.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cluster-nodes-usage.html>`_
 
         :param node_id: A comma-separated list of node IDs or names to limit the returned
             information; use `_local` to return information from the node you're connecting

elasticsearch/_sync/client/query_rules.py

@@ -0,0 +1,384 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+import typing as t
+
+from elastic_transport import ObjectApiResponse
+
+from ._base import NamespacedClient
+from .utils import SKIP_IN_PATH, _quote, _rewrite_parameters
+
+
+class QueryRulesClient(NamespacedClient):
+
+    @_rewrite_parameters()
+    def delete_rule(
+        self,
+        *,
+        ruleset_id: str,
+        rule_id: str,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        Deletes a query rule within a query ruleset.
+
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/delete-query-rule.html>`_
+
+        :param ruleset_id: The unique identifier of the query ruleset containing the
+            rule to delete
+        :param rule_id: The unique identifier of the query rule within the specified
+            ruleset to delete
+        """
+        if ruleset_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'ruleset_id'")
+        if rule_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'rule_id'")
+        __path_parts: t.Dict[str, str] = {
+            "ruleset_id": _quote(ruleset_id),
+            "rule_id": _quote(rule_id),
+        }
+        __path = f'/_query_rules/{__path_parts["ruleset_id"]}/_rule/{__path_parts["rule_id"]}'
+        __query: t.Dict[str, t.Any] = {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        __headers = {"accept": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "DELETE",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="query_rules.delete_rule",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters()
+    def delete_ruleset(
+        self,
+        *,
+        ruleset_id: str,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        Deletes a query ruleset.
+
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/delete-query-ruleset.html>`_
+
+        :param ruleset_id: The unique identifier of the query ruleset to delete
+        """
+        if ruleset_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'ruleset_id'")
+        __path_parts: t.Dict[str, str] = {"ruleset_id": _quote(ruleset_id)}
+        __path = f'/_query_rules/{__path_parts["ruleset_id"]}'
+        __query: t.Dict[str, t.Any] = {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        __headers = {"accept": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "DELETE",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="query_rules.delete_ruleset",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters()
+    def get_rule(
+        self,
+        *,
+        ruleset_id: str,
+        rule_id: str,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        Returns the details about a query rule within a query ruleset
+
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/get-query-rule.html>`_
+
+        :param ruleset_id: The unique identifier of the query ruleset containing the
+            rule to retrieve
+        :param rule_id: The unique identifier of the query rule within the specified
+            ruleset to retrieve
+        """
+        if ruleset_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'ruleset_id'")
+        if rule_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'rule_id'")
+        __path_parts: t.Dict[str, str] = {
+            "ruleset_id": _quote(ruleset_id),
+            "rule_id": _quote(rule_id),
+        }
+        __path = f'/_query_rules/{__path_parts["ruleset_id"]}/_rule/{__path_parts["rule_id"]}'
+        __query: t.Dict[str, t.Any] = {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        __headers = {"accept": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "GET",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="query_rules.get_rule",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters()
+    def get_ruleset(
+        self,
+        *,
+        ruleset_id: str,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        Returns the details about a query ruleset
+
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/get-query-ruleset.html>`_
+
+        :param ruleset_id: The unique identifier of the query ruleset
+        """
+        if ruleset_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'ruleset_id'")
+        __path_parts: t.Dict[str, str] = {"ruleset_id": _quote(ruleset_id)}
+        __path = f'/_query_rules/{__path_parts["ruleset_id"]}'
+        __query: t.Dict[str, t.Any] = {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        __headers = {"accept": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "GET",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="query_rules.get_ruleset",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        parameter_aliases={"from": "from_"},
+    )
+    def list_rulesets(
+        self,
+        *,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        from_: t.Optional[int] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+        size: t.Optional[int] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        Returns summarized information about existing query rulesets.
+
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/list-query-rulesets.html>`_
+
+        :param from_: Starting offset (default: 0)
+        :param size: specifies a max number of results to get
+        """
+        __path_parts: t.Dict[str, str] = {}
+        __path = "/_query_rules"
+        __query: t.Dict[str, t.Any] = {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if from_ is not None:
+            __query["from"] = from_
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        if size is not None:
+            __query["size"] = size
+        __headers = {"accept": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "GET",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="query_rules.list_rulesets",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("actions", "criteria", "type", "priority"),
+    )
+    def put_rule(
+        self,
+        *,
+        ruleset_id: str,
+        rule_id: str,
+        actions: t.Optional[t.Mapping[str, t.Any]] = None,
+        criteria: t.Optional[
+            t.Union[t.Mapping[str, t.Any], t.Sequence[t.Mapping[str, t.Any]]]
+        ] = None,
+        type: t.Optional[t.Union[str, t.Literal["pinned"]]] = None,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+        priority: t.Optional[int] = None,
+        body: t.Optional[t.Dict[str, t.Any]] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        Creates or updates a query rule within a query ruleset.
+
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/put-query-rule.html>`_
+
+        :param ruleset_id: The unique identifier of the query ruleset containing the
+            rule to be created or updated
+        :param rule_id: The unique identifier of the query rule within the specified
+            ruleset to be created or updated
+        :param actions:
+        :param criteria:
+        :param type:
+        :param priority:
+        """
+        if ruleset_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'ruleset_id'")
+        if rule_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'rule_id'")
+        if actions is None and body is None:
+            raise ValueError("Empty value passed for parameter 'actions'")
+        if criteria is None and body is None:
+            raise ValueError("Empty value passed for parameter 'criteria'")
+        if type is None and body is None:
+            raise ValueError("Empty value passed for parameter 'type'")
+        __path_parts: t.Dict[str, str] = {
+            "ruleset_id": _quote(ruleset_id),
+            "rule_id": _quote(rule_id),
+        }
+        __path = f'/_query_rules/{__path_parts["ruleset_id"]}/_rule/{__path_parts["rule_id"]}'
+        __query: t.Dict[str, t.Any] = {}
+        __body: t.Dict[str, t.Any] = body if body is not None else {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        if not __body:
+            if actions is not None:
+                __body["actions"] = actions
+            if criteria is not None:
+                __body["criteria"] = criteria
+            if type is not None:
+                __body["type"] = type
+            if priority is not None:
+                __body["priority"] = priority
+        __headers = {"accept": "application/json", "content-type": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="query_rules.put_rule",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("rules",),
+    )
+    def put_ruleset(
+        self,
+        *,
+        ruleset_id: str,
+        rules: t.Optional[
+            t.Union[t.Mapping[str, t.Any], t.Sequence[t.Mapping[str, t.Any]]]
+        ] = None,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+        body: t.Optional[t.Dict[str, t.Any]] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        Creates or updates a query ruleset.
+
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/put-query-ruleset.html>`_
+
+        :param ruleset_id: The unique identifier of the query ruleset to be created or
+            updated
+        :param rules:
+        """
+        if ruleset_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'ruleset_id'")
+        if rules is None and body is None:
+            raise ValueError("Empty value passed for parameter 'rules'")
+        __path_parts: t.Dict[str, str] = {"ruleset_id": _quote(ruleset_id)}
+        __path = f'/_query_rules/{__path_parts["ruleset_id"]}'
+        __query: t.Dict[str, t.Any] = {}
+        __body: t.Dict[str, t.Any] = body if body is not None else {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        if not __body:
+            if rules is not None:
+                __body["rules"] = rules
+        __headers = {"accept": "application/json", "content-type": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="query_rules.put_ruleset",
+            path_parts=__path_parts,
+        )

elasticsearch/_sync/client/rollup.py

@@ -38,7 +38,7 @@ class RollupClient(NamespacedClient):
         """
         Deletes an existing rollup job.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/rollup-delete-job.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/rollup-delete-job.html>`_
 
         :param id: Identifier for the job.
         """
@@ -78,7 +78,7 @@ class RollupClient(NamespacedClient):
         """
         Retrieves the configuration, stats, and status of rollup jobs.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/rollup-get-job.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/rollup-get-job.html>`_
 
         :param id: Identifier for the rollup job. If it is `_all` or omitted, the API
             returns all rollup jobs.
@@ -123,7 +123,7 @@ class RollupClient(NamespacedClient):
         Returns the capabilities of any rollup jobs that have been configured for a specific
         index or index pattern.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/rollup-get-rollup-caps.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/rollup-get-rollup-caps.html>`_
 
         :param id: Index, indices or index-pattern to return rollup capabilities for.
             `_all` may be used to fetch rollup capabilities from all jobs.
@@ -165,10 +165,10 @@ class RollupClient(NamespacedClient):
         pretty: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Returns the rollup capabilities of all jobs inside of a rollup index (e.g. the
-        index where rollup data is stored).
+        Returns the rollup capabilities of all jobs inside of a rollup index (for example,
+        the index where rollup data is stored).
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/rollup-get-rollup-index-caps.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/rollup-get-rollup-index-caps.html>`_
 
         :param index: Data stream or index to check for rollup capabilities. Wildcard
             (`*`) expressions are supported.
@@ -224,13 +224,13 @@ class RollupClient(NamespacedClient):
         human: t.Optional[bool] = None,
         metrics: t.Optional[t.Sequence[t.Mapping[str, t.Any]]] = None,
         pretty: t.Optional[bool] = None,
-        timeout: t.Optional[t.Union["t.Literal[-1]", "t.Literal[0]", str]] = None,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         Creates a rollup job.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/rollup-put-job.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/rollup-put-job.html>`_
 
         :param id: Identifier for the rollup job. This can be any alphanumeric string
             and uniquely identifies the data that is associated with the rollup job.
@@ -344,9 +344,9 @@ class RollupClient(NamespacedClient):
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Enables searching rolled-up data using the standard query DSL.
+        Enables searching rolled-up data using the standard Query DSL.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/rollup-search.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/rollup-search.html>`_
 
         :param index: Enables searching rolled-up data using the standard Query DSL.
         :param aggregations: Specifies aggregations.
@@ -409,7 +409,7 @@ class RollupClient(NamespacedClient):
         """
         Starts an existing, stopped rollup job.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/rollup-start-job.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/rollup-start-job.html>`_
 
         :param id: Identifier for the rollup job.
         """
@@ -445,13 +445,13 @@ class RollupClient(NamespacedClient):
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
-        timeout: t.Optional[t.Union["t.Literal[-1]", "t.Literal[0]", str]] = None,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         wait_for_completion: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         Stops an existing, started rollup job.
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.14/rollup-stop-job.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.15/rollup-stop-job.html>`_
 
         :param id: Identifier for the rollup job.
         :param timeout: If `wait_for_completion` is `true`, the API blocks for (at maximum)