elasticsearch 8.18.0__py3-none-any.whl → 8.19.0__py3-none-any.whl

elasticsearch/_async/client/inference.py

@@ -47,7 +47,7 @@ class InferenceClient(NamespacedClient):
           <p>Perform completion inference on the service</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/post-inference-api.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/post-inference-api.html>`_
 
         :param inference_id: The inference Id
         :param input: Inference input. Either a string or an array of strings.
@@ -123,7 +123,7 @@ class InferenceClient(NamespacedClient):
           <p>Delete an inference endpoint</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/delete-inference-api.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/delete-inference-api.html>`_
 
         :param inference_id: The inference identifier.
         :param task_type: The task type
@@ -197,7 +197,7 @@ class InferenceClient(NamespacedClient):
           <p>Get an inference endpoint</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/get-inference-api.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/get-inference-api.html>`_
 
         :param task_type: The task type
         :param inference_id: The inference Id
@@ -234,6 +234,125 @@ class InferenceClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters(
+        body_fields=("input", "input_type", "query", "task_settings"),
+    )
+    async def inference(
+        self,
+        *,
+        inference_id: str,
+        input: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        task_type: t.Optional[
+            t.Union[
+                str,
+                t.Literal[
+                    "chat_completion",
+                    "completion",
+                    "rerank",
+                    "sparse_embedding",
+                    "text_embedding",
+                ],
+            ]
+        ] = None,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        input_type: t.Optional[str] = None,
+        pretty: t.Optional[bool] = None,
+        query: t.Optional[str] = None,
+        task_settings: t.Optional[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>Perform inference on the service.</p>
+          <p>This API enables you to use machine learning models to perform specific tasks on data that you provide as an input.
+          It returns a response with the results of the tasks.
+          The inference endpoint you use can perform one specific task that has been defined when the endpoint was created with the create inference API.</p>
+          <p>For details about using this API with a service, such as Amazon Bedrock, Anthropic, or HuggingFace, refer to the service-specific documentation.</p>
+          <blockquote>
+          <p>info
+          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>
+          </blockquote>
+
+
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/post-inference-api.html>`_
+
+        :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 task_type: The type of inference task that the model performs.
+        :param input_type: Specifies the input data type for the text embedding model.
+            The `input_type` parameter only applies to Inference Endpoints with the `text_embedding`
+            task type. Possible values include: * `SEARCH` * `INGEST` * `CLASSIFICATION`
+            * `CLUSTERING` Not all services support all values. Unsupported values will
+            trigger a validation exception. Accepted values depend on the configured
+            inference service, refer to the relevant service-specific documentation for
+            more info. > info > The `input_type` parameter specified on the root level
+            of the request body will take precedence over the `input_type` parameter
+            specified in `task_settings`.
+        :param query: The query input, which is required only for the `rerank` task.
+            It is not required for other tasks.
+        :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.
+        """
+        if inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'inference_id'")
+        if input is None and body is None:
+            raise ValueError("Empty value passed for parameter 'input'")
+        __path_parts: t.Dict[str, str]
+        if task_type not in SKIP_IN_PATH and inference_id not in SKIP_IN_PATH:
+            __path_parts = {
+                "task_type": _quote(task_type),
+                "inference_id": _quote(inference_id),
+            }
+            __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["inference_id"]}'
+        elif inference_id not in SKIP_IN_PATH:
+            __path_parts = {"inference_id": _quote(inference_id)}
+            __path = f'/_inference/{__path_parts["inference_id"]}'
+        else:
+            raise ValueError("Couldn't find a path for the given parameters")
+        __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 input is not None:
+                __body["input"] = input
+            if input_type is not None:
+                __body["input_type"] = input_type
+            if query is not None:
+                __body["query"] = query
+            if task_settings is not None:
+                __body["task_settings"] = task_settings
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
+        return await self.perform_request(  # type: ignore[return-value]
+            "POST",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.inference",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         body_name="inference_config",
     )
@@ -259,26 +378,45 @@ class InferenceClient(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[str, t.Literal[-1], t.Literal[0]]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
 
-          <p>Create an inference endpoint.
-          When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
+          <p>Create an inference endpoint.</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, Mistral, Azure OpenAI, 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>The following integrations are available through the inference API. You can find the available task types next to the integration name:</p>
+          <ul>
+          <li>AlibabaCloud AI Search (<code>completion</code>, <code>rerank</code>, <code>sparse_embedding</code>, <code>text_embedding</code>)</li>
+          <li>Amazon Bedrock (<code>completion</code>, <code>text_embedding</code>)</li>
+          <li>Anthropic (<code>completion</code>)</li>
+          <li>Azure AI Studio (<code>completion</code>, <code>text_embedding</code>)</li>
+          <li>Azure OpenAI (<code>completion</code>, <code>text_embedding</code>)</li>
+          <li>Cohere (<code>completion</code>, <code>rerank</code>, <code>text_embedding</code>)</li>
+          <li>DeepSeek (<code>completion</code>, <code>chat_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>rerank</code>, <code>text_embedding</code>)</li>
+          <li>Hugging Face (<code>chat_completion</code>, <code>completion</code>, <code>rerank</code>, <code>text_embedding</code>)</li>
+          <li>Mistral (<code>chat_completion</code>, <code>completion</code>, <code>text_embedding</code>)</li>
+          <li>OpenAI (<code>chat_completion</code>, <code>completion</code>, <code>text_embedding</code>)</li>
+          <li>VoyageAI (<code>text_embedding</code>, <code>rerank</code>)</li>
+          <li>Watsonx inference integration (<code>text_embedding</code>)</li>
+          <li>JinaAI (<code>text_embedding</code>, <code>rerank</code>)</li>
+          </ul>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/put-inference-api.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/put-inference-api.html>`_
 
         :param inference_id: The inference Id
         :param inference_config:
-        :param task_type: The task type
+        :param task_type: The task type. Refer to the integration list in the API description
+            for the available task types.
+        :param timeout: Specifies the amount of time to wait for the inference endpoint
+            to be created.
         """
         if inference_id in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'inference_id'")
