elasticsearch9 9.2.1__py3-none-any.whl → 9.3.0__py3-none-any.whl

elasticsearch9/_async/client/inference.py

@@ -45,6 +45,10 @@ class InferenceClient(NamespacedClient):
         .. raw:: html
 
           <p>Perform completion inference on the service.</p>
+          <p>Get responses for completion tasks.
+          This API works only with the completion task type.</p>
+          <p>IMPORTANT: The inference APIs enable you to use certain services, such as built-in machine learning models (ELSER, E5), models uploaded through Eland, Cohere, OpenAI, Azure, Google AI Studio, Google Vertex AI, Anthropic, Watsonx.ai, or Hugging Face. For built-in models and models uploaded through Eland, the inference APIs offer an alternative way to use and manage trained models. However, if you do not plan to use the inference APIs to use these models or if you want to use non-NLP models, use the machine learning trained model APIs.</p>
+          <p>This API requires the <code>monitor_inference</code> cluster privilege (the built-in <code>inference_admin</code> and <code>inference_user</code> roles grant this privilege).</p>
 
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-inference>`_
@@ -391,19 +395,22 @@ class InferenceClient(NamespacedClient):
           <li>Amazon Bedrock (<code>completion</code>, <code>text_embedding</code>)</li>
           <li>Amazon SageMaker (<code>chat_completion</code>, <code>completion</code>, <code>rerank</code>, <code>sparse_embedding</code>, <code>text_embedding</code>)</li>
           <li>Anthropic (<code>completion</code>)</li>
-          <li>Azure AI Studio (<code>completion</code>, 'rerank', <code>text_embedding</code>)</li>
-          <li>Azure OpenAI (<code>completion</code>, <code>text_embedding</code>)</li>
+          <li>Azure AI Studio (<code>completion</code>, <code>rerank</code>, <code>text_embedding</code>)</li>
+          <li>Azure OpenAI (<code>chat_completion</code>, <code>completion</code>, <code>text_embedding</code>)</li>
           <li>Cohere (<code>completion</code>, <code>rerank</code>, <code>text_embedding</code>)</li>
           <li>DeepSeek (<code>chat_completion</code>, <code>completion</code>)</li>
           <li>Elasticsearch (<code>rerank</code>, <code>sparse_embedding</code>, <code>text_embedding</code> - this service is for built-in models and models uploaded through Eland)</li>
           <li>ELSER (<code>sparse_embedding</code>)</li>
           <li>Google AI Studio (<code>completion</code>, <code>text_embedding</code>)</li>
           <li>Google Vertex AI (<code>chat_completion</code>, <code>completion</code>, <code>rerank</code>, <code>text_embedding</code>)</li>
+          <li>Groq (<code>chat_completion</code>)</li>
           <li>Hugging Face (<code>chat_completion</code>, <code>completion</code>, <code>rerank</code>, <code>text_embedding</code>)</li>
           <li>JinaAI (<code>rerank</code>, <code>text_embedding</code>)</li>
           <li>Llama (<code>chat_completion</code>, <code>completion</code>, <code>text_embedding</code>)</li>
           <li>Mistral (<code>chat_completion</code>, <code>completion</code>, <code>text_embedding</code>)</li>
+          <li>Nvidia (<code>chat_completion</code>, <code>completion</code>, <code>text_embedding</code>, <code>rerank</code>)</li>
           <li>OpenAI (<code>chat_completion</code>, <code>completion</code>, <code>text_embedding</code>)</li>
+          <li>OpenShift AI (<code>chat_completion</code>, <code>completion</code>, <code>rerank</code>, <code>text_embedding</code>)</li>
           <li>VoyageAI (<code>rerank</code>, <code>text_embedding</code>)</li>
           <li>Watsonx inference integration (<code>text_embedding</code>)</li>
           </ul>
@@ -1023,7 +1030,9 @@ class InferenceClient(NamespacedClient):
     async def put_azureopenai(
         self,
         *,
-        task_type: t.Union[str, t.Literal["completion", "text_embedding"]],
+        task_type: t.Union[
+            str, t.Literal["chat_completion", "completion", "text_embedding"]
+        ],
         azureopenai_inference_id: str,
         service: t.Optional[t.Union[str, t.Literal["azureopenai"]]] = None,
         service_settings: t.Optional[t.Mapping[str, t.Any]] = None,
@@ -1060,7 +1069,8 @@ class InferenceClient(NamespacedClient):
         :param service_settings: Settings used to install the inference model. These
             settings are specific to the `azureopenai` service.
         :param chunking_settings: The chunking configuration object. Applies only to
-            the `text_embedding` task type. Not applicable to the `completion` task type.
+            the `text_embedding` task type. Not applicable to the `completion` and `chat_completion`
+            task types.
         :param task_settings: Settings to configure the inference task. These settings
             are specific to the task type you specified.
         :param timeout: Specifies the amount of time to wait for the inference endpoint
@@ -1878,6 +1888,82 @@ class InferenceClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters(
+        body_fields=("service", "service_settings"),
+    )
+    async def put_groq(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["chat_completion"]],
+        groq_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["groq"]]] = None,
+        service_settings: t.Optional[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,
+        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>Create a Groq inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>groq</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-put-groq>`_
+
+        :param task_type: The type of the inference task that the model will perform.
+        :param groq_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            this case, `groq`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `groq` service.
+        :param timeout: Specifies the amount of time to wait for the inference endpoint
+            to be created.
+        """
+        if task_type in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'task_type'")
+        if groq_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'groq_inference_id'")
+        if service is None and body is None:
+            raise ValueError("Empty value passed for parameter 'service'")
+        if service_settings is None and body is None:
+            raise ValueError("Empty value passed for parameter 'service_settings'")
+        __path_parts: t.Dict[str, str] = {
+            "task_type": _quote(task_type),
+            "groq_inference_id": _quote(groq_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["groq_inference_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 timeout is not None:
+            __query["timeout"] = timeout
+        if not __body:
+            if service is not None:
+                __body["service"] = service
+            if service_settings is not None:
+                __body["service_settings"] = service_settings
+        __headers = {"accept": "application/json", "content-type": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_groq",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         body_fields=(
             "service",
@@ -2269,6 +2355,104 @@ class InferenceClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_nvidia(
+        self,
+        *,
+        task_type: t.Union[
+            str, t.Literal["chat_completion", "completion", "rerank", "text_embedding"]
+        ],
+        nvidia_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["nvidia"]]] = None,
+        service_settings: t.Optional[t.Mapping[str, t.Any]] = None,
+        chunking_settings: t.Optional[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,
+        task_settings: t.Optional[t.Mapping[str, t.Any]] = 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]:
+        """
+        .. raw:: html
+
+          <p>Create an Nvidia inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>nvidia</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-put-nvidia>`_
+
+        :param task_type: The type of the inference task that the model will perform.
+            NOTE: The `chat_completion` task type only supports streaming and only through
+            the _stream API.
+        :param nvidia_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            this case, `nvidia`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `nvidia` service.
+        :param chunking_settings: The chunking configuration object. Applies only to
+            the `text_embedding` task type. Not applicable to the `rerank`, `completion`,
+            or `chat_completion` task types.
+        :param task_settings: Settings to configure the inference task. Applies only
+            to the `text_embedding` task type. Not applicable to the `rerank`, `completion`,
+            or `chat_completion` task types. These settings are specific to the task
+            type you specified.
+        :param timeout: Specifies the amount of time to wait for the inference endpoint
+            to be created.
+        """
+        if task_type in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'task_type'")
+        if nvidia_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'nvidia_inference_id'")
+        if service is None and body is None:
+            raise ValueError("Empty value passed for parameter 'service'")
+        if service_settings is None and body is None:
+            raise ValueError("Empty value passed for parameter 'service_settings'")
+        __path_parts: t.Dict[str, str] = {
+            "task_type": _quote(task_type),
+            "nvidia_inference_id": _quote(nvidia_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["nvidia_inference_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 timeout is not None:
+            __query["timeout"] = timeout
+        if not __body:
+            if service is not None:
+                __body["service"] = service
+            if service_settings is not None:
+                __body["service_settings"] = service_settings
+            if chunking_settings is not None:
+                __body["chunking_settings"] = chunking_settings
+            if task_settings is not None:
+                __body["task_settings"] = task_settings
+        __headers = {"accept": "application/json", "content-type": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_nvidia",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         body_fields=(
             "service",
@@ -2365,6 +2549,106 @@ class InferenceClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_openshift_ai(
+        self,
+        *,
+        task_type: t.Union[
+            str, t.Literal["chat_completion", "completion", "rerank", "text_embedding"]
+        ],
+        openshiftai_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["openshift_ai"]]] = None,
+        service_settings: t.Optional[t.Mapping[str, t.Any]] = None,
+        chunking_settings: t.Optional[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,
+        task_settings: t.Optional[t.Mapping[str, t.Any]] = 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]:
+        """
+        .. raw:: html
+
+          <p>Create an OpenShift AI inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>openshift_ai</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-put-openshift-ai>`_
+
+        :param task_type: The type of the inference task that the model will perform.
+            NOTE: The `chat_completion` task type only supports streaming and only through
+            the _stream API.
+        :param openshiftai_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            this case, `openshift_ai`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `openshift_ai` service.
+        :param chunking_settings: The chunking configuration object. Applies only to
+            the `text_embedding` task type. Not applicable to the `rerank`, `completion`,
+            or `chat_completion` task types.
+        :param task_settings: Settings to configure the inference task. Applies only
+            to the `rerank` task type. Not applicable to the `text_embedding`, `completion`,
+            or `chat_completion` task types. These settings are specific to the task
+            type you specified.
+        :param timeout: Specifies the amount of time to wait for the inference endpoint
+            to be created.
+        """
+        if task_type in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'task_type'")
+        if openshiftai_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'openshiftai_inference_id'"
+            )
+        if service is None and body is None:
+            raise ValueError("Empty value passed for parameter 'service'")
+        if service_settings is None and body is None:
+            raise ValueError("Empty value passed for parameter 'service_settings'")
+        __path_parts: t.Dict[str, str] = {
+            "task_type": _quote(task_type),
+            "openshiftai_inference_id": _quote(openshiftai_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["openshiftai_inference_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 timeout is not None:
+            __query["timeout"] = timeout
+        if not __body:
+            if service is not None:
+                __body["service"] = service
+            if service_settings is not None:
+                __body["service_settings"] = service_settings
+            if chunking_settings is not None:
+                __body["chunking_settings"] = chunking_settings
+            if task_settings is not None:
+                __body["task_settings"] = task_settings
+        __headers = {"accept": "application/json", "content-type": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_openshift_ai",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         body_fields=(
             "service",
@@ -2544,20 +2828,22 @@ class InferenceClient(NamespacedClient):
         )
 
     @_rewrite_parameters(
-        body_fields=("input", "query", "task_settings"),
+        body_fields=("input", "query", "return_documents", "task_settings", "top_n"),
     )
     async def rerank(
         self,
         *,
         inference_id: str,
-        input: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        input: t.Optional[t.Sequence[str]] = None,
         query: t.Optional[str] = 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,
+        return_documents: t.Optional[bool] = None,
         task_settings: t.Optional[t.Any] = None,
         timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+        top_n: t.Optional[int] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -2569,14 +2855,14 @@ class InferenceClient(NamespacedClient):
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-inference>`_
 
         :param inference_id: The unique identifier for the inference endpoint.
-        :param input: The text on which you want to perform the inference task. It can
-            be a single string or an array. > info > Inference endpoints for the `completion`
-            task type currently only support a single string as input.
+        :param input: The documents to rank.
         :param query: Query input.
+        :param return_documents: Include the document text in the response.
         :param task_settings: Task settings for the individual inference request. These
             settings are specific to the task type you specified and override the task
             settings specified when initializing the service.
         :param timeout: The amount of time to wait for the inference request to complete.
+        :param top_n: Limit the response to the top N documents.
         """
         if inference_id in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'inference_id'")
