elasticsearch 8.17.1__py3-none-any.whl → 9.0.0__py3-none-any.whl

elasticsearch/_async/client/esql.py

@@ -20,7 +20,7 @@ import typing as t
 from elastic_transport import ObjectApiResponse
 
 from ._base import NamespacedClient
-from .utils import _rewrite_parameters
+from .utils import SKIP_IN_PATH, _quote, _rewrite_parameters
 
 
 class EsqlClient(NamespacedClient):
@@ -30,14 +30,16 @@ class EsqlClient(NamespacedClient):
             "query",
             "columnar",
             "filter",
+            "include_ccs_metadata",
             "locale",
             "params",
             "profile",
             "tables",
+            "wait_for_completion_timeout",
         ),
         ignore_deprecated_options={"params"},
     )
-    async def query(
+    async def async_query(
         self,
         *,
         query: t.Optional[str] = None,
@@ -56,10 +58,343 @@ class EsqlClient(NamespacedClient):
             ]
         ] = None,
         human: t.Optional[bool] = None,
+        include_ccs_metadata: t.Optional[bool] = None,
+        keep_alive: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+        keep_on_completion: t.Optional[bool] = None,
         locale: t.Optional[str] = None,
-        params: t.Optional[
-            t.Sequence[t.Union[None, bool, float, int, str, t.Any]]
+        params: t.Optional[t.Sequence[t.Union[None, bool, float, int, str]]] = None,
+        pretty: t.Optional[bool] = None,
+        profile: t.Optional[bool] = None,
+        tables: t.Optional[
+            t.Mapping[str, t.Mapping[str, t.Mapping[str, t.Any]]]
+        ] = None,
+        wait_for_completion_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]:
+        """
+        .. raw:: html
+
+          <p>Run an async ES|QL query.
+          Asynchronously run an ES|QL (Elasticsearch query language) query, monitor its progress, and retrieve results when they become available.</p>
+          <p>The API accepts the same parameters and request body as the synchronous query API, along with additional async related properties.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-esql-async-query>`_
+
+        :param query: The ES|QL query API accepts an ES|QL query string in the query
+            parameter, runs it, and returns the results.
+        :param columnar: By default, ES|QL returns results as rows. For example, FROM
+            returns each individual document as one row. For the JSON, YAML, CBOR and
+            smile formats, ES|QL can return the results in a columnar fashion where one
+            row represents all the values of a certain column in the results.
+        :param delimiter: The character to use between values within a CSV row. It is
+            valid only for the CSV format.
+        :param drop_null_columns: Indicates whether columns that are entirely `null`
+            will be removed from the `columns` and `values` portion of the results. If
+            `true`, the response will include an extra section under the name `all_columns`
+            which has the name of all the columns.
+        :param filter: Specify a Query DSL query in the filter parameter to filter the
+            set of documents that an ES|QL query runs on.
+        :param format: A short version of the Accept header, for example `json` or `yaml`.
+        :param include_ccs_metadata: When set to `true` and performing a cross-cluster
+            query, the response will include an extra `_clusters` object with information
+            about the clusters that participated in the search along with info such as
+            shards count.
+        :param keep_alive: The period for which the query and its results are stored
+            in the cluster. The default period is five days. When this period expires,
+            the query and its results are deleted, even if the query is still ongoing.
+            If the `keep_on_completion` parameter is false, Elasticsearch only stores
+            async queries that do not complete within the period set by the `wait_for_completion_timeout`
+            parameter, regardless of this value.
+        :param keep_on_completion: Indicates whether the query and its results are stored
+            in the cluster. If false, the query and its results are stored in the cluster
+            only if the request does not complete during the period set by the `wait_for_completion_timeout`
+            parameter.
+        :param locale:
+        :param params: To avoid any attempts of hacking or code injection, extract the
+            values in a separate list of parameters. Use question mark placeholders (?)
+            in the query string for each of the parameters.
+        :param profile: If provided and `true` the response will include an extra `profile`
+            object with information on how the query was executed. This information is
+            for human debugging and its format can change at any time but it can give
+            some insight into the performance of each part of the query.
+        :param tables: Tables to use with the LOOKUP operation. The top level key is
+            the table name and the next level key is the column name.
+        :param wait_for_completion_timeout: The period to wait for the request to finish.
+            By default, the request waits for 1 second for the query results. If the
+            query completes during this period, results are returned Otherwise, a query
+            ID is returned that can later be used to retrieve the results.
+        """
+        if query is None and body is None:
+            raise ValueError("Empty value passed for parameter 'query'")
+        __path_parts: t.Dict[str, str] = {}
+        __path = "/_query/async"
+        __query: t.Dict[str, t.Any] = {}
+        __body: t.Dict[str, t.Any] = body if body is not None else {}
+        if delimiter is not None:
+            __query["delimiter"] = delimiter
+        if drop_null_columns is not None:
+            __query["drop_null_columns"] = drop_null_columns
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if format is not None:
+            __query["format"] = format
+        if human is not None:
+            __query["human"] = human
+        if keep_alive is not None:
+            __query["keep_alive"] = keep_alive
+        if keep_on_completion is not None:
+            __query["keep_on_completion"] = keep_on_completion
+        if pretty is not None:
+            __query["pretty"] = pretty
+        if not __body:
+            if query is not None:
+                __body["query"] = query
+            if columnar is not None:
+                __body["columnar"] = columnar
+            if filter is not None:
+                __body["filter"] = filter
+            if include_ccs_metadata is not None:
+                __body["include_ccs_metadata"] = include_ccs_metadata
+            if locale is not None:
+                __body["locale"] = locale
+            if params is not None:
+                __body["params"] = params
+            if profile is not None:
+                __body["profile"] = profile
+            if tables is not None:
+                __body["tables"] = tables
+            if wait_for_completion_timeout is not None:
+                __body["wait_for_completion_timeout"] = wait_for_completion_timeout
+        __headers = {"accept": "application/json", "content-type": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "POST",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="esql.async_query",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters()
+    async def async_query_delete(
+        self,
+        *,
+        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]:
+        """
+        .. raw:: html
+
+          <p>Delete an async ES|QL query.
+          If the query is still running, it is cancelled.
+          Otherwise, the stored results are deleted.</p>
+          <p>If the Elasticsearch security features are enabled, only the following users can use this API to delete a query:</p>
+          <ul>
+          <li>The authenticated user that submitted the original query request</li>
+          <li>Users with the <code>cancel_task</code> cluster privilege</li>
+          </ul>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-esql-async-query-delete>`_
+
+        :param id: The unique identifier of the query. A query ID is provided in the
+            ES|QL async query API response for a query that does not complete in the
+            designated time. A query ID is also provided when the request was submitted
+            with the `keep_on_completion` parameter set to `true`.
+        """
+        if id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'id'")
+        __path_parts: t.Dict[str, str] = {"id": _quote(id)}
+        __path = f'/_query/async/{__path_parts["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 await self.perform_request(  # type: ignore[return-value]
+            "DELETE",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="esql.async_query_delete",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters()
+    async def async_query_get(
+        self,
+        *,
+        id: str,
+        drop_null_columns: t.Optional[bool] = None,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        keep_alive: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+        pretty: t.Optional[bool] = None,
+        wait_for_completion_timeout: t.Optional[
+            t.Union[str, t.Literal[-1], t.Literal[0]]
+        ] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Get async ES|QL query results.
+          Get the current status and available results or stored results for an ES|QL asynchronous query.
+          If the Elasticsearch security features are enabled, only the user who first submitted the ES|QL query can retrieve the results using this API.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-esql-async-query-get>`_
+
+        :param id: The unique identifier of the query. A query ID is provided in the
+            ES|QL async query API response for a query that does not complete in the
+            designated time. A query ID is also provided when the request was submitted
+            with the `keep_on_completion` parameter set to `true`.
+        :param drop_null_columns: Indicates whether columns that are entirely `null`
+            will be removed from the `columns` and `values` portion of the results. If
+            `true`, the response will include an extra section under the name `all_columns`
+            which has the name of all the columns.
+        :param keep_alive: The period for which the query and its results are stored
+            in the cluster. When this period expires, the query and its results are deleted,
+            even if the query is still ongoing.
+        :param wait_for_completion_timeout: The period to wait for the request to finish.
+            By default, the request waits for complete query results. If the request
+            completes during the period specified in this parameter, complete query results
+            are returned. Otherwise, the response returns an `is_running` value of `true`
+            and no results.
+        """
+        if id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'id'")
+        __path_parts: t.Dict[str, str] = {"id": _quote(id)}
+        __path = f'/_query/async/{__path_parts["id"]}'
+        __query: t.Dict[str, t.Any] = {}
+        if drop_null_columns is not None:
+            __query["drop_null_columns"] = drop_null_columns
+        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 keep_alive is not None:
+            __query["keep_alive"] = keep_alive
+        if pretty is not None:
+            __query["pretty"] = pretty
+        if wait_for_completion_timeout is not None:
+            __query["wait_for_completion_timeout"] = wait_for_completion_timeout
+        __headers = {"accept": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "GET",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="esql.async_query_get",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters()
+    async def async_query_stop(
+        self,
+        *,
+        id: str,
+        drop_null_columns: t.Optional[bool] = 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,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Stop async ES|QL query.</p>
+          <p>This API interrupts the query execution and returns the results so far.
+          If the Elasticsearch security features are enabled, only the user who first submitted the ES|QL query can stop it.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-esql-async-query-stop>`_
+
+        :param id: The unique identifier of the query. A query ID is provided in the
+            ES|QL async query API response for a query that does not complete in the
+            designated time. A query ID is also provided when the request was submitted
+            with the `keep_on_completion` parameter set to `true`.
+        :param drop_null_columns: Indicates whether columns that are entirely `null`
+            will be removed from the `columns` and `values` portion of the results. If
+            `true`, the response will include an extra section under the name `all_columns`
+            which has the name of all the columns.
+        """
+        if id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'id'")
+        __path_parts: t.Dict[str, str] = {"id": _quote(id)}
+        __path = f'/_query/async/{__path_parts["id"]}/stop'
+        __query: t.Dict[str, t.Any] = {}
+        if drop_null_columns is not None:
+            __query["drop_null_columns"] = drop_null_columns
+        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 await self.perform_request(  # type: ignore[return-value]
+            "POST",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="esql.async_query_stop",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "query",
+            "columnar",
+            "filter",
+            "include_ccs_metadata",
+            "locale",
+            "params",
+            "profile",
+            "tables",
+        ),
+        ignore_deprecated_options={"params"},
+    )
+    async def query(
+        self,
+        *,
+        query: t.Optional[str] = None,
+        columnar: t.Optional[bool] = None,
+        delimiter: t.Optional[str] = None,
+        drop_null_columns: t.Optional[bool] = None,
+        error_trace: t.Optional[bool] = None,
+        filter: t.Optional[t.Mapping[str, t.Any]] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        format: t.Optional[
+            t.Union[
+                str,
+                t.Literal[
+                    "arrow", "cbor", "csv", "json", "smile", "tsv", "txt", "yaml"
+                ],
+            ]
+        ] = None,
+        human: t.Optional[bool] = None,
+        include_ccs_metadata: t.Optional[bool] = None,
+        locale: t.Optional[str] = None,
+        params: t.Optional[t.Sequence[t.Union[None, bool, float, int, str]]] = None,
         pretty: t.Optional[bool] = None,
         profile: t.Optional[bool] = None,
         tables: t.Optional[
@@ -68,10 +403,13 @@ class EsqlClient(NamespacedClient):
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Run an ES|QL query. Get search results for an ES|QL (Elasticsearch query language)
-        query.
+        .. raw:: html
+
+          <p>Run an ES|QL query.
+          Get search results for an ES|QL (Elasticsearch query language) query.</p>
+
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.17/esql-rest.html>`_
+        `<https://www.elastic.co/docs/explore-analyze/query-filter/languages/esql-rest>`_
 
         :param query: The ES|QL query API accepts an ES|QL query string in the query
             parameter, runs it, and returns the results.
@@ -88,6 +426,10 @@ class EsqlClient(NamespacedClient):
         :param filter: Specify a Query DSL query in the filter parameter to filter the
             set of documents that an ES|QL query runs on.
         :param format: A short version of the Accept header, e.g. json, yaml.
+        :param include_ccs_metadata: When set to `true` and performing a cross-cluster
+            query, the response will include an extra `_clusters` object with information
+            about the clusters that participated in the search along with info such as
+            shards count.
         :param locale:
         :param params: To avoid any attempts of hacking or code injection, extract the
             values in a separate list of parameters. Use question mark placeholders (?)
@@ -126,6 +468,8 @@ class EsqlClient(NamespacedClient):
                 __body["columnar"] = columnar
             if filter is not None:
                 __body["filter"] = filter
+            if include_ccs_metadata is not None:
+                __body["include_ccs_metadata"] = include_ccs_metadata
             if locale is not None:
                 __body["locale"] = locale
             if params is not None:

elasticsearch/_async/client/features.py

@@ -32,22 +32,25 @@ class FeaturesClient(NamespacedClient):
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Get the features. Get a list of features that can be included in snapshots using
-        the `feature_states` field when creating a snapshot. You can use this API to
-        determine which feature states to include when taking a snapshot. By default,
-        all feature states are included in a snapshot if that snapshot includes the global
-        state, or none if it does not. A feature state includes one or more system indices
-        necessary for a given feature to function. In order to ensure data integrity,
-        all system indices that comprise a feature state are snapshotted and restored
-        together. The features listed by this API are a combination of built-in features
-        and features defined by plugins. In order for a feature state to be listed in
-        this API and recognized as a valid feature state by the create snapshot API,
-        the plugin that defines that feature must be installed on the master node.
+        .. raw:: html
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.17/get-features-api.html>`_
+          <p>Get the features.
+          Get a list of features that can be included in snapshots using the <code>feature_states</code> field when creating a snapshot.
+          You can use this API to determine which feature states to include when taking a snapshot.
+          By default, all feature states are included in a snapshot if that snapshot includes the global state, or none if it does not.</p>
+          <p>A feature state includes one or more system indices necessary for a given feature to function.
+          In order to ensure data integrity, all system indices that comprise a feature state are snapshotted and restored together.</p>
+          <p>The features listed by this API are a combination of built-in features and features defined by plugins.
+          In order for a feature state to be listed in this API and recognized as a valid feature state by the create snapshot API, the plugin that defines that feature must be installed on the master node.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-features-get-features>`_
+
+        :param master_timeout: Period to wait for a connection to the master node.
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_features"
@@ -58,6 +61,8 @@ class FeaturesClient(NamespacedClient):
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
+        if master_timeout is not None:
+            __query["master_timeout"] = master_timeout
         if pretty is not None:
             __query["pretty"] = pretty
         __headers = {"accept": "application/json"}
@@ -78,25 +83,28 @@ class FeaturesClient(NamespacedClient):
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Reset the features. Clear all of the state information stored in system indices
-        by Elasticsearch features, including the security and machine learning indices.
-        WARNING: Intended for development and testing use only. Do not reset features
-        on a production cluster. Return a cluster to the same state as a new installation
-        by resetting the feature state for all Elasticsearch features. This deletes all
-        state information stored in system indices. The response code is HTTP 200 if
-        the state is successfully reset for all features. It is HTTP 500 if the reset
-        operation failed for any feature. Note that select features might provide a way
-        to reset particular system indices. Using this API resets all features, both
-        those that are built-in and implemented as plugins. To list the features that
-        will be affected, use the get features API. IMPORTANT: The features installed
-        on the node you submit this request to are the features that will be reset. Run
-        on the master node if you have any doubts about which plugins are installed on
-        individual nodes.
+        .. raw:: html
+
+          <p>Reset the features.
+          Clear all of the state information stored in system indices by Elasticsearch features, including the security and machine learning indices.</p>
+          <p>WARNING: Intended for development and testing use only. Do not reset features on a production cluster.</p>
+          <p>Return a cluster to the same state as a new installation by resetting the feature state for all Elasticsearch features.
+          This deletes all state information stored in system indices.</p>
+          <p>The response code is HTTP 200 if the state is successfully reset for all features.
+          It is HTTP 500 if the reset operation failed for any feature.</p>
+          <p>Note that select features might provide a way to reset particular system indices.
+          Using this API resets all features, both those that are built-in and implemented as plugins.</p>
+          <p>To list the features that will be affected, use the get features API.</p>
+          <p>IMPORTANT: The features installed on the node you submit this request to are the features that will be reset. Run on the master node if you have any doubts about which plugins are installed on individual nodes.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-features-reset-features>`_
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.17/modules-snapshots.html>`_
+        :param master_timeout: Period to wait for a connection to the master node.
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_features/_reset"
@@ -107,6 +115,8 @@ class FeaturesClient(NamespacedClient):
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
+        if master_timeout is not None:
+            __query["master_timeout"] = master_timeout
         if pretty is not None:
             __query["pretty"] = pretty
         __headers = {"accept": "application/json"}

elasticsearch/_async/client/fleet.py

@@ -46,10 +46,14 @@ class FleetClient(NamespacedClient):
         wait_for_index: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Returns the current global checkpoints for an index. This API is design for internal
-        use by the fleet server project.
+        .. raw:: html
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.17/get-global-checkpoints.html>`_
+          <p>Get global checkpoints.</p>
+          <p>Get the current global checkpoints for an index.
+          This API is designed for internal use by the Fleet server project.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-fleet>`_
 
         :param index: A single index or index alias that resolves to a single index.
         :param checkpoints: A comma separated list of previous global checkpoints. When
@@ -132,10 +136,15 @@ class FleetClient(NamespacedClient):
         wait_for_checkpoints: t.Optional[t.Sequence[int]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Executes several [fleet searches](https://www.elastic.co/guide/en/elasticsearch/reference/current/fleet-search.html)
-        with a single API request. The API follows the same structure as the [multi search](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-multi-search.html)
-        API. However, similar to the fleet search API, it supports the wait_for_checkpoints
-        parameter.
+        .. raw:: html
+
+          <p>Run multiple Fleet searches.
+          Run several Fleet searches with a single API request.
+          The API follows the same structure as the multi search API.
+          However, similar to the Fleet search API, it supports the <code>wait_for_checkpoints</code> parameter.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-fleet-msearch>`_
 
         :param searches:
         :param index: A single target to search. If the target is an index alias, it
@@ -146,9 +155,9 @@ class FleetClient(NamespacedClient):
             example, a request targeting foo*,bar* returns an error if an index starts
             with foo but no index starts with bar.
         :param allow_partial_search_results: If true, returns partial results if there
-            are shard request timeouts or [shard failures](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-replication.html#shard-failures).
-            If false, returns an error with no partial results. Defaults to the configured
-            cluster setting `search.default_allow_partial_results` which is true by default.
+            are shard request timeouts or shard failures. If false, returns an error
+            with no partial results. Defaults to the configured cluster setting `search.default_allow_partial_results`,
+            which is true by default.
         :param ccs_minimize_roundtrips: If true, network roundtrips between the coordinating
             node and remote clusters are minimized for cross-cluster search requests.
         :param expand_wildcards: Type of index that wildcard expressions can match. If
@@ -322,7 +331,6 @@ class FleetClient(NamespacedClient):
         indices_boost: t.Optional[t.Sequence[t.Mapping[str, float]]] = None,
         lenient: t.Optional[bool] = None,
         max_concurrent_shard_requests: t.Optional[int] = None,
-        min_compatible_shard_node: t.Optional[str] = None,
         min_score: t.Optional[float] = None,
         pit: t.Optional[t.Mapping[str, t.Any]] = None,
         post_filter: t.Optional[t.Mapping[str, t.Any]] = None,
@@ -342,7 +350,7 @@ class FleetClient(NamespacedClient):
         script_fields: t.Optional[t.Mapping[str, t.Mapping[str, t.Any]]] = None,
         scroll: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         search_after: t.Optional[
-            t.Sequence[t.Union[None, bool, float, int, str, t.Any]]
+            t.Sequence[t.Union[None, bool, float, int, str]]
         ] = None,
         search_type: t.Optional[
             t.Union[str, t.Literal["dfs_query_then_fetch", "query_then_fetch"]]
@@ -378,9 +386,14 @@ class FleetClient(NamespacedClient):
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        The purpose of the fleet search api is to provide a search api where the search
-        will only be executed after provided checkpoint has been processed and is visible
-        for searches inside of Elasticsearch.
+        .. raw:: html
+
+          <p>Run a Fleet search.
+          The purpose of the Fleet search API is to provide an API where the search will be run only
+          after the provided checkpoint has been processed and is visible for searches inside of Elasticsearch.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-fleet-search>`_
 
         :param index: A single target to search. If the target is an index alias, it
             must resolve to a single index.
@@ -388,9 +401,9 @@ class FleetClient(NamespacedClient):
         :param aggs:
         :param allow_no_indices:
         :param allow_partial_search_results: If true, returns partial results if there
-            are shard request timeouts or [shard failures](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-replication.html#shard-failures).
-            If false, returns an error with no partial results. Defaults to the configured
-            cluster setting `search.default_allow_partial_results` which is true by default.
+            are shard request timeouts or shard failures. If false, returns an error
+            with no partial results. Defaults to the configured cluster setting `search.default_allow_partial_results`,
+            which is true by default.
         :param analyze_wildcard:
         :param analyzer:
         :param batched_reduce_size:
@@ -416,9 +429,8 @@ class FleetClient(NamespacedClient):
         :param indices_boost: Boosts the _score of documents from specified indices.
         :param lenient:
         :param max_concurrent_shard_requests:
-        :param min_compatible_shard_node:
         :param min_score: Minimum _score for matching documents. Documents with a lower
-            _score are not included in the search results.
+            _score are not included in search results and results collected by aggregations.
         :param pit: Limits the search to a point in time (PIT). If you provide a PIT,
             you cannot specify an <index> in the request path.
         :param post_filter:
@@ -531,8 +543,6 @@ class FleetClient(NamespacedClient):
             __query["lenient"] = lenient
         if max_concurrent_shard_requests is not None:
             __query["max_concurrent_shard_requests"] = max_concurrent_shard_requests
-        if min_compatible_shard_node is not None:
-            __query["min_compatible_shard_node"] = min_compatible_shard_node
         if pre_filter_shard_size is not None:
             __query["pre_filter_shard_size"] = pre_filter_shard_size
         if preference is not None:

elasticsearch/_async/client/graph.py

@@ -45,16 +45,17 @@ class GraphClient(NamespacedClient):
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
-        Explore graph analytics. Extract and summarize information about the documents
-        and terms in an Elasticsearch data stream or index. The easiest way to understand
-        the behavior of this API is to use the Graph UI to explore connections. An initial
-        request to the `_explore` API contains a seed query that identifies the documents
-        of interest and specifies the fields that define the vertices and connections
-        you want to include in the graph. Subsequent requests enable you to spider out
-        from one more vertices of interest. You can exclude vertices that have already
-        been returned.
+        .. raw:: html
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.17/graph-explore-api.html>`_
+          <p>Explore graph analytics.
+          Extract and summarize information about the documents and terms in an Elasticsearch data stream or index.
+          The easiest way to understand the behavior of this API is to use the Graph UI to explore connections.
+          An initial request to the <code>_explore</code> API contains a seed query that identifies the documents of interest and specifies the fields that define the vertices and connections you want to include in the graph.
+          Subsequent requests enable you to spider out from one more vertices of interest.
+          You can exclude vertices that have already been returned.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-graph>`_
 
         :param index: Name of the index.
         :param connections: Specifies or more fields from which you want to extract terms