@@ -309,6 +447,8 @@ class InferenceClient(NamespacedClient):
             __query["human"] = human
         if pretty is not None:
             __query["pretty"] = pretty
+        if timeout is not None:
+            __query["timeout"] = timeout
         __body = inference_config if inference_config is not None else body
         __headers = {"accept": "application/json", "content-type": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
@@ -344,6 +484,7 @@ class InferenceClient(NamespacedClient):
         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]:
         """
@@ -351,14 +492,9 @@ class InferenceClient(NamespacedClient):
 
           <p>Create an AlibabaCloud AI Search inference endpoint.</p>
           <p>Create an inference endpoint to perform an inference task with the <code>alibabacloud-ai-search</code> service.</p>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-alibabacloud-ai-search.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-alibabacloud-ai-search.html>`_
 
         :param task_type: The type of the inference task that the model will perform.
         :param alibabacloud_inference_id: The unique identifier of the inference endpoint.
@@ -369,6 +505,8 @@ class InferenceClient(NamespacedClient):
         :param chunking_settings: The chunking configuration object.
         :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
+            to be created.
         """
         if task_type in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'task_type'")
@@ -395,6 +533,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -440,25 +580,21 @@ class InferenceClient(NamespacedClient):
         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 Amazon Bedrock inference endpoint.</p>
-          <p>Creates an inference endpoint to perform an inference task with the <code>amazonbedrock</code> service.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>amazonbedrock</code> service.</p>
           <blockquote>
           <p>info
           You need to provide the access and secret keys only once, during the inference model creation. The get inference API does not retrieve your access or secret keys. After creating the inference model, you cannot change the associated key pairs. If you want to use a different access and secret key pair, delete the inference model and recreate it with the same name and the updated keys.</p>
           </blockquote>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-amazon-bedrock.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-amazon-bedrock.html>`_
 
         :param task_type: The type of the inference task that the model will perform.
         :param amazonbedrock_inference_id: The unique identifier of the inference endpoint.
@@ -469,6 +605,8 @@ class InferenceClient(NamespacedClient):
         :param chunking_settings: The chunking configuration object.
         :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
+            to be created.
         """
         if task_type in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'task_type'")
@@ -495,6 +633,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -540,6 +680,7 @@ class InferenceClient(NamespacedClient):
         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]:
         """
@@ -547,14 +688,9 @@ class InferenceClient(NamespacedClient):
 
           <p>Create an Anthropic inference endpoint.</p>
           <p>Create an inference endpoint to perform an inference task with the <code>anthropic</code> service.</p>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-anthropic.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-anthropic.html>`_
 
         :param task_type: The task type. The only valid task type for the model to perform
             is `completion`.