@@ -2603,8 +2889,12 @@ class InferenceClient(NamespacedClient):
                 __body["input"] = input
             if query is not None:
                 __body["query"] = query
+            if return_documents is not None:
+                __body["return_documents"] = return_documents
             if task_settings is not None:
                 __body["task_settings"] = task_settings
+            if top_n is not None:
+                __body["top_n"] = top_n
         __headers = {"accept": "application/json", "content-type": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             "POST",

elasticsearch9/_async/client/ml.py

@@ -1506,7 +1506,7 @@ class MlClient(NamespacedClient):
         self,
         *,
         job_id: str,
-        category_id: t.Optional[str] = None,
+        category_id: t.Optional[int] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         from_: t.Optional[int] = None,
@@ -4861,13 +4861,14 @@ class MlClient(NamespacedClient):
         )
 
     @_rewrite_parameters(
-        body_fields=("allow_no_match", "force", "timeout"),
+        body_fields=("allow_no_match", "close_job", "force", "timeout"),
     )
     async def stop_datafeed(
         self,
         *,
         datafeed_id: str,
         allow_no_match: t.Optional[bool] = None,
+        close_job: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         force: t.Optional[bool] = None,
@@ -4892,6 +4893,7 @@ class MlClient(NamespacedClient):
             `*` as the identifier.
         :param allow_no_match: Refer to the description for the `allow_no_match` query
             parameter.
+        :param close_job: Refer to the description for the `close_job` query parameter.
         :param force: Refer to the description for the `force` query parameter.
         :param timeout: Refer to the description for the `timeout` query parameter.
         """
@@ -4912,6 +4914,8 @@ class MlClient(NamespacedClient):
         if not __body:
             if allow_no_match is not None:
                 __body["allow_no_match"] = allow_no_match
+            if close_job is not None:
+                __body["close_job"] = close_job
             if force is not None:
                 __body["force"] = force
             if timeout is not None:
@@ -5755,7 +5759,7 @@ class MlClient(NamespacedClient):
           <p>Validate an anomaly detection job.</p>
 
 
-        `<https://www.elastic.co/guide/en/machine-learning/9.2/ml-jobs.html>`_
+        `<https://www.elastic.co/guide/en/machine-learning/9.3/ml-jobs.html>`_
 
         :param analysis_config:
         :param analysis_limits:

elasticsearch9/_async/client/nodes.py

@@ -220,7 +220,50 @@ class NodesClient(NamespacedClient):
         self,
         *,
         node_id: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        metric: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        metric: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "_all",
+                            "_none",
+                            "aggregations",
+                            "http",
+                            "indices",
+                            "ingest",
+                            "jvm",
+                            "os",
+                            "plugins",
+                            "process",
+                            "remote_cluster_server",
+                            "settings",
+                            "thread_pool",
+                            "transport",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "_all",
+                        "_none",
+                        "aggregations",
+                        "http",
+                        "indices",
+                        "ingest",
+                        "jvm",
+                        "os",
+                        "plugins",
+                        "process",
+                        "remote_cluster_server",
+                        "settings",
+                        "thread_pool",
+                        "transport",
+                    ],
+                ],
+            ]
+        ] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         flat_settings: t.Optional[bool] = None,
@@ -357,8 +400,120 @@ class NodesClient(NamespacedClient):
         self,
         *,
         node_id: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        metric: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        index_metric: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        metric: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "_all",
+                            "_none",
+                            "adaptive_selection",
+                            "allocations",
+                            "breaker",
+                            "discovery",
+                            "fs",
+                            "http",
+                            "indexing_pressure",
+                            "indices",
+                            "ingest",
+                            "jvm",
+                            "os",
+                            "process",
+                            "repositories",
+                            "script",
+                            "script_cache",
+                            "thread_pool",
+                            "transport",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "_all",
+                        "_none",
+                        "adaptive_selection",
+                        "allocations",
+                        "breaker",
+                        "discovery",
+                        "fs",
+                        "http",
+                        "indexing_pressure",
+                        "indices",
+                        "ingest",
+                        "jvm",
+                        "os",
+                        "process",
+                        "repositories",
+                        "script",
+                        "script_cache",
+                        "thread_pool",
+                        "transport",
+                    ],
+                ],
+            ]
+        ] = None,
+        index_metric: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "_all",
+                            "bulk",
+                            "completion",
+                            "dense_vector",
+                            "docs",
+                            "fielddata",
+                            "flush",
+                            "get",
+                            "indexing",
+                            "mappings",
+                            "merge",
+                            "query_cache",
+                            "recovery",
+                            "refresh",
+                            "request_cache",
+                            "search",
+                            "segments",
+                            "shard_stats",
+                            "sparse_vector",
+                            "store",
+                            "translog",
+                            "warmer",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "_all",
+                        "bulk",
+                        "completion",
+                        "dense_vector",
+                        "docs",
+                        "fielddata",
+                        "flush",
+                        "get",
+                        "indexing",
+                        "mappings",
+                        "merge",
+                        "query_cache",
+                        "recovery",
+                        "refresh",
+                        "request_cache",
+                        "search",
+                        "segments",
+                        "shard_stats",
+                        "sparse_vector",
+                        "store",
+                        "translog",
+                        "warmer",
+                    ],
+                ],
+            ]
+        ] = None,
         completion_fields: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         error_trace: t.Optional[bool] = None,
         fielddata_fields: t.Optional[t.Union[str, t.Sequence[str]]] = None,
@@ -483,7 +638,14 @@ class NodesClient(NamespacedClient):
         self,
         *,
         node_id: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        metric: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        metric: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[str, t.Literal["_all", "aggregations", "rest_actions"]]
+                ],
+                t.Union[str, t.Literal["_all", "aggregations", "rest_actions"]],
+            ]
+        ] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
@@ -502,7 +664,7 @@ class NodesClient(NamespacedClient):
             information. Use `_local` to return information from the node you're connecting
             to, leave empty to get information from all nodes.
         :param metric: Limits the information returned to the specific metrics. A comma-separated
-            list of the following options: `_all`, `rest_actions`.
+            list of the following options: `_all`, `rest_actions`, `aggregations`.
         :param timeout: Period to wait for a response. If no response is received before
             the timeout expires, the request fails and returns an error.
         """