@@ -566,6 +702,8 @@ class InferenceClient(NamespacedClient):
         :param chunking_settings: The chunking configuration object.
         :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
+            to be created.
         """
         if task_type in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'task_type'")
@@ -592,6 +730,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -637,6 +777,7 @@ class InferenceClient(NamespacedClient):
         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]:
         """
@@ -644,14 +785,9 @@ class InferenceClient(NamespacedClient):
 
           <p>Create an Azure AI studio inference endpoint.</p>
           <p>Create an inference endpoint to perform an inference task with the <code>azureaistudio</code> service.</p>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-azure-ai-studio.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-azure-ai-studio.html>`_
 
         :param task_type: The type of the inference task that the model will perform.
         :param azureaistudio_inference_id: The unique identifier of the inference endpoint.
@@ -662,6 +798,8 @@ class InferenceClient(NamespacedClient):
         :param chunking_settings: The chunking configuration object.
         :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
+            to be created.
         """
         if task_type in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'task_type'")
@@ -688,6 +826,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -733,6 +873,7 @@ class InferenceClient(NamespacedClient):
         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]:
         """
@@ -746,14 +887,9 @@ class InferenceClient(NamespacedClient):
           <li><a href="https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/models?tabs=global-standard%2Cstandard-chat-completions#gpt-35">GPT-3.5</a></li>
           </ul>
           <p>The list of embeddings models that you can choose from in your deployment can be found in the <a href="https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/models?tabs=global-standard%2Cstandard-chat-completions#embeddings">Azure models documentation</a>.</p>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-azure-openai.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-azure-openai.html>`_
 
         :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
@@ -766,6 +902,8 @@ class InferenceClient(NamespacedClient):
         :param chunking_settings: The chunking configuration object.
         :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
+            to be created.
         """
         if task_type in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'task_type'")
@@ -792,6 +930,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -837,6 +977,7 @@ class InferenceClient(NamespacedClient):
         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]:
         """
@@ -844,14 +985,9 @@ class InferenceClient(NamespacedClient):
 
           <p>Create a Cohere inference endpoint.</p>
           <p>Create an inference endpoint to perform an inference task with the <code>cohere</code> service.</p>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-cohere.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-cohere.html>`_
 
         :param task_type: The type of the inference task that the model will perform.
         :param cohere_inference_id: The unique identifier of the inference endpoint.
@@ -862,6 +998,8 @@ class InferenceClient(NamespacedClient):
         :param chunking_settings: The chunking configuration object.
         :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
+            to be created.
         """
         if task_type in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'task_type'")
@@ -886,6 +1024,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -910,6 +1050,221 @@ class InferenceClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_custom(
+        self,
+        *,
+        task_type: t.Union[
+            str, t.Literal["completion", "rerank", "sparse_embedding", "text_embedding"]
+        ],
+        custom_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["custom"]]] = 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,
+        body: t.Optional[t.Dict[str, t.Any]] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Create a custom inference endpoint.</p>
+          <p>The custom service gives more control over how to interact with external inference services that aren't explicitly supported through dedicated integrations.
+          The custom service gives you the ability to define the headers, url, query parameters, request body, and secrets.
+          The custom service supports the template replacement functionality, which enables you to define a template that can be replaced with the value associated with that key.
+          Templates are portions of a string that start with <code>${</code> and end with <code>}</code>.
+          The parameters <code>secret_parameters</code> and <code>task_settings</code> are checked for keys for template replacement. Template replacement is supported in the <code>request</code>, <code>headers</code>, <code>url</code>, and <code>query_parameters</code>.
+          If the definition (key) is not found for a template, an error message is returned.
+          In case of an endpoint definition like the following:</p>
+          <pre><code>PUT _inference/text_embedding/test-text-embedding
+          {
+            &quot;service&quot;: &quot;custom&quot;,
+            &quot;service_settings&quot;: {
+               &quot;secret_parameters&quot;: {
+                    &quot;api_key&quot;: &quot;&lt;some api key&gt;&quot;
+               },
+               &quot;url&quot;: &quot;...endpoints.huggingface.cloud/v1/embeddings&quot;,
+               &quot;headers&quot;: {
+                   &quot;Authorization&quot;: &quot;Bearer ${api_key}&quot;,
+                   &quot;Content-Type&quot;: &quot;application/json&quot;
+               },
+               &quot;request&quot;: &quot;{\\&quot;input\\&quot;: ${input}}&quot;,
+               &quot;response&quot;: {
+                   &quot;json_parser&quot;: {
+                       &quot;text_embeddings&quot;:&quot;$.data[*].embedding[*]&quot;
+                   }
+               }
+            }
+          }
+          </code></pre>
+          <p>To replace <code>${api_key}</code> the <code>secret_parameters</code> and <code>task_settings</code> are checked for a key named <code>api_key</code>.</p>
+          <blockquote>
+          <p>info
+          Templates should not be surrounded by quotes.</p>
+          </blockquote>
+          <p>Pre-defined templates:</p>
+          <ul>
+          <li><code>${input}</code> refers to the array of input strings that comes from the <code>input</code> field of the subsequent inference requests.</li>
+          <li><code>${input_type}</code> refers to the input type translation values.</li>
+          <li><code>${query}</code> refers to the query field used specifically for reranking tasks.</li>
+          <li><code>${top_n}</code> refers to the <code>top_n</code> field available when performing rerank requests.</li>
+          <li><code>${return_documents}</code> refers to the <code>return_documents</code> field available when performing rerank requests.</li>
+          </ul>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-put-custom>`_
+
+        :param task_type: The type of the inference task that the model will perform.
+        :param custom_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            this case, `custom`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `custom` service.
+        :param chunking_settings: The chunking configuration object.
+        :param task_settings: Settings to configure the inference task. These settings
+            are specific to the task type you specified.
+        """
+        if task_type in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'task_type'")
+        if custom_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'custom_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),
+            "custom_inference_id": _quote(custom_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["custom_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 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
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["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_custom",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("service", "service_settings", "chunking_settings"),
+    )
+    async def put_deepseek(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["chat_completion", "completion"]],
+        deepseek_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["deepseek"]]] = 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,
+        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 DeepSeek inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>deepseek</code> service.</p>
+
+
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-deepseek.html>`_
+
+        :param task_type: The type of the inference task that the model will perform.
+        :param deepseek_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            this case, `deepseek`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `deepseek` service.
+        :param chunking_settings: The chunking configuration object.
+        :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 deepseek_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'deepseek_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),
+            "deepseek_inference_id": _quote(deepseek_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["deepseek_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 not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["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_deepseek",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         body_fields=(
             "service",
@@ -933,6 +1288,7 @@ class InferenceClient(NamespacedClient):
         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]:
         """
@@ -955,7 +1311,7 @@ class InferenceClient(NamespacedClient):
           Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-elasticsearch.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-elasticsearch.html>`_
 
         :param task_type: The type of the inference task that the model will perform.
         :param elasticsearch_inference_id: The unique identifier of the inference endpoint.
@@ -967,6 +1323,8 @@ class InferenceClient(NamespacedClient):
         :param chunking_settings: The chunking configuration object.
         :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
+            to be created.
         """
         if task_type in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'task_type'")
@@ -993,6 +1351,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -1032,6 +1392,7 @@ class InferenceClient(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[str, t.Literal[-1], t.Literal[0]]] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -1055,7 +1416,7 @@ class InferenceClient(NamespacedClient):
           Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-elser.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-elser.html>`_
 
         :param task_type: The type of the inference task that the model will perform.
         :param elser_inference_id: The unique identifier of the inference endpoint.
@@ -1064,6 +1425,8 @@ class InferenceClient(NamespacedClient):
         :param service_settings: Settings used to install the inference model. These
             settings are specific to the `elser` service.
         :param chunking_settings: The chunking configuration object.
+        :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'")
@@ -1088,6 +1451,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -1125,6 +1490,7 @@ class InferenceClient(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[str, t.Literal[-1], t.Literal[0]]] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -1132,14 +1498,9 @@ class InferenceClient(NamespacedClient):
 
           <p>Create an Google AI Studio inference endpoint.</p>
           <p>Create an inference endpoint to perform an inference task with the <code>googleaistudio</code> service.</p>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-google-ai-studio.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-google-ai-studio.html>`_
 
         :param task_type: The type of the inference task that the model will perform.
         :param googleaistudio_inference_id: The unique identifier of the inference endpoint.
@@ -1148,6 +1509,8 @@ class InferenceClient(NamespacedClient):
         :param service_settings: Settings used to install the inference model. These
             settings are specific to the `googleaistudio` service.
         :param chunking_settings: The chunking configuration object.
+        :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'")
@@ -1174,6 +1537,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -1207,7 +1572,9 @@ class InferenceClient(NamespacedClient):
     async def put_googlevertexai(
         self,
         *,
-        task_type: t.Union[str, t.Literal["rerank", "text_embedding"]],
+        task_type: t.Union[
+            str, t.Literal["chat_completion", "completion", "rerank", "text_embedding"]
+        ],
         googlevertexai_inference_id: str,
         service: t.Optional[t.Union[str, t.Literal["googlevertexai"]]] = None,
         service_settings: t.Optional[t.Mapping[str, t.Any]] = None,
@@ -1217,6 +1584,7 @@ class InferenceClient(NamespacedClient):
         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]:
         """
@@ -1224,14 +1592,9 @@ class InferenceClient(NamespacedClient):
 
           <p>Create a Google Vertex AI inference endpoint.</p>
           <p>Create an inference endpoint to perform an inference task with the <code>googlevertexai</code> service.</p>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-google-vertex-ai.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-google-vertex-ai.html>`_
 
         :param task_type: The type of the inference task that the model will perform.
         :param googlevertexai_inference_id: The unique identifier of the inference endpoint.
@@ -1242,6 +1605,8 @@ class InferenceClient(NamespacedClient):
         :param chunking_settings: The chunking configuration object.
         :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
+            to be created.
         """
         if task_type in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'task_type'")
@@ -1268,6 +1633,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -1293,12 +1660,19 @@ class InferenceClient(NamespacedClient):
         )
 
     @_rewrite_parameters(
-        body_fields=("service", "service_settings", "chunking_settings"),
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
     )
     async def put_hugging_face(
         self,
         *,
-        task_type: t.Union[str, t.Literal["text_embedding"]],
+        task_type: t.Union[
+            str, t.Literal["chat_completion", "completion", "rerank", "text_embedding"]
+        ],
         huggingface_inference_id: str,
         service: t.Optional[t.Union[str, t.Literal["hugging_face"]]] = None,
         service_settings: t.Optional[t.Mapping[str, t.Any]] = None,
@@ -1307,17 +1681,22 @@ class InferenceClient(NamespacedClient):
         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 a Hugging Face inference endpoint.</p>
-          <p>Create an inference endpoint to perform an inference task with the <code>hugging_face</code> service.</p>
-          <p>You must first create an inference endpoint on the Hugging Face endpoint page to get an endpoint URL.
-          Select the model you want to use on the new endpoint creation page (for example <code>intfloat/e5-small-v2</code>), then select the sentence embeddings task under the advanced configuration section.
-          Create the endpoint and copy the URL after the endpoint initialization has been finished.</p>
-          <p>The following models are recommended for the Hugging Face service:</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>hugging_face</code> service.
+          Supported tasks include: <code>text_embedding</code>, <code>completion</code>, and <code>chat_completion</code>.</p>
+          <p>To configure the endpoint, first visit the Hugging Face Inference Endpoints page and create a new endpoint.
+          Select a model that supports the task you intend to use.</p>
+          <p>For Elastic's <code>text_embedding</code> task:
+          The selected model must support the <code>Sentence Embeddings</code> task. On the new endpoint creation page, select the <code>Sentence Embeddings</code> task under the <code>Advanced Configuration</code> section.
+          After the endpoint has initialized, copy the generated endpoint URL.
+          Recommended models for <code>text_embedding</code> task:</p>
           <ul>
           <li><code>all-MiniLM-L6-v2</code></li>
           <li><code>all-MiniLM-L12-v2</code></li>
@@ -1327,14 +1706,27 @@ class InferenceClient(NamespacedClient):
           <li><code>multilingual-e5-base</code></li>
           <li><code>multilingual-e5-small</code></li>
           </ul>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
+          <p>For Elastic's <code>chat_completion</code> and <code>completion</code> tasks:
+          The selected model must support the <code>Text Generation</code> task and expose OpenAI API. HuggingFace supports both serverless and dedicated endpoints for <code>Text Generation</code>. When creating dedicated endpoint select the <code>Text Generation</code> task.
+          After the endpoint is initialized (for dedicated) or ready (for serverless), ensure it supports the OpenAI API and includes <code>/v1/chat/completions</code> part in URL. Then, copy the full endpoint URL for use.
+          Recommended models for <code>chat_completion</code> and <code>completion</code> tasks:</p>
+          <ul>
+          <li><code>Mistral-7B-Instruct-v0.2</code></li>
+          <li><code>QwQ-32B</code></li>
+          <li><code>Phi-3-mini-128k-instruct</code></li>
+          </ul>
+          <p>For Elastic's <code>rerank</code> task:
+          The selected model must support the <code>sentence-ranking</code> task and expose OpenAI API.
+          HuggingFace supports only dedicated (not serverless) endpoints for <code>Rerank</code> so far.
+          After the endpoint is initialized, copy the full endpoint URL for use.
+          Tested models for <code>rerank</code> task:</p>
+          <ul>
+          <li><code>bge-reranker-base</code></li>
+          <li><code>jina-reranker-v1-turbo-en-GGUF</code></li>
+          </ul>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-hugging-face.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-hugging-face.html>`_
 
         :param task_type: The type of the inference task that the model will perform.
         :param huggingface_inference_id: The unique identifier of the inference endpoint.
@@ -1343,6 +1735,10 @@ class InferenceClient(NamespacedClient):
         :param service_settings: Settings used to install the inference model. These
             settings are specific to the `hugging_face` service.
         :param chunking_settings: The chunking configuration object.
+        :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
+            to be created.
         """
         if task_type in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'task_type'")
@@ -1369,6 +1765,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -1376,6 +1774,8 @@ class InferenceClient(NamespacedClient):
                 __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
         if not __body:
             __body = None  # type: ignore[assignment]
         __headers = {"accept": "application/json"}
@@ -1412,6 +1812,7 @@ class InferenceClient(NamespacedClient):
         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]:
         """
@@ -1421,14 +1822,9 @@ class InferenceClient(NamespacedClient):
           <p>Create an inference endpoint to perform an inference task with the <code>jinaai</code> service.</p>
           <p>To review the available <code>rerank</code> models, refer to <a href="https://jina.ai/reranker">https://jina.ai/reranker</a>.
           To review the available <code>text_embedding</code> models, refer to the <a href="https://jina.ai/embeddings/">https://jina.ai/embeddings/</a>.</p>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-jinaai.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-jinaai.html>`_
 
         :param task_type: The type of the inference task that the model will perform.
         :param jinaai_inference_id: The unique identifier of the inference endpoint.
@@ -1439,6 +1835,8 @@ class InferenceClient(NamespacedClient):
         :param chunking_settings: The chunking configuration object.
         :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
+            to be created.
         """
         if task_type in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'task_type'")
@@ -1463,6 +1861,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -1493,7 +1893,9 @@ class InferenceClient(NamespacedClient):
     async def put_mistral(
         self,
         *,
-        task_type: t.Union[str, t.Literal["text_embedding"]],
+        task_type: t.Union[
+            str, t.Literal["chat_completion", "completion", "text_embedding"]
+        ],
         mistral_inference_id: str,
         service: t.Optional[t.Union[str, t.Literal["mistral"]]] = None,
         service_settings: t.Optional[t.Mapping[str, t.Any]] = None,
@@ -1502,30 +1904,27 @@ class InferenceClient(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[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 Mistral inference endpoint.</p>
-          <p>Creates an inference endpoint to perform an inference task with the <code>mistral</code> service.</p>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>mistral</code> service.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/{brnach}/infer-service-mistral.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-mistral.html>`_
 
-        :param task_type: The task type. The only valid task type for the model to perform
-            is `text_embedding`.
+        :param task_type: The type of the inference task that the model will perform.
         :param mistral_inference_id: The unique identifier of the inference endpoint.
         :param service: The type of service supported for the specified task type. In
             this case, `mistral`.
         :param service_settings: Settings used to install the inference model. These
             settings are specific to the `mistral` service.
         :param chunking_settings: The chunking configuration object.
+        :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'")
@@ -1550,6 +1949,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -1595,6 +1996,7 @@ class InferenceClient(NamespacedClient):
         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]:
         """
@@ -1602,14 +2004,9 @@ class InferenceClient(NamespacedClient):
 
           <p>Create an OpenAI inference endpoint.</p>
           <p>Create an inference endpoint to perform an inference task with the <code>openai</code> service or <code>openai</code> compatible APIs.</p>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-openai.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-openai.html>`_
 
         :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
@@ -1622,6 +2019,8 @@ class InferenceClient(NamespacedClient):
         :param chunking_settings: The chunking configuration object.
         :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
+            to be created.
         """
         if task_type in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'task_type'")
@@ -1646,6 +2045,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -1691,6 +2092,7 @@ class InferenceClient(NamespacedClient):
         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]:
         """
@@ -1701,7 +2103,7 @@ class InferenceClient(NamespacedClient):
           <p>Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-voyageai.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-voyageai.html>`_
 
         :param task_type: The type of the inference task that the model will perform.
         :param voyageai_inference_id: The unique identifier of the inference endpoint.
@@ -1712,6 +2114,8 @@ class InferenceClient(NamespacedClient):
         :param chunking_settings: The chunking configuration object.
         :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
+            to be created.
         """
         if task_type in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'task_type'")
@@ -1736,6 +2140,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -1774,6 +2180,7 @@ class InferenceClient(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[str, t.Literal[-1], t.Literal[0]]] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -1783,14 +2190,9 @@ class InferenceClient(NamespacedClient):
           <p>Create an inference endpoint to perform an inference task with the <code>watsonxai</code> service.
           You need an IBM Cloud Databases for Elasticsearch deployment to use the <code>watsonxai</code> inference service.
           You can provision one through the IBM catalog, the Cloud Databases CLI plug-in, the Cloud Databases API, or Terraform.</p>
-          <p>When you create an inference endpoint, the associated machine learning model is automatically deployed if it is not already running.
-          After creating the endpoint, wait for the model deployment to complete before using it.
-          To verify the deployment status, use the get trained model statistics API.
-          Look for <code>&quot;state&quot;: &quot;fully_allocated&quot;</code> in the response and ensure that the <code>&quot;allocation_count&quot;</code> matches the <code>&quot;target_allocation_count&quot;</code>.
-          Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/infer-service-watsonx-ai.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/infer-service-watsonx-ai.html>`_
 
         :param task_type: The task type. The only valid task type for the model to perform
             is `text_embedding`.
@@ -1799,6 +2201,8 @@ class InferenceClient(NamespacedClient):
             this case, `watsonxai`.
         :param service_settings: Settings used to install the inference model. These
             settings are specific to the `watsonxai` 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'")
@@ -1823,6 +2227,8 @@ class InferenceClient(NamespacedClient):
             __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
@@ -1863,10 +2269,10 @@ class InferenceClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Perform rereanking inference on the service</p>
+          <p>Perform reranking inference on the service</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/post-inference-api.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/post-inference-api.html>`_
 
         :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
@@ -1942,7 +2348,7 @@ class InferenceClient(NamespacedClient):
           <p>Perform sparse embedding inference on the service</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/post-inference-api.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/post-inference-api.html>`_
 
         :param inference_id: The inference Id
         :param input: Inference input. Either a string or an array of strings.
@@ -2010,7 +2416,7 @@ class InferenceClient(NamespacedClient):
           <p>Perform text embedding inference on the service</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/post-inference-api.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/post-inference-api.html>`_
 
         :param inference_id: The inference Id
         :param input: Inference input. Either a string or an array of strings.
@@ -2092,7 +2498,7 @@ class InferenceClient(NamespacedClient):
           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>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.18/update-inference-api.html>`_
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.19/update-inference-api.html>`_
 
         :param inference_id: The unique identifier of the inference endpoint.
         :param inference_config: